Sync missing files (lean, preprints, history.md); remove stale build artifacts (part 13)

.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

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

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

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

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

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<x b) :
+    0 < simpleReflection M a x a := by
+  have hc : cartan M a b<0 :=
+    lt_of_le_of_ne (cartan_off_nonpos M a b hab) (cartan_ne_zero_of_not_commuting M a b hab hm)
+  have hrow : (cartan M *ᵥ x) a<0 := by
+    change (∑ j, cartan M a j*x j)<0
+    have hsum := Finset.sum_lt_sum (s := (Finset.univ : Finset S))
+      (f := fun j => 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.
+-/

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

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

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

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<N ∧ ∀ v p, meshPathEvaluate G B N v p=0 := by
+  by_cases hedge : ∃ u v, G.Adj u v
+  · obtain ⟨μ,d,hμ,hd0,hd2,heigen⟩ := mesh_graph_positive_weights G hG hedge hcartan
+    exact allPlus_mesh_paths_vanish G μ hμ d hd0 hd2 heigen B hmesh
+  · refine ⟨1,by omega,?_⟩
+    intro v p
+    exact (hedge ⟨p.1.val,v,p.1.property⟩).elim
+
+omit [Fintype V] [Algebra ℂ R] in
+lemma meshPathEvaluate_longer (B : ∀ u v, G.Adj u v → R) (N : ℕ)
+    (hN : ∀ v p, meshPathEvaluate G B N v p=0) :
+    ∀ n, N≤n → ∀ v p, meshPathEvaluate G B n v p=0 := by
+  intro n hn
+  obtain ⟨k,rfl⟩ := Nat.exists_eq_add_of_le hn
+  induction k with
+  | zero => 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<N ∧ ∀ v p, meshPathEvaluate G B N v p=0 := by
+  have hC (C : G.ConnectedComponent) : ∃ N : ℕ, 0<N ∧
+      ∀ v p, meshPathEvaluate C.toSimpleGraph (fun u v h => 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

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<y v := by
+  have hzero_adj {u v : V} (hadj : G.Adj u v) (hu : y u=0) : y v=0 := by
+    have hs : (∑ w : {w : V // G.Adj w u}, y w)=0 := by
+      have h := congrFun heigen u
+      rw [mesh_adjacency_sum] at h
+      simpa only [Pi.smul_apply,smul_eq_mul,hu,mul_zero] using h
+    exact (Finset.sum_eq_zero_iff_of_nonneg
+      (fun (w : {w : V // G.Adj w u}) _ => 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<d ∧ d<2 ∧
+      ∀ v, (∑ u : {u : V // G.Adj u v}, μ u)=d*μ v := by
+  let : Nonempty V := hG.nonempty
+  have hsym : (G.adjMatrix ℝ).IsHermitian := by
+    rw [Matrix.isHermitian_iff_isSymm]
+    exact G.isSymm_adjMatrix
+  have hentries : ∀ u v, 0≤G.adjMatrix ℝ u v := by
+    intro u v
+    simp only [SimpleGraph.adjMatrix_apply]
+    split_ifs <;> 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<d := by
+    rw [heq] at hsum
+    exact (mul_pos_iff.mp hsum).resolve_right (by intro h; exact (not_lt_of_ge (hμ v).le) h.2) |>.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

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

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

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

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

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

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<a) (hb : 0<b) :
+    Real.sqrt (a/b)*(Real.sqrt a)⁻¹*(Real.sqrt b)⁻¹=b⁻¹ := by
+  rw [Real.sqrt_div ha.le]
+  have hsa := ne_of_gt (Real.sqrt_pos.mpr ha)
+  have hsb := ne_of_gt (Real.sqrt_pos.mpr hb)
+  calc
+    _ = ((Real.sqrt b)^2)⁻¹ := by field_simp
+    _ = b⁻¹ := by rw [Real.sq_sqrt hb.le]
+
+noncomputable def meshRescale (μ : V → ℝ) (B : ∀ u v, G.Adj u v → R)
+    (u v : V) (h : G.Adj u v) : R :=
+  ((Real.sqrt (μ v))⁻¹ : ℂ) • B u v h
+
+lemma meshRescale_relation (μ : V → ℝ) (hμ : ∀ v, 0<μ 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) (v : V) :
+    (∑ u : {u : V // G.Adj u v}, (Real.sqrt (μ u/μ v) : ℂ) •
+      (meshRescale G μ B v u.val u.property.symm * meshRescale G μ B u.val v u.property))=0 := by
+  have hc (u : {u : V // G.Adj u v}) :
+      (Real.sqrt (μ u/μ v) : ℂ) * ((Real.sqrt (μ v))⁻¹ : ℂ) *
+        ((Real.sqrt (μ u))⁻¹ : ℂ)=(μ v)⁻¹ := by
+    calc
+      _ = (Real.sqrt (μ u/μ v) : ℂ) * ((Real.sqrt (μ u))⁻¹ : ℂ) *
+          ((Real.sqrt (μ v))⁻¹ : ℂ) := by ring
+      _ = _ := by exact_mod_cast mesh_normalization_weight (μ u) (μ v) (hμ u) (hμ v)
+  simp only [meshRescale,smul_mul_assoc,mul_smul_comm,smul_smul]
+  simp only [←mul_assoc,hc]
+  rw [←Finset.smul_sum,hmesh,smul_zero]
+
+noncomputable def meshPathScale (μ : V → ℝ) :
+    (n : ℕ) → (v : V) → MeshPaths G n v → ℂ
+  | 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<N ∧ ∀ v p, meshPathEvaluate G B N v p=0 := by
+  obtain ⟨N,hN,hzero⟩ := weighted_mesh_paths_vanish G μ hμ δ hδ0 hδ2 heigen
+    (meshRescale G μ B) (meshRescale_relation G μ hμ B hmesh)
+  refine ⟨N,hN,?_⟩
+  intro v p
+  have h := hzero v p
+  rw [meshRescale_evaluate] at h
+  exact (smul_eq_zero.mp h).resolve_left (meshPathScale_ne_zero G μ hμ N v p)
+
+end HarmonicArtin.ParabolicIntersections
+
+end OAI

lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshPathEvaluation.lean

@@ -0,0 +1,115 @@
+import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshProjectionCutoff
+import OAI.Topology.ArtinGroups.ParabolicIntersections.MeshMatrixAction
+
+namespace OAI
+
+/-! Weighted mesh relations annihilate sufficiently long actual paths. -/
+namespace HarmonicArtin.ParabolicIntersections
+attribute [local instance] Classical.decEq Classical.propDecidable
+variable {V R : Type} [Fintype V] (G : SimpleGraph V)
+variable [Ring R] [Algebra ℂ R]
+
+def meshPathEvaluate (B : ∀ u v, G.Adj u v → R) :
+    (n : ℕ) → (v : V) → MeshPaths G n v → R
+  | 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<N ∧ ∀ v p, meshPathEvaluate G B N v p=0 := by
+  obtain ⟨N,hN,hzero⟩ := meshProjection_eventually_zero G μ hμ δ hδ0 hδ2 heigen
+  refine ⟨N,hN,?_⟩
+  intro v p
+  have h := meshPathEvaluate_projection G μ δ B hmesh N v
+  rw [hzero,meshApply_zero] at h
+  exact (congrFun h p).symm
+
+end HarmonicArtin.ParabolicIntersections
+
+end OAI

lean/OAI/Topology/ArtinGroups/ParabolicIntersections/MeshPathSpaces.lean

@@ -0,0 +1,57 @@
+import Mathlib
+
+namespace OAI
+
+/-! The actual finite path spaces and weighted last-backtrack contractions. -/
+namespace HarmonicArtin.ParabolicIntersections
+attribute [local instance] Classical.decEq Classical.propDecidable
+variable {V : Type} (G : SimpleGraph V)
+
+/-- Paths of length `n`, indexed by their final vertex. The recursive
+presentation makes extension of prefix operators a block-diagonal map. -/
+def MeshPaths : ℕ → V → Type
+  | 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

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

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

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

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<H → meshWeightedTrace μ (meshProjection G μ δ n)=
+      (meshQuantum δ (n+1) : ℂ)*∑ v, (μ v : ℂ) := by
+  intro n
+  induction n using Nat.twoStepInduction with
+  | zero =>
+    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<N ∧ ∀ v, meshProjection G μ δ N v=0 := by
+  obtain ⟨H,hH,hq,hpos⟩ := meshQuantum_cutoff δ hδ0 hδ2
+  let N := H-1
+  have hN : 0<N := by dsimp [N]; omega
+  have hNH : N<H := by dsimp [N]; omega
+  have hstage := meshProjectionStage_before_cutoff G μ hμ δ heigen H hpos (H-2) (by omega)
+  have hlen : H-2+1=N := by dsimp [N]; omega
+  have hstar : ∀ v, (meshProjection G μ δ N v).conjTranspose=meshProjection G μ δ N v := by
+    rw [←hlen]
+    exact hstage.upper_star
+  have hsq : ∀ v, meshProjection G μ δ N v*meshProjection G μ δ N v=
+      meshProjection G μ δ N v := by
+    rw [←hlen]
+    exact hstage.upper_square
+  have hw := meshProjection_weightedTrace G μ hμ δ heigen H hpos N hNH
+  rw [show N+1=H by dsimp [N]; omega] at hw
+  have hnonneg := meshWeightedTrace_nonneg μ (fun v => (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

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<H → MeshProjectionStage G μ δ n := by
+  intro n
+  induction n with
+  | zero => 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

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<n ∧ q n≤0 := by
+  by_contra hex
+  have hpos : ∀ n, 0<n → 0<q n := by
+    intro n hn
+    by_contra hq
+    exact hex ⟨n,hn,le_of_not_gt hq⟩
+  have hnonneg : ∀ n, 0≤q n := by
+    intro n
+    cases n with
+    | zero => 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<n → n<h → 0<q n := by
+  classical
+  have hex := mesh_quantum_eventually_nonpositive δ hδ2 q hzero hone hrec
+  let h := Nat.find hex
+  have hh : 0<h ∧ q h≤0 := Nat.find_spec hex
+  have hp : ∀ n, 0<n → n<h → 0<q n := by
+    intro n hn hnh
+    have hnot := Nat.find_min hex hnh
+    exact lt_of_not_ge (fun hqn => 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