import OAI.Analysis.DiamondDistortion.SegmentNorm

namespace OAI

universe u v

noncomputable section
open scoped BigOperators Classical Topology
open Set

namespace DiamondDistortion

/-- A finite interval in an ancestral order.  This keeps the root in every tree. -/
def intervalSystem {ι : Type*} (r : ι → ι → Prop)
    (hrefl : ∀ a, r a a) (hanti : ∀ a b, r a b → r b a → a = b) : SegmentSystem ι where
  IsSegment s := ∃ a b, r a b ∧ ∀ v, v ∈ s ↔ r a v ∧ r v b
  singleton v := by
    refine ⟨v, v, hrefl v, ?_⟩
    intro w
    simp only [Finset.mem_singleton]
    constructor
    · rintro rfl
      exact ⟨hrefl _, hrefl _⟩
    · intro h
      exact hanti w v h.2 h.1

/-- An ancestral partial order: the predecessors of any vertex form a chain. -/
class Ancestry (ι : Type*) extends PartialOrder ι where
  predecessors_total : ∀ {a b c : ι}, le a c → le b c → le a b ∨ le b a

namespace Ancestry
open scoped Classical
variable {ι : Type*} [A : Ancestry ι]
local instance : PartialOrder ι := A.toPartialOrder

/-- Nonempty finite intervals for an ancestral order. -/
def segments : SegmentSystem ι :=
  intervalSystem (· ≤ ·) (fun _ => le_rfl) (fun _ _ => le_antisymm)

/-- Downward closed sets are precisely ancestral heads. -/
def Ancestral (H : Set ι) : Prop := ∀ ⦃a b : ι⦄, a ≤ b → b ∈ H → a ∈ H

lemma ancestral_not_above (c : ι) : A.Ancestral {v | ¬ c ≤ v} := by
  intro a b hab hb ha
  exact hb (ha.trans hab)

lemma interval_chain {S : Finset ι} (hS : A.segments.IsSegment S) :
    ∀ a ∈ S, ∀ b ∈ S, a ≤ b ∨ b ≤ a := by
  obtain ⟨l, r, _, hmem⟩ := hS
  intro a ha b hb
  exact A.predecessors_total ((hmem a).mp ha).2 ((hmem b).mp hb).2

lemma segment_filter_head {S : Finset ι} (hS : A.segments.IsSegment S)
    {H : Set ι} (hH : A.Ancestral H) :
    (S.filter (· ∈ H)).Nonempty → A.segments.IsSegment (S.filter (· ∈ H)) := by
  classical
  intro hne
  obtain ⟨c, hc, hmax⟩ := Finset.exists_maximal hne
  have hcS : c ∈ S := (Finset.mem_filter.mp hc).1
  have hcH : c ∈ H := (Finset.mem_filter.mp hc).2
  have hgreat : ∀ v ∈ S.filter (· ∈ H), v ≤ c := by
    intro v hv
    rcases A.interval_chain hS c hcS v (Finset.mem_filter.mp hv).1 with h | h
    · exact hmax hv h
    · exact h
  obtain ⟨a, b, hab, hmem⟩ := hS
  refine ⟨a, c, ((hmem c).mp hcS).1, ?_⟩
  intro v
  simp only [Finset.mem_filter]
  constructor
  · intro hv
    exact ⟨((hmem v).mp hv.1).1, hgreat v (Finset.mem_filter.mpr hv)⟩
  · intro hv
    exact ⟨(hmem v).mpr ⟨hv.1, hv.2.trans ((hmem c).mp hcS).2⟩, hH hv.2 hcH⟩

lemma segment_filter_tail {S : Finset ι} (hS : A.segments.IsSegment S)
    {H : Set ι} (hH : A.Ancestral H) :
    (S.filter (· ∉ H)).Nonempty → A.segments.IsSegment (S.filter (· ∉ H)) := by
  classical
  intro hne
  obtain ⟨c, hc, hmin⟩ := Finset.exists_minimal hne
  have hcS : c ∈ S := (Finset.mem_filter.mp hc).1
  have hcH : c ∉ H := (Finset.mem_filter.mp hc).2
  have hleast : ∀ v ∈ S.filter (· ∉ H), c ≤ v := by
    intro v hv
    rcases A.interval_chain hS c hcS v (Finset.mem_filter.mp hv).1 with h | h
    · exact h
    · exact hmin hv h
  obtain ⟨a, b, hab, hmem⟩ := hS
  refine ⟨c, b, ((hmem c).mp hcS).2, ?_⟩
  intro v
  simp only [Finset.mem_filter]
  constructor
  · intro hv
    exact ⟨hleast v (Finset.mem_filter.mpr hv), ((hmem v).mp hv.1).2⟩
  · intro hv
    refine ⟨(hmem v).mpr ⟨((hmem c).mp hcS).1.trans hv.1, hv.2⟩, ?_⟩
    exact fun hvH => hcH (hH hv.1 hvH)

/-- Splitting each member of a disjoint family at its own ancestral cut preserves
    the testing budget. This is the simultaneous, not one-gate-at-a-time, estimate. -/
lemma split_energy_le (F : A.segments.Family) (H : Fin F.n → Set ι)
    (hH : ∀ i, A.Ancestral (H i)) (u : ι →₀ ℝ) :
    (∑ i, ((∑ v ∈ (F.seg i).filter (· ∈ H i), u v) ^ 2 +
      (∑ v ∈ (F.seg i).filter (· ∉ H i), u v) ^ 2)) ≤
      (A.segments.primalSeminorm u) ^ 2 := by
  classical
  let P : Fin F.n × Bool → Finset ι := fun z =>
    if z.2 then (F.seg z.1).filter (· ∉ H z.1) else (F.seg z.1).filter (· ∈ H z.1)
  have hp : ∀ z, (P z).Nonempty → A.segments.IsSegment (P z) := by
    rintro ⟨i, b⟩
    cases b
    · exact A.segment_filter_head (F.allowed i) (hH i)
    · exact A.segment_filter_tail (F.allowed i) (hH i)
  have hs : ∀ z, P z ⊆ F.seg z.1 := by
    rintro ⟨i, b⟩
    cases b <;> exact Finset.filter_subset _ _
  have hd : Pairwise (fun z w => Disjoint (P z) (P w)) := by
    intro z w hzw
    by_cases h : z.1 = w.1
    · obtain ⟨i, b⟩ := z
      obtain ⟨j, c⟩ := w
      dsimp at h
      subst j
      apply Finset.disjoint_left.mpr
      intro v hv hw
      cases b <;> cases c
      · exact hzw rfl
      · simp only [P, Bool.false_eq_true, ↓reduceIte, Finset.mem_filter] at hv hw
        exact hw.2 hv.2
      · simp only [P, Bool.false_eq_true, ↓reduceIte, Finset.mem_filter] at hv hw
        exact hv.2 hw.2
      · exact hzw rfl
    · exact (F.disjoint h).mono (hs z) (hs w)
  have he := A.segments.test_energy_le_allow_empty P hp hd u
  simpa only [Fintype.sum_prod_type, Fintype.sum_bool, P, Bool.false_eq_true, ↓reduceIte,
    add_comm] using he

/-- The explicit increase in the squared test after simultaneous splitting. -/
lemma split_gain_le (F : A.segments.Family) (H : Fin F.n → Set ι)
    (hH : ∀ i, A.Ancestral (H i)) (u : ι →₀ ℝ) :
    (∑ i, (∑ v ∈ F.seg i, u v) ^ 2) +
      2 * (∑ i : Fin F.n, ((∑ v ∈ (F.seg i).filter (· ∉ H i), u v) ^ 2 -
        (∑ v ∈ F.seg i, u v) * (∑ v ∈ (F.seg i).filter (· ∉ H i), u v))) ≤
        (A.segments.primalSeminorm u) ^ 2 := by
  classical
  have he := A.split_energy_le F H hH u
  have hp (i : Fin F.n) :
      (∑ v ∈ (F.seg i).filter (· ∈ H i), u v) +
      (∑ v ∈ (F.seg i).filter (· ∉ H i), u v) = ∑ v ∈ F.seg i, u v := by
    rw [Finset.sum_filter, Finset.sum_filter, ← Finset.sum_add_distrib]
    apply Finset.sum_congr rfl
    intro v hv
    by_cases h : v ∈ H i <;> simp [h]
  convert he using 1
  rw [Finset.mul_sum, ← Finset.sum_add_distrib]
  apply Finset.sum_congr rfl
  intro i hi
  rw [← hp i]
  ring

/-- A minimal vertex outside a head. Gates in a tree form an antichain. -/
def Gate (H : Set ι) (g : ι) : Prop :=
  g ∉ H ∧ ∀ v, v < g → v ∈ H

lemma gates_eq_of_le {H : Set ι} {g h : ι} (hg : A.Gate H g)
    (hh : A.Gate H h) (hgh : g ≤ h) : g = h := by
  by_contra hne
  exact hg.1 (hh.2 g (lt_of_le_of_ne hgh hne))

lemma gates_eq_of_common_upper {H : Set ι} {g h v : ι} (hg : A.Gate H g)
    (hh : A.Gate H h) (hgv : g ≤ v) (hhv : h ≤ v) : g = h := by
  rcases A.predecessors_total hgv hhv with h | h
  · exact A.gates_eq_of_le hg hh h
  · exact (A.gates_eq_of_le hh hg h).symm

lemma gate_unique_in_segment {H : Set ι} {S : Finset ι}
    (hS : A.segments.IsSegment S) {g h : ι} (hg : A.Gate H g)
    (hh : A.Gate H h) (hgS : g ∈ S) (hhS : h ∈ S) : g = h := by
  rcases A.interval_chain hS g hgS h hhS with h | h
  · exact A.gates_eq_of_le hg hh h
  · exact (A.gates_eq_of_le hh hg h).symm

lemma exists_gate_le {H : Set ι} {K : Finset ι} (hK : A.Ancestral (K : Set ι))
    {v : ι} (hvK : v ∈ K) (hvH : v ∉ H) :
    ∃ g ∈ K, A.Gate H g ∧ g ≤ v := by
  classical
  let S := K.filter (fun a => a ≤ v ∧ a ∉ H)
  have hvS : v ∈ S := by simp [S, hvK, hvH]
  obtain ⟨g, hg, hmin⟩ := Finset.exists_minimal ⟨v, hvS⟩
  have hgK := (Finset.mem_filter.mp hg).1
  have hgv := (Finset.mem_filter.mp hg).2.1
  have hgH := (Finset.mem_filter.mp hg).2.2
  refine ⟨g, hgK, ⟨hgH, ?_⟩, hgv⟩
  intro a hag
  by_contra haH
  have haS : a ∈ S := by
    exact Finset.mem_filter.mpr ⟨hK hag.le hgK, hag.le.trans hgv, haH⟩
  exact (not_le_of_gt hag) (hmin haS hag.le)

/-- Canonical lower endpoint; no ordering is imposed on segment families. -/
def first (F : A.segments.Family) (i : Fin F.n) : ι :=
  Classical.choose (F.allowed i)

lemma first_spec (F : A.segments.Family) (i : Fin F.n) :
    ∃ b, A.first F i ≤ b ∧ ∀ v, v ∈ F.seg i ↔ A.first F i ≤ v ∧ v ≤ b :=
  Classical.choose_spec (F.allowed i)

lemma first_le_of_mem (F : A.segments.Family) (i : Fin F.n) {v : ι}
    (hv : v ∈ F.seg i) : A.first F i ≤ v := by
  obtain ⟨b, _, hm⟩ := A.first_spec F i
  exact ((hm v).mp hv).1

lemma first_mem (F : A.segments.Family) (i : Fin F.n) : A.first F i ∈ F.seg i := by
  obtain ⟨b, hb, hm⟩ := A.first_spec F i
  exact (hm _).mpr ⟨le_rfl, hb⟩

/-- Two heads through a common exterior vertex are nested; cutting the longer
    at the shorter's first vertex preserves exactly the shorter head sum. -/
lemma crossing_cut_sum {H : Set ι} (hH : A.Ancestral H) (p : ι →₀ ℝ)
    (hp : ∀ v, v ∉ H → p v = 0) (F G : A.segments.Family)
    (i : Fin F.n) (j : Fin G.n) {g : ι} (hg : g ∉ H)
    (hgF : g ∈ F.seg i) (hgG : g ∈ G.seg j)
    (hfirst : A.first F i ≤ A.first G j) :
    (∑ v ∈ (F.seg i).filter (fun v => A.first G j ≤ v), p v) =
      ∑ v ∈ G.seg j, p v := by
  classical
  obtain ⟨b, hfb, hFm⟩ := A.first_spec F i
  obtain ⟨d, hgd, hGm⟩ := A.first_spec G j
  have hhead : ∀ S, A.segments.IsSegment S → g ∈ S → ∀ v ∈ S, v ∈ H → v ≤ g := by
    intro S hS hgS v hv hvH
    rcases A.interval_chain hS v hv g hgS with h | h
    · exact h
    · exact False.elim (hg (hH h hvH))
  have he : ((F.seg i).filter (fun v => A.first G j ≤ v)).filter (· ∈ H) =
      (G.seg j).filter (· ∈ H) := by
    ext v
    simp only [Finset.mem_filter]
    constructor
    · rintro ⟨⟨hvF, hvfirst⟩, hvH⟩
      refine ⟨(hGm v).mpr ⟨hvfirst, ?_⟩, hvH⟩
      exact (hhead _ (F.allowed i) hgF v hvF hvH).trans ((hGm g).mp hgG).2
    · rintro ⟨hvG, hvH⟩
      have hvg := hhead _ (G.allowed j) hgG v hvG hvH
      exact ⟨⟨(hFm v).mpr ⟨hfirst.trans ((hGm v).mp hvG).1,
        hvg.trans ((hFm g).mp hgF).2⟩, ((hGm v).mp hvG).1⟩, hvH⟩
  have hf (S : Finset ι) : (∑ v ∈ S.filter (· ∈ H), p v) = ∑ v ∈ S, p v := by
    apply Finset.sum_filter_of_ne
    intro v _ hpv
    by_contra hvH
    exact hpv (hp v hvH)
  rw [← hf ((F.seg i).filter (fun v => A.first G j ≤ v)), he, hf]

/-- Zero-extension along a finite injection preserves the finite sum. -/
lemma sum_extend_zero {κ ν : Type*} [Fintype κ] [Fintype ν]
    (e : κ ↪ ν) (f : κ → ℝ) :
    (∑ i, Function.extend e f (fun _ => 0) i) = ∑ a, f a := by
  classical
  let I := Finset.univ.image e
  have hz : ∀ i ∈ Finset.univ, i ∉ I → Function.extend e f (fun _ => 0) i = 0 := by
    intro i _ hi
    apply Function.extend_apply'
    simpa [I] using hi
  rw [← Finset.sum_subset (Finset.subset_univ I) hz,
    Finset.sum_image (fun _ _ _ _ h => e.injective h)]
  apply Finset.sum_congr rfl
  intro a _
  exact e.injective.extend_apply _ _ _

/-- Simultaneous splitting restricted to any injected list of original segments. -/
lemma matched_split_gain_le {κ : Type*} [Fintype κ]
    (F : A.segments.Family) (e : κ ↪ Fin F.n) (c : κ → ι) (p : ι →₀ ℝ) :
    (∑ i, (∑ v ∈ F.seg i, p v) ^ 2) +
      2 * (∑ a, ((∑ v ∈ (F.seg (e a)).filter (fun v => c a ≤ v), p v) ^ 2 -
        (∑ v ∈ F.seg (e a), p v) *
          (∑ v ∈ (F.seg (e a)).filter (fun v => c a ≤ v), p v))) ≤
      (A.segments.primalSeminorm p) ^ 2 := by
  classical
  let H : Fin F.n → Set ι := Function.extend e (fun a => {v | ¬ c a ≤ v}) (fun _ => Set.univ)
  have he (a : κ) : H (e a) = {v | ¬ c a ≤ v} := e.injective.extend_apply _ _ _
  have hout (i : Fin F.n) (hi : ¬ ∃ a, e a = i) : H i = Set.univ :=
    Function.extend_apply' _ _ _ hi
  have hH : ∀ i, A.Ancestral (H i) := by
    intro i
    by_cases hi : ∃ a, e a = i
    · obtain ⟨a, rfl⟩ := hi
      rw [he]
      exact A.ancestral_not_above (c a)
    · rw [hout i hi]
      intro a b _ _
      trivial
  have hb := A.split_gain_le F H hH p
  let q : κ → ℝ := fun a =>
    (∑ v ∈ (F.seg (e a)).filter (fun v => c a ≤ v), p v) ^ 2 -
      (∑ v ∈ F.seg (e a), p v) *
        (∑ v ∈ (F.seg (e a)).filter (fun v => c a ≤ v), p v)
  have hid : (fun i => (∑ v ∈ (F.seg i).filter (· ∉ H i), p v) ^ 2 -
      (∑ v ∈ F.seg i, p v) * (∑ v ∈ (F.seg i).filter (· ∉ H i), p v)) =
        Function.extend e q (fun _ => 0) := by
    funext i
    by_cases hi : ∃ a, e a = i
    · obtain ⟨a, rfl⟩ := hi
      rw [he, e.injective.extend_apply]
      simp [q]
    · rw [hout i hi, Function.extend_apply' _ _ _ hi]
      simp
  rw [hid, sum_extend_zero] at hb
  exact hb

/-- Opposite head sums, matched injectively in both families, spend only the
    combined testing deficits. This is the simultaneous boundary cancellation. -/
lemma opposite_matching_le {κ : Type*} [Fintype κ]
    {H : Set ι} (hH : A.Ancestral H) (p : ι →₀ ℝ)
    (hp : ∀ v, v ∉ H → p v = 0) (F G : A.segments.Family)
    (eF : κ ↪ Fin F.n) (eG : κ ↪ Fin G.n) (g : κ → ι)
    (hgH : ∀ a, g a ∉ H) (hgF : ∀ a, g a ∈ F.seg (eF a))
    (hgG : ∀ a, g a ∈ G.seg (eG a))
    (hopp : ∀ a, (∑ v ∈ F.seg (eF a), p v) * (∑ v ∈ G.seg (eG a), p v) < 0) :
    2 * (∑ a, |(∑ v ∈ F.seg (eF a), p v) * (∑ v ∈ G.seg (eG a), p v)|) ≤
      ((A.segments.primalSeminorm p) ^ 2 - ∑ i, (∑ v ∈ F.seg i, p v) ^ 2) +
      ((A.segments.primalSeminorm p) ^ 2 - ∑ j, (∑ v ∈ G.seg j, p v) ^ 2) := by
  classical
  let P : κ → Prop := fun a => A.first F (eF a) ≤ A.first G (eG a)
  let L := {a : κ // P a}
  let U := {a : κ // ¬ P a}
  let eL : L ↪ Fin F.n := ⟨fun a => eF a.val,
    fun a b h => Subtype.ext (eF.injective h)⟩
  let eU : U ↪ Fin G.n := ⟨fun a => eG a.val,
    fun a b h => Subtype.ext (eG.injective h)⟩
  have hcutL (a : L) :
      (∑ v ∈ (F.seg (eL a)).filter (fun v => A.first G (eG a.val) ≤ v), p v) =
        ∑ v ∈ G.seg (eG a.val), p v :=
    A.crossing_cut_sum hH p hp F G (eF a.val) (eG a.val)
      (hgH a.val) (hgF a.val) (hgG a.val) a.property
  have hcutU (a : U) :
      (∑ v ∈ (G.seg (eU a)).filter (fun v => A.first F (eF a.val) ≤ v), p v) =
        ∑ v ∈ F.seg (eF a.val), p v := by
    have hfirst : A.first G (eG a.val) ≤ A.first F (eF a.val) := by
      rcases A.predecessors_total (A.first_le_of_mem F _ (hgF a.val))
        (A.first_le_of_mem G _ (hgG a.val)) with h | h
      · exact False.elim (a.property h)
      · exact h
    exact A.crossing_cut_sum hH p hp G F (eG a.val) (eF a.val)
      (hgH a.val) (hgG a.val) (hgF a.val) hfirst
  have hF := A.matched_split_gain_le F eL (fun a => A.first G (eG a.val)) p
  have hG := A.matched_split_gain_le G eU (fun a => A.first F (eF a.val)) p
  simp_rw [hcutL] at hF
  simp_rw [hcutU] at hG
  have hL : (∑ a : L, |(∑ v ∈ F.seg (eF a.val), p v) *
      (∑ v ∈ G.seg (eG a.val), p v)|) ≤
      ∑ a : L, ((∑ v ∈ G.seg (eG a.val), p v) ^ 2 -
        (∑ v ∈ F.seg (eL a), p v) * (∑ v ∈ G.seg (eG a.val), p v)) := by
    apply Finset.sum_le_sum
    intro a _
    rw [abs_of_neg (hopp a.val)]
    change -( (∑ v ∈ F.seg (eF a.val), p v) * (∑ v ∈ G.seg (eG a.val), p v)) ≤
      (∑ v ∈ G.seg (eG a.val), p v) ^ 2 -
        (∑ v ∈ F.seg (eF a.val), p v) * (∑ v ∈ G.seg (eG a.val), p v)
    nlinarith [sq_nonneg (∑ v ∈ G.seg (eG a.val), p v)]
  have hU : (∑ a : U, |(∑ v ∈ F.seg (eF a.val), p v) *
      (∑ v ∈ G.seg (eG a.val), p v)|) ≤
      ∑ a : U, ((∑ v ∈ F.seg (eF a.val), p v) ^ 2 -
        (∑ v ∈ G.seg (eU a), p v) * (∑ v ∈ F.seg (eF a.val), p v)) := by
    apply Finset.sum_le_sum
    intro a _
    rw [abs_of_neg (hopp a.val)]
    change -( (∑ v ∈ F.seg (eF a.val), p v) * (∑ v ∈ G.seg (eG a.val), p v)) ≤
      (∑ v ∈ F.seg (eF a.val), p v) ^ 2 -
        (∑ v ∈ G.seg (eG a.val), p v) * (∑ v ∈ F.seg (eF a.val), p v)
    nlinarith [sq_nonneg (∑ v ∈ F.seg (eF a.val), p v)]
  have hsum := Fintype.sum_subtype_add_sum_subtype P (fun a =>
    |(∑ v ∈ F.seg (eF a), p v) * (∑ v ∈ G.seg (eG a), p v)|)
  change (∑ a : L, _) + (∑ a : U, _) = _ at hsum
  linarith

/-- The (possibly zero) head sum carried by the unique segment at a gate. -/
def boundaryCoeff (F : A.segments.Family) (p : ι →₀ ℝ) (g : ι) : ℝ :=
  ∑ i : Fin F.n, if g ∈ F.seg i then (∑ v ∈ F.seg i, p v) else 0

lemma boundaryCoeff_eq (F : A.segments.Family) (p : ι →₀ ℝ)
    (i : Fin F.n) {g : ι} (hg : g ∈ F.seg i) :
    A.boundaryCoeff F p g = ∑ v ∈ F.seg i, p v := by
  classical
  rw [boundaryCoeff, Finset.sum_eq_single i]
  · simp [hg]
  · intro j _ hji
    have hj : g ∉ F.seg j := fun h => Finset.disjoint_left.mp (F.disjoint hji) h hg
    simp [hj]
  · simp

lemma boundaryCoeff_nonzero_mem (F : A.segments.Family) (p : ι →₀ ℝ)
    {g : ι} (h : A.boundaryCoeff F p g ≠ 0) : ∃ i, g ∈ F.seg i := by
  classical
  by_contra hn
  have hm : ∀ i, g ∉ F.seg i := by simpa using hn
  exact h (by simp [boundaryCoeff, hm])

/-- Exact two-family opposite-crossing estimate, written without a sign-filter
    so that it can be averaged over independent finite endpoint laws. -/
lemma opposite_crossing_le {κ : Type*} [Fintype κ]
    {H : Set ι} (hH : A.Ancestral H) (p : ι →₀ ℝ)
    (hp : ∀ v, v ∉ H → p v = 0) (F G : A.segments.Family)
    (gate : κ ↪ ι) (hgate : ∀ a, A.Gate H (gate a)) :
    (∑ a, (|A.boundaryCoeff F p (gate a)| * |A.boundaryCoeff G p (gate a)| -
      A.boundaryCoeff F p (gate a) * A.boundaryCoeff G p (gate a))) ≤
      ((A.segments.primalSeminorm p) ^ 2 - ∑ i, (∑ v ∈ F.seg i, p v) ^ 2) +
      ((A.segments.primalSeminorm p) ^ 2 - ∑ j, (∑ v ∈ G.seg j, p v) ^ 2) := by
  classical
  let P : κ → Prop := fun a => A.boundaryCoeff F p (gate a) *
    A.boundaryCoeff G p (gate a) < 0
  let M := {a : κ // P a}
  have hnF (a : M) : A.boundaryCoeff F p (gate a.val) ≠ 0 := by
    intro he
    have := a.property
    change A.boundaryCoeff F p (gate a.val) * A.boundaryCoeff G p (gate a.val) < 0 at this
    simp [he] at this
  have hnG (a : M) : A.boundaryCoeff G p (gate a.val) ≠ 0 := by
    intro he
    have := a.property
    change A.boundaryCoeff F p (gate a.val) * A.boundaryCoeff G p (gate a.val) < 0 at this
    simp [he] at this
  choose iF hiF using fun a : M => A.boundaryCoeff_nonzero_mem F p (hnF a)
  choose iG hiG using fun a : M => A.boundaryCoeff_nonzero_mem G p (hnG a)
  have hiFinj : Function.Injective iF := by
    intro a b hab
    apply Subtype.ext
    apply gate.injective
    exact A.gate_unique_in_segment (F.allowed (iF a)) (hgate a.val) (hgate b.val)
      (hiF a) (by rw [hab]; exact hiF b)
  have hiGinj : Function.Injective iG := by
    intro a b hab
    apply Subtype.ext
    apply gate.injective
    exact A.gate_unique_in_segment (G.allowed (iG a)) (hgate a.val) (hgate b.val)
      (hiG a) (by rw [hab]; exact hiG b)
  have hbF (a : M) := A.boundaryCoeff_eq F p (iF a) (hiF a)
  have hbG (a : M) := A.boundaryCoeff_eq G p (iG a) (hiG a)
  have hb := A.opposite_matching_le hH p hp F G ⟨iF, hiFinj⟩ ⟨iG, hiGinj⟩
    (fun a => gate a.val) (fun a => (hgate a.val).1) hiF hiG (by
      intro a
      change (∑ v ∈ F.seg (iF a), p v) * (∑ v ∈ G.seg (iG a), p v) < 0
      rw [← hbF, ← hbG]
      exact a.property)
  simp only [Function.Embedding.coeFn_mk, ← hbF, ← hbG] at hb
  let f : κ → ℝ := fun a => |A.boundaryCoeff F p (gate a)| *
    |A.boundaryCoeff G p (gate a)| - A.boundaryCoeff F p (gate a) * A.boundaryCoeff G p (gate a)
  have hzero : (∑ a : {a : κ // ¬ P a}, f a.val) = 0 := by
    apply Finset.sum_eq_zero
    intro a _
    dsimp [f]
    rw [← abs_mul, abs_of_nonneg (le_of_not_gt a.property), sub_self]
  have heq : (∑ a : M, f a.val) =
      2 * ∑ a : M, |A.boundaryCoeff F p (gate a.val) * A.boundaryCoeff G p (gate a.val)| := by
    rw [Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro a _
    dsimp [f]
    rw [← abs_mul, abs_of_neg a.property]
    ring
  have hs := Fintype.sum_subtype_add_sum_subtype P f
  rw [hzero, add_zero, heq] at hs
  simpa only [hs] using hb

lemma gate_coefficient_energy {κ : Type*} [Fintype κ] {H : Set ι}
    (F : A.segments.Family) (a : Fin F.n → ℝ)
    (gate : κ ↪ ι) (hg : ∀ g, A.Gate H (gate g)) :
    (∑ g, (A.segments.combine F.seg a (A.segments.unitVector (gate g))) ^ 2) ≤
      ∑ i, a i ^ 2 := by
  classical
  let P : κ → Prop := fun g => ∃ i, gate g ∈ F.seg i
  let M := {g : κ // P g}
  choose idx hidx using fun g : M => g.property
  have hinj : Function.Injective idx := by
    intro g h he
    apply Subtype.ext
    apply gate.injective
    exact A.gate_unique_in_segment (F.allowed (idx g)) (hg g.val) (hg h.val)
      (hidx g) (by rw [he]; exact hidx h)
  have hz : (∑ g : {g : κ // ¬ P g},
      (A.segments.combine F.seg a (A.segments.unitVector (gate g.val))) ^ 2) = 0 := by
    apply Finset.sum_eq_zero
    intro g _
    rw [SegmentSystem.combine_unit]
    have hgn : ∀ i, gate g.val ∉ F.seg i := by simpa only [P, not_exists] using g.property
    simp only [hgn, ↓reduceIte, Finset.sum_const_zero, zero_pow (by norm_num : 2 ≠ 0)]
  have he := Fintype.sum_subtype_add_sum_subtype P
    (fun g => (A.segments.combine F.seg a (A.segments.unitVector (gate g))) ^ 2)
  rw [hz, add_zero] at he
  rw [← he]
  calc
    _ = ∑ g : M, a (idx g) ^ 2 := by
      apply Finset.sum_congr rfl
      intro g _
      rw [A.segments.combine_unit_of_mem F a (idx g) (hidx g)]
    _ = ∑ i ∈ Finset.univ.image idx, a i ^ 2 :=
      (Finset.sum_image (s := Finset.univ) (f := fun i : Fin F.n => a i ^ 2)
        (fun _ _ _ _ h => hinj h)).symm
    _ ≤ _ := Finset.sum_le_univ_sum_of_nonneg (fun i => sq_nonneg _)

/-- The tail from the unique segment through g, or the empty segment if absent. -/
def tailAt (F : A.segments.Family) (H : Finset ι) (g : ι) : Finset ι :=
  if h : ∃ i, g ∈ F.seg i then (F.seg h.choose).filter (· ∉ H) else ∅

lemma tailAt_eq (F : A.segments.Family) (H : Finset ι)
    (i : Fin F.n) {g : ι} (hg : g ∈ F.seg i) :
    A.tailAt F H g = (F.seg i).filter (· ∉ H) := by
  classical
  have h : ∃ i, g ∈ F.seg i := ⟨i,hg⟩
  have he : h.choose = i := by
    by_contra hn
    exact Finset.disjoint_left.mp (F.disjoint hn) h.choose_spec hg
  simp only [tailAt, dite_eq_left h]
  rw [he]

lemma tailAt_mem {F : A.segments.Family} {H : Finset ι} {g v : ι}
    (hv : v ∈ A.tailAt F H g) : ∃ i, g ∈ F.seg i ∧ v ∈ F.seg i ∧ v ∉ H := by
  classical
  unfold tailAt at hv
  split_ifs at hv with h
  · exact ⟨h.choose, h.choose_spec, (Finset.mem_filter.mp hv).1, (Finset.mem_filter.mp hv).2⟩
  · simp at hv

lemma tailAt_outside {F : A.segments.Family} {H : Finset ι} {g v : ι}
    (hv : v ∈ A.tailAt F H g) : v ∉ H := (A.tailAt_mem hv).choose_spec.2.2

lemma tailAt_allowed (F : A.segments.Family) {H : Finset ι}
    (hH : A.Ancestral (H : Set ι)) (g : ι) (hne : (A.tailAt F H g).Nonempty) :
    A.segments.IsSegment (A.tailAt F H g) := by
  classical
  obtain ⟨v,hv⟩ := hne
  obtain ⟨i, hgi, _, _⟩ := A.tailAt_mem hv
  rw [A.tailAt_eq F H i hgi] at hv ⊢
  convert A.segment_filter_tail (F.allowed i) hH ?_ using 1
  · ext w
    simp only [Finset.mem_filter, Finset.mem_coe]
  · simpa only [Finset.filter_nonempty_iff, Finset.mem_coe] using
      (show ((F.seg i).filter (· ∉ H)).Nonempty from ⟨v,hv⟩)

lemma tailAt_cone {F : A.segments.Family} {H : Finset ι} {g v : ι}
    (hg : A.Gate (H : Set ι) g) (hv : v ∈ A.tailAt F H g) : g ≤ v := by
  obtain ⟨i,hgi,hvi,hvH⟩ := A.tailAt_mem hv
  rcases A.interval_chain (F.allowed i) g hgi v hvi with h | h
  · exact h
  · by_contra hn
    have hvne : v ≠ g := fun he => hn (he ▸ le_rfl)
    exact hvH (hg.2 v (lt_of_le_of_ne h hvne))

lemma tailAt_pairwise {κ : Type*} (F : κ → A.segments.Family) {H : Finset ι}
    (gate : κ ↪ ι) (hg : ∀ a, A.Gate (H : Set ι) (gate a)) :
    Pairwise (fun a b => Disjoint (A.tailAt (F a) H (gate a)) (A.tailAt (F b) H (gate b))) := by
  intro a b hab
  apply Finset.disjoint_left.mpr
  intro v hva hvb
  exact hab (gate.injective (A.gates_eq_of_common_upper (hg a) (hg b)
    (A.tailAt_cone (hg a) hva) (A.tailAt_cone (hg b) hvb)))

lemma gate_on_nonzero_segment {H K : Finset ι} (hH : A.Ancestral (H : Set ι))
    (hK : A.Ancestral (K : Set ι)) (F : A.segments.Family)
    (hFK : ∀ i, F.seg i ⊆ K) (p : ι →₀ ℝ) (hp : ∀ v, v ∉ H → p v = 0)
    (i : Fin F.n) (hi : (∑ v ∈ F.seg i, p v) ≠ 0) {v : ι}
    (hvi : v ∈ F.seg i) (hvH : v ∉ H) :
    ∃ g ∈ K, A.Gate (H : Set ι) g ∧ g ∈ F.seg i := by
  classical
  obtain ⟨w, hwi, hpw⟩ := Finset.exists_ne_zero_of_sum_ne_zero hi
  have hwH : w ∈ H := by by_contra hn; exact hpw (hp w hn)
  have hfH : A.first F i ∈ H := hH (A.first_le_of_mem F i hwi) hwH
  obtain ⟨g,hgK,hg,hgv⟩ := A.exists_gate_le hK (hFK i hvi) hvH
  obtain ⟨b,hfb,hm⟩ := A.first_spec F i
  have hfg : A.first F i ≤ g := by
    rcases A.predecessors_total (A.first_le_of_mem F i hvi) hgv with h | h
    · exact h
    · exact False.elim (hg.1 (hH h hfH))
  exact ⟨g,hgK,hg,(hm g).mpr ⟨hfg,hgv.trans ((hm v).mp hvi).2⟩⟩

/-- The represented finite set of all gates of H in K. -/
def gateSet (H K : Finset ι) : Finset ι := K.filter (A.Gate (H : Set ι))

lemma mem_gateSet {H K : Finset ι} {g : ι} :
    g ∈ A.gateSet H K ↔ g ∈ K ∧ A.Gate (H : Set ι) g := Finset.mem_filter

/-- Replacement coefficients have no wholly exterior contribution. Their entire
    tail is the sum of their crossing tails at the finitely represented gates. -/
lemma replaced_tail_eq {H K : Finset ι} (hH : A.Ancestral (H : Set ι))
    (hK : A.Ancestral (K : Set ι)) (F : A.segments.Family)
    (hFK : ∀ i, F.seg i ⊆ K) (p : ι →₀ ℝ) (hp : ∀ v, v ∉ H → p v = 0) :
    A.segments.tailDual H (A.segments.combine F.seg (fun i => ∑ v ∈ F.seg i, p v)) =
      A.segments.combine (fun g : A.gateSet H K => A.tailAt F H g.val)
        (fun g : A.gateSet H K => A.boundaryCoeff F p g.val) := by
  classical
  apply A.segments.dual_ext
  intro v
  rw [SegmentSystem.tailDual_apply, sub_apply, SegmentSystem.headDual_unit]
  by_cases hvH : v ∈ H
  · rw [ite_eq_left hvH, sub_self, SegmentSystem.combine_unit]
    symm
    apply Finset.sum_eq_zero
    intro g _
    rw [ite_eq_right (fun hv => A.tailAt_outside hv hvH)]
  rw [ite_eq_right hvH, sub_zero]
  by_cases hhas : ∃ i, v ∈ F.seg i
  · obtain ⟨i,hvi⟩ := hhas
    rw [A.segments.combine_unit_of_mem F _ i hvi, SegmentSystem.combine_unit]
    by_cases hi : (∑ w ∈ F.seg i, p w) = 0
    · rw [hi]
      symm
      apply Finset.sum_eq_zero
      intro g _
      split_ifs with hv
      · obtain ⟨j,hgj,hvj,_⟩ := A.tailAt_mem hv
        have hji : j = i := by
          by_contra hn
          exact Finset.disjoint_left.mp (F.disjoint hn) hvj hvi
        subst j
        rwa [A.boundaryCoeff_eq F p i hgj]
      · rfl
    obtain ⟨g,hgK,hg,hgi⟩ := A.gate_on_nonzero_segment hH hK F hFK p hp i hi hvi hvH
    let g' : A.gateSet H K := ⟨g, A.mem_gateSet.mpr ⟨hgK,hg⟩⟩
    have hvJ : v ∈ A.tailAt F H g := by
      rw [A.tailAt_eq F H i hgi]
      exact Finset.mem_filter.mpr ⟨hvi,hvH⟩
    rw [Finset.sum_eq_single g']
    · rw [ite_eq_left hvJ, A.boundaryCoeff_eq F p i hgi]
    · intro h _ hh
      rw [ite_eq_right]
      intro hv
      have he : h.val = g := A.gates_eq_of_common_upper
        (A.mem_gateSet.mp h.property).2 hg
        (A.tailAt_cone (A.mem_gateSet.mp h.property).2 hv) (A.tailAt_cone hg hvJ)
      exact hh (Subtype.ext he)
    · simp
  · have hn : ∀ i, v ∉ F.seg i := by simpa only [not_exists] using hhas
    rw [SegmentSystem.combine_unit, SegmentSystem.combine_unit]
    have hz : (∑ i, if v ∈ F.seg i then (∑ w ∈ F.seg i,p w) else 0) = 0 := by simp [hn]
    rw [hz]
    symm
    apply Finset.sum_eq_zero
    intro g _
    rw [ite_eq_right]
    intro hv
    obtain ⟨i,_,hvi,_⟩ := A.tailAt_mem hv
    exact hn i hvi

lemma primal_filter_le {H : Set ι} (hH : A.Ancestral H) (u : ι →₀ ℝ) :
    A.segments.primalSeminorm (u.filter (· ∈ H)) ≤ A.segments.primalSeminorm u := by
  classical
  rw [SegmentSystem.primalSeminorm,
    Seminorm.iSup_apply A.segments.families_bddAbove]
  apply ciSup_le
  intro F
  have h := A.segments.test_energy_le_allow_empty
    (fun i => (F.seg i).filter (· ∈ H))
    (fun i hne => A.segment_filter_head (F.allowed i) hH hne)
    (fun i j hij => (F.disjoint hij).mono (Finset.filter_subset _ _) (Finset.filter_subset _ _)) u
  have he : ‖F.test (u.filter (· ∈ H))‖ ^ 2 =
      ∑ i, (∑ v ∈ (F.seg i).filter (· ∈ H), u v) ^ 2 := by
    rw [EuclideanSpace.norm_sq_eq]
    apply Finset.sum_congr rfl
    intro i hi
    simp only [SegmentSystem.Family.test, LinearMap.coe_mk, AddHom.coe_mk,
      WithLp.ofLp_toLp, Real.norm_eq_abs, sq_abs]
    congr 1
    simp [Finsupp.filter_apply, Finset.sum_filter]
  rw [← he] at h
  exact (sq_le_sq₀ (norm_nonneg _) (apply_nonneg _ _)).mp h

lemma primal_filter_tail_le {H : Set ι} (hH : A.Ancestral H) (u : ι →₀ ℝ) :
    A.segments.primalSeminorm (u.filter (· ∉ H)) ≤ A.segments.primalSeminorm u := by
  classical
  rw [SegmentSystem.primalSeminorm,
    Seminorm.iSup_apply A.segments.families_bddAbove]
  apply ciSup_le
  intro F
  have h := A.segments.test_energy_le_allow_empty
    (fun i => (F.seg i).filter (· ∉ H))
    (fun i hne => A.segment_filter_tail (F.allowed i) hH hne)
    (fun i j hij => (F.disjoint hij).mono (Finset.filter_subset _ _) (Finset.filter_subset _ _)) u
  have he : ‖F.test (u.filter (· ∉ H))‖ ^ 2 =
      ∑ i, (∑ v ∈ (F.seg i).filter (· ∉ H), u v) ^ 2 := by
    rw [EuclideanSpace.norm_sq_eq]
    apply Finset.sum_congr rfl
    intro i hi
    simp only [SegmentSystem.Family.test, LinearMap.coe_mk, AddHom.coe_mk,
      WithLp.ofLp_toLp, Real.norm_eq_abs, sq_abs]
    congr 1
    simp [Finsupp.filter_apply, Finset.sum_filter]
  rw [← he] at h
  exact (sq_le_sq₀ (norm_nonneg _) (apply_nonneg _ _)).mp h

/-- Restricting any test family to a finite ancestral set gives one of the
    finitely many local families, with exactly the same energy for supported tests. -/
lemma localize_family_energy {K : Finset ι} (hK : A.Ancestral (K : Set ι))
    (F : A.segments.Family) (p : ι →₀ ℝ) (hp : ∀ v, v ∉ K → p v = 0) :
    ∃ G : A.segments.LocalFamily K,
      (∑ i, (∑ v ∈ F.seg i, p v) ^ 2) =
        ∑ S : A.segments.LocalIndex G, (∑ v ∈ S.val, p v) ^ 2 := by
  classical
  let P : Fin F.n → Prop := fun i => ((F.seg i).filter (· ∈ K)).Nonempty
  let I := {i : Fin F.n // P i}
  let f : I → Finset ι := fun i => (F.seg i.val).filter (· ∈ K)
  have hf : Function.Injective f := by
    intro i j he
    apply Subtype.ext
    by_contra hne
    obtain ⟨v, hv⟩ := i.property
    have hvj : v ∈ f j := by rw [← he]; exact hv
    exact Finset.disjoint_left.mp (F.disjoint hne)
      (Finset.mem_filter.mp hv).1 (Finset.mem_filter.mp hvj).1
  let Gset := Finset.univ.image f
  have hGK : Gset ∈ K.powerset.powerset := by
    apply Finset.mem_powerset.mpr
    intro S hS
    obtain ⟨i, _, rfl⟩ := Finset.mem_image.mp hS
    apply Finset.mem_powerset.mpr
    intro v hv
    exact (Finset.mem_filter.mp hv).2
  have hGa : ∀ S ∈ Gset, A.segments.IsSegment S := by
    intro S hS
    obtain ⟨i, _, rfl⟩ := Finset.mem_image.mp hS
    convert A.segment_filter_head (F.allowed i.val) hK (by
      have hi := i.property
      change ((F.seg i.val).filter (fun v => v ∈ K)).Nonempty at hi
      simpa only [Finset.filter_nonempty_iff, Finset.mem_coe] using hi) using 1
    ext v
    simp only [f, Finset.mem_filter, Finset.mem_coe]

  have hGd : (Gset : Set (Finset ι)).Pairwise Disjoint := by
    intro S hS U hU hSU
    obtain ⟨i, _, rfl⟩ := Finset.mem_image.mp hS
    obtain ⟨j, _, rfl⟩ := Finset.mem_image.mp hU
    have hij : i.val ≠ j.val := fun h => hSU (congrArg f (Subtype.ext h))
    exact (F.disjoint hij).mono (Finset.filter_subset _ _) (Finset.filter_subset _ _)
  let G : A.segments.LocalFamily K := ⟨Gset, hGK, hGa, hGd⟩
  refine ⟨G, ?_⟩
  have hsum (i : Fin F.n) : (∑ v ∈ F.seg i, p v) =
      ∑ v ∈ (F.seg i).filter (· ∈ K), p v := by
    symm
    apply Finset.sum_filter_of_ne
    intro v _ hv
    by_contra hn
    exact hv (hp v hn)
  have hzero : (∑ i : {i : Fin F.n // ¬ P i},
      (∑ v ∈ (F.seg i.val).filter (· ∈ K), p v) ^ 2) = 0 := by
    apply Finset.sum_eq_zero
    intro i _
    have hi : (F.seg i.val).filter (· ∈ K) = ∅ := Finset.not_nonempty_iff_eq_empty.mp i.property
    rw [hi]
    simp
  have he := Fintype.sum_subtype_add_sum_subtype P
    (fun i => (∑ v ∈ (F.seg i).filter (· ∈ K), p v) ^ 2)
  rw [hzero, add_zero] at he
  simp_rw [hsum]
  rw [← he]
  change (∑ i : I, (∑ v ∈ f i, p v) ^ 2) =
    ∑ S : ↥Gset, (∑ v ∈ S.val, p v) ^ 2
  calc
    _ = ∑ S ∈ Gset, (∑ v ∈ S, p v) ^ 2 :=
      (Finset.sum_image (fun _ _ _ _ h => hf h)).symm
    _ = _ := (Finset.sum_coe_sort Gset (fun S => (∑ v ∈ S, p v) ^ 2)).symm

lemma primal_le_of_local_energies {K : Finset ι} (hK : A.Ancestral (K : Set ι))
    (p : ι →₀ ℝ) (hp : ∀ v, v ∉ K → p v = 0) {M : ℝ} (hM : 0 ≤ M)
    (hlocal : ∀ G : A.segments.LocalFamily K,
      (∑ S : A.segments.LocalIndex G, (∑ v ∈ S.val, p v) ^ 2) ≤ M ^ 2) :
    A.segments.primalSeminorm p ≤ M := by
  rw [SegmentSystem.primalSeminorm, Seminorm.iSup_apply A.segments.families_bddAbove]
  apply ciSup_le
  intro F
  obtain ⟨G, he⟩ := A.localize_family_energy hK F p hp
  have h := hlocal G
  rw [← he] at h
  have hnorm : ‖F.test p‖ ^ 2 = ∑ i, (∑ v ∈ F.seg i, p v) ^ 2 := by
    rw [EuclideanSpace.norm_sq_eq]
    simp only [SegmentSystem.Family.test_apply, Real.norm_eq_abs, sq_abs]
  rw [← hnorm] at h
  exact (sq_le_sq₀ (norm_nonneg _) hM).mp h

/-- Finite atomic-ball formula: exact inherited dual restrictions, derived by
    finite-dimensional separation rather than assumed as model data. -/
lemma finite_atomic_representation {K : Finset ι} (hK : A.Ancestral (K : Set ι))
    (x : A.segments.Dual) (hx : ‖x‖ ≤ 1) :
    ∃ c ∈ A.segments.coefficientBall K 1,
      A.segments.totalMap K c = fun v : K => x (A.segments.unitVector v.val) := by
  classical
  let C := A.segments.totalMap K '' A.segments.coefficientBall K 1
  let z : A.segments.Coordinates K := fun v => x (A.segments.unitVector v.val)
  suffices z ∈ C by exact this
  by_contra hn
  have hCc : Convex ℝ C := (A.segments.coefficientBall_convex K 1).linear_image _
  have hCk : IsCompact C := (A.segments.coefficientBall_compact K (by norm_num : (0:ℝ) ≤ 1)).image
    (A.segments.totalMap K).continuous_of_finiteDimensional
  obtain ⟨f, u, hfu, huz⟩ := geometric_hahn_banach_closed_point hCc hCk.isClosed hn
  have hzC : (0 : A.segments.Coordinates K) ∈ C := by
    refine ⟨0, ?_, map_zero _⟩
    change (∑ F : A.segments.LocalFamily K, ‖(0 : A.segments.Coefficients K) F‖) ≤ 1
    simp
  have hu : 0 < u := by simpa only [map_zero] using hfu 0 hzC
  let p := A.segments.coordinateTest K (fun w => f (Pi.single w 1))
  have hp : ∀ v, v ∉ K → p v = 0 := by
    intro v hv
    exact A.segments.coordinateTest_not_mem K _ hv
  have hpbound : A.segments.primalSeminorm p ≤ u := by
    apply A.primal_le_of_local_energies hK p hp hu.le
    intro F
    apply A.segments.local_energy_le_of_functional_bound F f hu.le
    intro a ha
    apply (hfu _ ?_).le
    refine ⟨Pi.single F a, A.segments.single_mem_coefficientBall K F a ha, ?_⟩
    exact A.segments.totalMap_single K F a
  have he : f z = x (A.segments.finiteEmbedding p) := by
    rw [A.segments.functional_pi_formula, A.segments.coordinateTest_pairing]
    apply Finset.sum_congr rfl
    intro v _
    exact mul_comm _ _
  have hle : f z ≤ u := by
    rw [he]
    calc
      x (A.segments.finiteEmbedding p) ≤ ‖x (A.segments.finiteEmbedding p)‖ := Real.le_norm_self _
      _ ≤ ‖x‖ * ‖A.segments.finiteEmbedding p‖ := x.le_opNorm _
      _ ≤ 1 * A.segments.primalSeminorm p := by
        rw [A.segments.finiteEmbedding_norm]
        exact mul_le_mul_of_nonneg_right hx (apply_nonneg _ _)
      _ ≤ u := by simpa using hpbound
  exact (not_lt_of_ge hle) huz

lemma finite_atomic_representation_radius {K : Finset ι} (hK : A.Ancestral (K : Set ι))
    (x : A.segments.Dual) {R : ℝ} (hR : 0 ≤ R) (hx : ‖x‖ ≤ R) :
    ∃ c ∈ A.segments.coefficientBall K R,
      A.segments.totalMap K c = fun v : K => x (A.segments.unitVector v.val) := by
  classical
  rcases eq_or_lt_of_le hR with hR0 | hRpos
  · have hx0 : x = 0 := norm_eq_zero.mp (le_antisymm (by simpa [← hR0] using hx) (norm_nonneg _))
    refine ⟨0, ?_, ?_⟩
    · simp [SegmentSystem.coefficientBall, ← hR0]
    · rw [map_zero]
      ext v
      simp [hx0]
  have hxn : ‖R⁻¹ • x‖ ≤ 1 := by
    rw [norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hRpos)]
    exact (inv_mul_le_iff₀ hRpos).mpr (by simpa using hx)
  obtain ⟨c, hc, hce⟩ := A.finite_atomic_representation hK (R⁻¹ • x) hxn
  refine ⟨R • c, ?_, ?_⟩
  · change (∑ F, ‖R • c F‖) ≤ R
    simp_rw [norm_smul, Real.norm_eq_abs, abs_of_pos hRpos]
    rw [← Finset.mul_sum]
    exact (mul_le_mul_of_nonneg_left hc hRpos.le).trans_eq (mul_one _)
  · rw [map_smul, hce]
    ext v
    simp only [Pi.smul_apply, smul_apply, smul_eq_mul]
    rw [← mul_assoc, mul_inv_cancel₀ hRpos.ne', one_mul]

lemma headPrimal_norm_le {H : Finset ι} (hH : A.Ancestral (H : Set ι))
    (u : A.segments.JamesSpace) : ‖A.segments.headPrimal H u‖ ≤ ‖u‖ := by
  induction u using UniformSpace.Completion.induction_on with
  | hp => exact isClosed_le (by fun_prop) (by fun_prop)
  | ih u =>
    rw [SegmentSystem.headPrimal_coe, UniformSpace.Completion.norm_coe,
      UniformSpace.Completion.norm_coe]
    exact A.primal_filter_le hH u

lemma tailPrimal_norm_le {H : Finset ι} (hH : A.Ancestral (H : Set ι))
    (u : A.segments.JamesSpace) : ‖u - A.segments.headPrimal H u‖ ≤ ‖u‖ := by
  induction u using UniformSpace.Completion.induction_on with
  | hp => exact isClosed_le (by fun_prop) (by fun_prop)
  | ih u =>
    rw [SegmentSystem.headPrimal_coe, ← UniformSpace.Completion.coe_sub,
      UniformSpace.Completion.norm_coe, UniformSpace.Completion.norm_coe]
    rw [SegmentSystem.sub_filterPrimal, SegmentSystem.norm_eq_primal,
      SegmentSystem.norm_eq_primal, SegmentSystem.ofPrimal_filter]
    convert A.primal_filter_tail_le hH (A.segments.ofPrimal u) using 1
    congr 2

lemma headDual_norm_le {H : Finset ι} (hH : A.Ancestral (H : Set ι))
    (x : A.segments.Dual) : ‖A.segments.headDual H x‖ ≤ ‖x‖ := by
  apply ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg _)
  intro u
  rw [SegmentSystem.headDual_apply_apply]
  exact (x.le_opNorm _).trans (mul_le_mul_of_nonneg_left (A.headPrimal_norm_le hH u)
    (norm_nonneg _))

lemma tailDual_norm_le {H : Finset ι} (hH : A.Ancestral (H : Set ι))
    (x : A.segments.Dual) : ‖A.segments.tailDual H x‖ ≤ ‖x‖ := by
  apply ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg _)
  intro u
  rw [SegmentSystem.tailDual_apply_apply]
  exact (x.le_opNorm _).trans (mul_le_mul_of_nonneg_left (A.tailPrimal_norm_le hH u)
    (norm_nonneg _))

lemma replacement_error_le {H : Finset ι} (hH : A.Ancestral (H : Set ι))
    (F : A.segments.Family) (a b : Fin F.n → ℝ) :
    ‖A.segments.tailDual H (A.segments.combine F.seg a - A.segments.combine F.seg b)‖ ^ 2 ≤
      ∑ i, (a i - b i) ^ 2 := by
  have hV : 0 ≤ ∑ i,(a i-b i)^2 := Finset.sum_nonneg (fun _ _ => sq_nonneg _)
  have hc := A.tailDual_norm_le hH (A.segments.combine F.seg a - A.segments.combine F.seg b)
  rw [← SegmentSystem.combine_sub] at hc
  have ha := A.segments.norm_combine_le F.seg (a-b) (fun i _ => F.allowed i) F.disjoint
  have h := (sq_le_sq₀ (norm_nonneg _) (Real.sqrt_nonneg _)).2 (hc.trans ha)
  simpa only [Pi.sub_apply, Real.sq_sqrt hV, SegmentSystem.combine_sub] using h

lemma replacement_error_gate {H : Finset ι} (F : A.segments.Family)
    (a : Fin F.n → ℝ) (q : ι →₀ ℝ) {g : ι} (hg : g ∉ H) :
    A.segments.tailDual H (A.segments.combine F.seg a -
      A.segments.combine F.seg (fun i => ∑ v ∈ F.seg i,q v)) (A.segments.unitVector g) =
      A.segments.combine F.seg a (A.segments.unitVector g) - A.boundaryCoeff F q g := by
  rw [SegmentSystem.tailDual_apply, sub_apply, SegmentSystem.headDual_unit, ite_eq_right hg,
    sub_zero, sub_apply]
  simp only [SegmentSystem.combine_unit, boundaryCoeff]

lemma replacement_cross (F : A.segments.Family) (a : Fin F.n → ℝ) (p : ι →₀ ℝ) (r : ℝ) :
    (∑ i, a i * (∑ v ∈ F.seg i,(r • p) v)) =
      r * A.segments.combine F.seg a (A.segments.finiteEmbedding p) := by
  rw [SegmentSystem.finiteEmbedding_apply, SegmentSystem.combine_coe]
  change (∑ i,a i*(∑ v ∈ F.seg i,(r • p) v)) = r*(∑ i,a i*(∑ v ∈ F.seg i,p v))
  simp_rw [Finsupp.smul_apply, smul_eq_mul, ← Finset.mul_sum]
  rw [Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro i _
  ring

lemma replacement_mass_norm {Ω : Type*} [Fintype Ω] [Nonempty Ω]
    {H K : Finset ι} (hH : A.Ancestral (H : Set ι)) (hK : A.Ancestral (K : Set ι))
    (F : Ω → A.segments.Family) (hFK : ∀ ω i, (F ω).seg i ⊆ K)
    (q : ι →₀ ℝ) (hq : ∀ v,v ∉ H → q v=0)
    (w σ : Ω → ℝ) (hw : ∀ ω,0 ≤ w ω) (hσ : ∀ ω,|σ ω|=1) :
    ‖∑ ω,w ω • (σ ω • A.segments.tailDual H
      (A.segments.combine (F ω).seg (fun i => ∑ v ∈ (F ω).seg i,q v)))‖ ≤
      Real.sqrt (∑ g : A.gateSet H K, (∑ ω,w ω * |A.boundaryCoeff (F ω) q g.val|)^2) := by
  classical
  let gate : A.gateSet H K ↪ ι := ⟨Subtype.val, Subtype.val_injective⟩
  have hg (g : A.gateSet H K) : A.Gate (H : Set ι) (gate g) :=
    (A.mem_gateSet.mp g.property).2
  have h := A.segments.norm_cone_mean_le
    (fun ω (g : A.gateSet H K) => A.tailAt (F ω) H g.val)
    (fun ω g => σ ω * A.boundaryCoeff (F ω) q g.val) w hw
    (fun ω g => A.tailAt_allowed (F ω) hH g.val) (by
      intro g h hgh ω ν
      apply Finset.disjoint_left.mpr
      intro v hvg hvh
      exact hgh (gate.injective (A.gates_eq_of_common_upper (hg g) (hg h)
        (A.tailAt_cone (hg g) hvg) (A.tailAt_cone (hg h) hvh))))
  simp only [abs_mul, hσ, one_mul] at h
  convert h using 1
  congr 1
  apply Finset.sum_congr rfl
  intro ω _
  rw [A.replaced_tail_eq hH hK (F ω) (hFK ω) q hq, SegmentSystem.combine_smul]

/-- The finite pooled coefficient/slack bound, before taking the supremum over
    head tests. No lens or convexity modulus is postulated for the space. -/
lemma pooled_tail_test {Ω : Type*} [Fintype Ω] {H K : Finset ι}
    (hH : A.Ancestral (H : Set ι)) (hK : A.Ancestral (K : Set ι))
    {R : ℝ} {x y : A.segments.Dual} (law : A.segments.BipolarLaw Ω R x y)
    (hFK : ∀ ω i,(law.atom ω).family.seg i ⊆ K)
    (hx : ∀ v,v ∉ H → x (A.segments.unitVector v)=0)
    (p : ι →₀ ℝ) (hp : ∀ v,v ∉ H → p v=0) (hpn : A.segments.primalSeminorm p ≤ 1) :
    ‖A.segments.tailDual H y‖ ≤
      2*Real.sqrt (R^2 - (x (A.segments.finiteEmbedding p))^2) := by
  classical
  have : Nonempty Ω := by
    by_contra hn
    have : IsEmpty Ω := not_nonempty_iff.mp hn
    have h := law.sum_one
    simp at h
  let r : ℝ := x (A.segments.finiteEmbedding p)
  let q : ι →₀ ℝ := r • p
  let F : Ω → A.segments.Family := fun ω => (law.atom ω).family
  let a : (ω : Ω) → Fin (F ω).n → ℝ := fun ω => (law.atom ω).coeff
  let β : (ω : Ω) → Fin (F ω).n → ℝ := fun ω i => ∑ v ∈ (F ω).seg i,q v
  let Ac : Ω → A.segments.Dual := fun ω => A.segments.combine (F ω).seg (β ω)
  let W : Ω → A.segments.Dual := fun ω =>
    A.segments.tailDual H ((law.atom ω).value - Ac ω)
  let V : Ω → ℝ := fun ω => ∑ i,(a ω i-β ω i)^2
  let L : Ω → ℝ := fun ω => r^2-∑ i,β ω i^2
  let η : ℝ := ∑ ω,law.weight ω*V ω
  let θ : ℝ := ∑ ω,law.weight ω*L ω
  have hq (v : ι) (hv : v ∉ H) : q v = 0 := by simp only [q,Finsupp.smul_apply,hp v hv,smul_zero]
  have hqn : A.segments.primalSeminorm q ≤ |r| := by
    dsimp [q]
    rw [map_smul_eq_mul, Real.norm_eq_abs]
    simpa only [mul_one] using mul_le_mul_of_nonneg_left hpn (abs_nonneg r)
  have hqn2 : (A.segments.primalSeminorm q)^2 ≤ r^2 := by
    simpa only [sq_abs] using (sq_le_sq₀ (apply_nonneg _ _) (abs_nonneg r)).2 hqn
  have hV (ω : Ω) : 0 ≤ V ω := Finset.sum_nonneg (fun _ _ => sq_nonneg _)
  have hL (ω : Ω) : 0 ≤ L ω := by
    apply sub_nonneg.mpr
    exact (A.segments.test_energy_le_allow_empty (F ω).seg
      (fun i _ => (F ω).allowed i) (F ω).disjoint q).trans hqn2
  have hη : 0 ≤ η := Finset.sum_nonneg (fun ω _ => mul_nonneg (law.nonneg ω) (hV ω))
  have hθ : 0 ≤ θ := Finset.sum_nonneg (fun ω _ => mul_nonneg (law.nonneg ω) (hL ω))
  have hcross : (∑ ω,law.weight ω*(∑ i,a ω i*β ω i)) = r^2 := by
    have hm := congrArg (fun z : A.segments.Dual => z (A.segments.finiteEmbedding p)) law.mean
    simp only [sum_apply, smul_apply, smul_eq_mul] at hm
    calc
      _ = r*(∑ ω,law.weight ω*(law.atom ω).value (A.segments.finiteEmbedding p)) := by
        rw [Finset.mul_sum]
        apply Finset.sum_congr rfl
        intro ω _
        have hr := A.replacement_cross (F ω) (a ω) p r
        change (∑ i,a ω i*β ω i) = r*(law.atom ω).value (A.segments.finiteEmbedding p) at hr
        rw [hr]
        ring
      _ = r^2 := by rw [hm]; dsimp [r]; ring
  have hbudget : η+θ ≤ R^2-r^2 :=
    FiniteAverage.joint_budget law.weight law.nonneg law.sum_one (fun ω => Fin (F ω).n)
      a β (fun ω => (law.atom ω).energy_le) hcross
  have hWnorm (ω : Ω) : ‖W ω‖^2 ≤ V ω :=
    A.replacement_error_le hH (F ω) (a ω) (β ω)
  let gate : A.gateSet H K ↪ ι := ⟨Subtype.val,Subtype.val_injective⟩
  have hg (g : A.gateSet H K) : A.Gate (H : Set ι) (gate g) :=
    (A.mem_gateSet.mp g.property).2
  let b : Ω → A.gateSet H K → ℝ := fun ω g => A.boundaryCoeff (F ω) q g.val
  let e : Ω → A.gateSet H K → ℝ := fun ω g => W ω (A.segments.unitVector g.val)
  have he (ω : Ω) (g : A.gateSet H K) :
      e ω g = (law.atom ω).value (A.segments.unitVector g.val) - b ω g :=
    A.replacement_error_gate (F ω) (a ω) q (hg g).1
  have hgateEnergy (ω : Ω) : (∑ g,e ω g^2) ≤ V ω := by
    have heq (g : A.gateSet H K) : e ω g =
        A.segments.combine (F ω).seg (a ω-β ω) (A.segments.unitVector g.val) := by
      rw [SegmentSystem.combine_sub]
      rw [sub_apply]
      simpa only [SegmentSystem.Atom.value, SegmentSystem.combine_unit, b, β,
        boundaryCoeff, F, a] using he ω g
    simp_rw [heq]
    exact A.gate_coefficient_energy (F ω) (a ω-β ω) gate hg
  have hmean (g : A.gateSet H K) :
      (∑ ω,law.weight ω*b ω g) = -(∑ ω,law.weight ω*e ω g) := by
    have hm := congrArg (fun z : A.segments.Dual => z (A.segments.unitVector g.val)) law.mean
    simp only [sum_apply,smul_apply,smul_eq_mul,hx g.val (hg g).1] at hm
    have heq : (∑ ω,law.weight ω*b ω g)+(∑ ω,law.weight ω*e ω g) =
        ∑ ω,law.weight ω*(law.atom ω).value (A.segments.unitVector g.val) := by
      rw [← Finset.sum_add_distrib]
      apply Finset.sum_congr rfl
      intro ω _
      rw [he]
      ring
    rw [hm] at heq
    linarith
  have hopp (ω ν : Ω) : (∑ g,(|b ω g| * |b ν g|-b ω g*b ν g)) ≤ L ω+L ν := by
    have h := A.opposite_crossing_le hH q hq (F ω) (F ν) gate hg
    change (∑ g,(|b ω g| * |b ν g|-b ω g*b ν g)) ≤
      ((A.segments.primalSeminorm q)^2 - ∑ i,β ω i^2) +
      ((A.segments.primalSeminorm q)^2 - ∑ i,β ν i^2) at h
    exact h.trans (add_le_add (sub_le_sub_right hqn2 _) (sub_le_sub_right hqn2 _))
  have hmass : (∑ g,(∑ ω,law.weight ω* |b ω g|)^2) ≤ η+2*θ :=
    FiniteAverage.pooled_mass law.weight law.nonneg law.sum_one b e V L hmean hgateEnergy hopp
  have herr : ‖∑ ω,law.weight ω • (law.sign ω • W ω)‖ ≤ Real.sqrt η := by
    apply FiniteAverage.norm_mean_le_sqrt law.weight law.nonneg law.sum_one _ hη
    apply Finset.sum_le_sum
    intro ω _
    rw [norm_smul,Real.norm_eq_abs,law.abs_sign,one_mul]
    exact mul_le_mul_of_nonneg_left (hWnorm ω) (law.nonneg ω)
  have hrec : ‖∑ ω,law.weight ω • (law.sign ω • A.segments.tailDual H (Ac ω))‖ ≤
      Real.sqrt (η+2*θ) := by
    exact (A.replacement_mass_norm hH hK F hFK q hq law.weight law.sign law.nonneg law.abs_sign).trans
      (Real.sqrt_le_sqrt hmass)
  have hdec : A.segments.tailDual H y =
      (∑ ω,law.weight ω • (law.sign ω • W ω)) +
      (∑ ω,law.weight ω • (law.sign ω • A.segments.tailDual H (Ac ω))) := by
    conv_lhs => rw [← law.signed_mean]
    rw [map_sum, ← Finset.sum_add_distrib]
    apply Finset.sum_congr rfl
    intro ω _
    simp only [map_smul, W, map_sub, smul_sub]
    module
  calc
    ‖A.segments.tailDual H y‖ ≤ Real.sqrt η+Real.sqrt (η+2*θ) := by
      rw [hdec]
      exact (norm_add_le _ _).trans (add_le_add herr hrec)
    _ ≤ 2*Real.sqrt (η+θ) := FiniteAverage.sqrt_pooled hη hθ
    _ ≤ _ := mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt hbudget) (by norm_num)

/-- Pair the two exact finite atomic representations, retaining their common
    ancestral support and their actual endpoints. -/
lemma finite_lens_test {H K : Finset ι}
    (hH : A.Ancestral (H : Set ι)) (hK : A.Ancestral (K : Set ι)) (hHK : H ⊆ K)
    {R : ℝ} (hR : 0 < R) {x y : A.segments.Dual}
    (hx : ∀ v, v ∉ H → x (A.segments.unitVector v) = 0)
    (hplus : ‖x+y‖ ≤ R) (hminus : ‖x-y‖ ≤ R)
    (p : ι →₀ ℝ) (hp : ∀ v, v ∉ H → p v = 0) (hpn : A.segments.primalSeminorm p ≤ 1) :
    ‖A.segments.tailDual H (A.segments.headDual K y)‖ ≤
      2*Real.sqrt (R^2 - (x (A.segments.finiteEmbedding p))^2) := by
  classical
  obtain ⟨cp,hcp,hcep⟩ := A.finite_atomic_representation_radius hK (x+y) hR.le hplus
  obtain ⟨cm,hcm,hcem⟩ := A.finite_atomic_representation_radius hK (x-y) hR.le hminus
  have hxK : A.segments.headDual K x = x :=
    A.segments.headDual_eq_self (fun v hv => hx v (fun h => hv (hHK h)))
  let Lp0 := A.segments.lawOfCoefficients (x+y) hR cp hcp hcep
  let Lm0 := A.segments.lawOfCoefficients (x-y) hR cm hcm hcem
  let Lp : A.segments.AtomLaw (Option (A.segments.LocalFamily K)) R
      (x+A.segments.headDual K y) :=
    { Lp0 with mean := by rw [Lp0.mean, map_add, hxK] }
  let Lm : A.segments.AtomLaw (Option (A.segments.LocalFamily K)) R
      (x-A.segments.headDual K y) :=
    { Lm0 with mean := by rw [Lm0.mean, map_sub, hxK] }
  apply A.pooled_tail_test hH hK (A.segments.pairLaws Lp Lm) _ hx p hp hpn
  apply A.segments.pairLaws_subset Lp Lm K
  · exact A.segments.lawOfCoefficients_subset (x+y) hR cp hcp hcep
  · exact A.segments.lawOfCoefficients_subset (x-y) hR cm hcm hcem

/-- Finite restrictions suffice for the full dual estimate: no shrinking or
    reflexivity hypothesis is needed for this intrinsic finite-head bound. -/
lemma intrinsic_tail_test
    (hfin : ∀ S : Finset ι, ∃ K : Finset ι, S ⊆ K ∧ A.Ancestral (K : Set ι))
    {H : Finset ι} (hH : A.Ancestral (H : Set ι)) {R : ℝ} (hR : 0 < R)
    {x y : A.segments.Dual} (hx : ∀ v, v ∉ H → x (A.segments.unitVector v) = 0)
    (hplus : ‖x+y‖ ≤ R) (hminus : ‖x-y‖ ≤ R)
    (p : ι →₀ ℝ) (hp : ∀ v, v ∉ H → p v = 0) (hpn : A.segments.primalSeminorm p ≤ 1) :
    ‖A.segments.tailDual H y‖ ≤
      2*Real.sqrt (R^2 - (x (A.segments.finiteEmbedding p))^2) := by
  apply ContinuousLinearMap.opNorm_le_bound _ (mul_nonneg (by norm_num) (Real.sqrt_nonneg _))
  intro u
  induction u using UniformSpace.Completion.induction_on with
  | hp => exact isClosed_le (by fun_prop) (by fun_prop)
  | ih u =>
    obtain ⟨K,hsub,hK⟩ := hfin (H ∪ (A.segments.ofPrimal u).support)
    have hHK : H ⊆ K := Finset.Subset.trans Finset.subset_union_left hsub
    have huK : (A.segments.ofPrimal u).support ⊆ K :=
      Finset.Subset.trans Finset.subset_union_right hsub
    have ht := A.finite_lens_test hH hK hHK hR hx hplus hminus p hp hpn
    calc
      _ = ‖A.segments.tailDual H (A.segments.headDual K y) (u : A.segments.JamesSpace)‖ := by
        rw [SegmentSystem.tailDual_headDual, A.segments.headDual_finite_apply _ u huK]
      _ ≤ ‖A.segments.tailDual H (A.segments.headDual K y)‖ * ‖(u : A.segments.JamesSpace)‖ :=
        ContinuousLinearMap.le_opNorm _ _
      _ ≤ _ := mul_le_mul_of_nonneg_right ht (norm_nonneg _)

lemma norm_center_le {x y : A.segments.Dual} {R : ℝ}
    (hplus : ‖x+y‖ ≤ R) (hminus : ‖x-y‖ ≤ R) : ‖x‖ ≤ R := by
  have h := (norm_add_le (x+y) (x-y)).trans (add_le_add hplus hminus)
  have he : (x+y)+(x-y) = (2:ℝ) • x := by module
  rw [he, norm_smul, Real.norm_eq_abs] at h
  norm_num at h
  linarith

lemma intrinsic_tail_sq
    (hfin : ∀ S : Finset ι, ∃ K : Finset ι, S ⊆ K ∧ A.Ancestral (K : Set ι))
    {H : Finset ι} (hH : A.Ancestral (H : Set ι)) {R : ℝ} (hR : 0 ≤ R)
    {x y : A.segments.Dual} (hx : ∀ v, v ∉ H → x (A.segments.unitVector v) = 0)
    (hplus : ‖x+y‖ ≤ R) (hminus : ‖x-y‖ ≤ R) :
    ‖A.segments.tailDual H y‖^2 + 4*‖x‖^2 ≤ 4*R^2 := by
  have hxr := A.norm_center_le hplus hminus
  rcases eq_or_lt_of_le hR with hR0 | hRpos
  · have hx0 : x=0 := norm_eq_zero.mp (le_antisymm (by simpa [← hR0] using hxr) (norm_nonneg _))
    have hy0 : y=0 := norm_eq_zero.mp (le_antisymm (by simpa [← hR0,hx0] using hplus) (norm_nonneg _))
    simp [hx0,hy0,← hR0]
  let t := ‖A.segments.tailDual H y‖
  have ht : 0 ≤ t := norm_nonneg _
  have htn : t ≤ 2*R := by
    have h := A.intrinsic_tail_test hfin hH hRpos hx hplus hminus 0 (by simp) (by simp)
    simpa only [map_zero, zero_pow (by decide : 2 ≠ 0), sub_zero,
      Real.sqrt_sq_eq_abs, abs_of_nonneg hR] using h
  have ht2 : t^2 ≤ (2*R)^2 := (sq_le_sq₀ ht (by positivity)).2 htn
  have hrad : 0 ≤ R^2-t^2/4 := by nlinarith
  have hxn : ‖x‖ ≤ Real.sqrt (R^2-t^2/4) := by
    apply ContinuousLinearMap.opNorm_le_of_unit_norm (Real.sqrt_nonneg _)
    intro u hu
    let p := A.segments.headArray H u
    have hp : ∀ v, v ∉ H → p v=0 := fun v hv => A.segments.headArray_outside H u hv
    have hpn : A.segments.primalSeminorm p ≤ 1 := by
      rw [← SegmentSystem.finiteEmbedding_norm, SegmentSystem.finiteEmbedding_headArray]
      exact (A.headPrimal_norm_le hH u).trans hu.le
    have he : x (A.segments.finiteEmbedding p) = x u := by
      rw [SegmentSystem.finiteEmbedding_headArray, ← SegmentSystem.headDual_apply_apply,
        A.segments.headDual_eq_self hx]
    have hval : |x u| ≤ R := by
      have h := x.le_opNorm u
      rw [Real.norm_eq_abs, hu, mul_one] at h
      exact h.trans hxr
    have hval2 : (x u)^2 ≤ R^2 := by
      simpa only [sq_abs] using (sq_le_sq₀ (abs_nonneg _) hR).2 hval
    have h := A.intrinsic_tail_test hfin hH hRpos hx hplus hminus p hp hpn
    rw [he] at h
    have hsq : t^2 ≤ (2*Real.sqrt (R^2-(x u)^2))^2 :=
      (sq_le_sq₀ ht (by positivity)).2 h
    have hs := Real.sq_sqrt (sub_nonneg.mpr hval2)
    have hv2 : (x u)^2 ≤ R^2-t^2/4 := by nlinarith
    rw [Real.norm_eq_abs]
    apply (sq_le_sq₀ (abs_nonneg _) (Real.sqrt_nonneg _)).mp
    rw [sq_abs, Real.sq_sqrt hrad]
    exact hv2
  have hxn2 := (sq_le_sq₀ (norm_nonneg x) (Real.sqrt_nonneg _)).2 hxn
  rw [Real.sq_sqrt hrad] at hxn2
  change t^2+4*‖x‖^2 ≤ 4*R^2
  nlinarith

lemma finite_heads_of_predecessors
    (hpred : ∀ b : ι, ({a : ι | a ≤ b} : Set ι).Finite) :
    ∀ S : Finset ι, ∃ K : Finset ι, S ⊆ K ∧ A.Ancestral (K : Set ι) := by
  classical
  intro S
  let U : Set ι := ⋃ b ∈ (S : Set ι), {a : ι | a ≤ b}
  have hU : U.Finite := S.finite_toSet.biUnion (fun b _ => hpred b)
  refine ⟨hU.toFinset, ?_, ?_⟩
  · intro b hb
    rw [Set.Finite.mem_toFinset]
    exact Set.mem_iUnion.mpr ⟨b, Set.mem_iUnion.mpr ⟨hb, le_rfl⟩⟩
  · intro a b hab hb
    rw [Finset.mem_coe, Set.Finite.mem_toFinset] at hb ⊢
    obtain ⟨c,hc,hbc⟩ := Set.mem_iUnion₂.mp hb
    exact Set.mem_iUnion₂.mpr ⟨c,hc,hab.trans hbc⟩

lemma coordinate_predual_approximation
    (hfin : ∀ S : Finset ι, ∃ K : Finset ι, S ⊆ K ∧ A.Ancestral (K : Set ι))
    {x : A.segments.Dual} (hx : x ∈ A.segments.CoordinatePredual)
    {ε : ℝ} (hε : 0 < ε) :
    ∃ H : Finset ι, A.Ancestral (H : Set ι) ∧ ‖A.segments.tailDual H x‖ < ε := by
  have hxcl : x ∈ closure (Submodule.span ℝ (Set.range A.segments.coordinate) : Set A.segments.Dual) := hx
  obtain ⟨z,hz,hclose⟩ := Metric.mem_closure_iff.mp hxcl ε hε
  obtain ⟨S,hS⟩ := A.segments.span_coordinates_finite_support hz
  obtain ⟨H,hSH,hH⟩ := hfin S
  have hPH : A.segments.headDual H z = z :=
    A.segments.headDual_eq_self (fun v hv => hS v (fun h => hv (hSH h)))
  refine ⟨H,hH,?_⟩
  have he : A.segments.tailDual H x = A.segments.tailDual H (x-z) := by
    simp only [map_sub, SegmentSystem.tailDual_apply, hPH, sub_self, sub_zero]
  rw [he]
  exact lt_of_le_of_lt (A.tailDual_norm_le hH (x-z)) (by simpa only [dist_eq_norm] using hclose)

/-- Finite-dimensional compactness compares distinct members of any bounded
    sequence; no maximum over the infinitely many children is asserted. -/
lemma finite_head_pair {H : Finset ι} (hH : A.Ancestral (H : Set ι))
    (z : ℕ → A.segments.Dual) {R η : ℝ} (hz : ∀ i, ‖z i‖ ≤ R) (hη : 0 < η) :
    ∃ i j : ℕ, i ≠ j ∧ ‖A.segments.headDual H ((1/2:ℝ) • (z i-z j))‖ < η := by
  classical
  let M := Submodule.span ℝ (A.segments.coordinate '' (H : Set ι))
  have : FiniteDimensional ℝ M :=
    FiniteDimensional.span_of_finite ℝ (H.finite_toSet.image A.segments.coordinate)
  have hm (w : A.segments.Dual) : A.segments.headDual H w ∈ M := by
    rw [SegmentSystem.headDual_apply]
    apply Submodule.sum_mem
    intro v hv
    exact Submodule.smul_mem M _ (Submodule.subset_span ⟨v,hv,rfl⟩)
  let Z : ℕ → M := fun i => ⟨A.segments.headDual H (z i),hm (z i)⟩
  have hZ (i : ℕ) : Z i ∈ Metric.closedBall (0 : M) R := by
    rw [Metric.mem_closedBall]
    change dist (A.segments.headDual H (z i)) 0 ≤ R
    rw [dist_zero_right]
    exact (A.headDual_norm_le hH (z i)).trans (hz i)
  obtain ⟨a,_,φ,hφ,hconv⟩ := tendsto_subseq_of_bounded Metric.isBounded_closedBall hZ
  obtain ⟨N,hN⟩ := Metric.cauchySeq_iff.mp hconv.cauchySeq (2*η) (by positivity)
  have hd := hN N le_rfl (N+1) (by omega)
  change dist (Z (φ N)) (Z (φ (N+1))) < 2*η at hd
  change dist (A.segments.headDual H (z (φ N))) (A.segments.headDual H (z (φ (N+1)))) < 2*η at hd
  rw [dist_eq_norm] at hd
  change ‖A.segments.headDual H (z (φ N)) - A.segments.headDual H (z (φ (N+1)))‖ < 2*η at hd
  refine ⟨φ N, φ (N+1), hφ.injective.ne (by omega), ?_⟩
  rw [map_smul,norm_smul,map_sub,Real.norm_eq_abs,abs_of_pos (by norm_num : (0:ℝ)<1/2)]
  linarith

lemma average_lens {x : A.segments.Dual} (z : ℕ → A.segments.Dual) {R : ℝ}
    (hplus : ∀ i, ‖x+z i‖ ≤ R) (hminus : ∀ i, ‖x-z i‖ ≤ R) (i j : ℕ) :
    ‖x+(1/2:ℝ) • (z i-z j)‖ ≤ R ∧ ‖x-(1/2:ℝ) • (z i-z j)‖ ≤ R := by
  have hp : x+(1/2:ℝ) • (z i-z j) = (1/2:ℝ) • ((x+z i)+(x-z j)) := by module
  have hm : x-(1/2:ℝ) • (z i-z j) = (1/2:ℝ) • ((x-z i)+(x+z j)) := by module
  constructor
  · rw [hp,norm_smul,Real.norm_eq_abs]
    norm_num
    have h := (norm_add_le (x+z i) (x-z j)).trans (add_le_add (hplus i) (hminus j))
    linarith
  · rw [hm,norm_smul,Real.norm_eq_abs]
    norm_num
    have h := (norm_add_le (x-z i) (x+z j)).trans (add_le_add (hminus i) (hplus j))
    linarith

/-- Exact separated-lens consequence of the intrinsic estimate. Its only
    approximation input is explicitly proved for each target model below. -/
lemma separated_lens
    (hfin : ∀ S : Finset ι, ∃ K : Finset ι, S ⊆ K ∧ A.Ancestral (K : Set ι))
    {x : A.segments.Dual}
    (happrox : ∀ η > 0, ∃ H : Finset ι, A.Ancestral (H : Set ι) ∧ ‖A.segments.tailDual H x‖ < η)
    (z : ℕ → A.segments.Dual) {R ε : ℝ} (hR : 0 ≤ R) (hε : 0 < ε)
    (hplus : ∀ i, ‖x+z i‖ ≤ R) (hminus : ∀ i, ‖x-z i‖ ≤ R)
    (hsep : ∀ i j, i ≠ j → ε ≤ ‖z i-z j‖) :
    ‖x‖^2+ε^2/16 ≤ R^2 := by
  have hxr : ‖x‖ ≤ R := A.norm_center_le (hplus 0) (hminus 0)
  have hz (i : ℕ) : ‖z i‖ ≤ R := by
    apply A.norm_center_le (x := z i) (y := x)
    · simpa only [add_comm] using hplus i
    · simpa only [norm_sub_rev] using hminus i
  apply le_of_forall_pos_le_add
  intro δ hδ
  let C : ℝ := 8*R+8*‖x‖+ε+4
  have hC : 0 < C := by dsimp [C]; positivity
  let η : ℝ := min (ε/4) (min 1 (δ/C))
  have hη : 0 < η := lt_min (by positivity) (lt_min (by norm_num) (div_pos hδ hC))
  have hηε : η < ε/2 := lt_of_le_of_lt (min_le_left _ _) (by linarith)
  have hη1 : η ≤ 1 := (min_le_right _ _).trans (min_le_left _ _)
  have hηδ : C*η ≤ δ := by
    have hh : η ≤ δ/C := (min_le_right _ _).trans (min_le_right _ _)
    nlinarith [(le_div_iff₀ hC).mp hh]
  obtain ⟨H,hH,hclose⟩ := happrox η hη
  let p := A.segments.headDual H x
  have hp : ∀ v, v ∉ H → p (A.segments.unitVector v)=0 := by
    intro v hv
    exact (A.segments.headDual_unit H x v).trans (ite_eq_right hv)
  have hpn : ‖p‖ ≤ ‖x‖ := A.headDual_norm_le hH x
  have hsmall : ‖x-p‖ < η := hclose
  have hplower : ‖x‖-η ≤ ‖p‖ := by
    have h := norm_sub_norm_le x p
    linarith
  obtain ⟨i,j,hij,hhead⟩ := A.finite_head_pair hH z hz hη
  let w := (1/2:ℝ) • (z i-z j)
  have hw : ε/2 ≤ ‖w‖ := by
    dsimp [w]
    rw [norm_smul,Real.norm_eq_abs]
    norm_num
    linarith [hsep i j hij]
  have hwl : ε/2-η ≤ ‖A.segments.tailDual H w‖ := by
    have h := norm_sub_norm_le w (A.segments.headDual H w)
    change ‖w‖-‖A.segments.headDual H w‖ ≤ ‖A.segments.tailDual H w‖ at h
    linarith
  obtain ⟨hwp,hwm⟩ := A.average_lens z hplus hminus i j
  have hpp : ‖p+w‖ ≤ R+η := by
    have he : p+w = (x+w)-(x-p) := by module
    rw [he]
    exact (norm_sub_le _ _).trans (add_le_add hwp hsmall.le)
  have hpm : ‖p-w‖ ≤ R+η := by
    have he : p-w = (x-w)-(x-p) := by module
    rw [he]
    exact (norm_sub_le _ _).trans (add_le_add hwm hsmall.le)
  have hbudget := A.intrinsic_tail_sq hfin hH (add_nonneg hR hη.le) hp hpp hpm
  have hpsq : ‖x‖^2 - 2*‖x‖*η ≤ ‖p‖^2 := by
    nlinarith [sq_nonneg (‖x‖-‖p‖),mul_nonneg (norm_nonneg x) (sub_nonneg.mpr hplower)]
  have hw2 : (ε/2)^2-ε*η ≤ ‖A.segments.tailDual H w‖^2 := by
    have hh := (sq_le_sq₀ (by linarith : 0 ≤ ε/2-η) (norm_nonneg _)).2 hwl
    nlinarith
  have hη2 : η^2 ≤ η := by nlinarith
  dsimp [C] at hηδ
  nlinarith

end Ancestry

end DiamondDistortion

end

end OAI