lean/OAI/Analysis/DiamondDistortion/ForestModels.lean

import OAI.Analysis.DiamondDistortion.Orthogonality

namespace OAI

universe u v

noncomputable section
open scoped BigOperators Classical Topology
open Set

namespace DiamondDistortion

def ForestNode := {hw : ℕ × List ℕ // 1 ≤ hw.1 ∧ hw.2.length ≤ hw.1}

def ForestAncestor (a b : ForestNode) : Prop :=
  a.val.1 = b.val.1 ∧ a.val.2.IsPrefix b.val.2

@[instance_reducible] def forestAncestry : Ancestry ForestNode where
  le := ForestAncestor
  lt a b := ForestAncestor a b ∧ ¬ ForestAncestor b a
  le_refl a := ⟨rfl, List.prefix_refl _⟩
  le_trans _ _ _ hab hbc := ⟨hab.1.trans hbc.1, hab.2.trans hbc.2⟩
  le_antisymm a b hab hba := by
    apply Subtype.ext
    exact Prod.ext hab.1 (hab.2.sublist.antisymm hba.2.sublist)
  predecessors_total hab hac := by
    rcases List.prefix_or_prefix_of_prefix hab.2 hac.2 with h | h
    · exact Or.inl ⟨hab.1.trans hac.1.symm, h⟩
    · exact Or.inr ⟨hac.1.trans hab.1.symm, h⟩

def forestSegments : SegmentSystem ForestNode :=
  Ancestry.segments (A := forestAncestry)

/-- Prefix order on all finite words, explicitly distinct from their lexicographic order. -/
@[instance_reducible] def infiniteAncestry : Ancestry (List ℕ) where
  le := List.IsPrefix
  lt a b := a.IsPrefix b ∧ ¬ b.IsPrefix a
  le_refl := List.prefix_refl
  le_trans _ _ _ := List.IsPrefix.trans
  le_antisymm _ _ hab hba := hab.sublist.antisymm hba.sublist
  predecessors_total := List.prefix_or_prefix_of_prefix

/-- The infinite-height tree of all finite words; this includes the empty root. -/
def infiniteSegments : SegmentSystem (List ℕ) :=
  Ancestry.segments (A := infiniteAncestry)

lemma infinite_finite_heads : ∀ S : Finset (List ℕ), ∃ K : Finset (List ℕ),
    S ⊆ K ∧ Ancestry.Ancestral (A := infiniteAncestry) (K : Set (List ℕ)) := by
  apply Ancestry.finite_heads_of_predecessors (A := infiniteAncestry)
  intro b
  exact b.inits.toFinset.finite_toSet.subset (by
    intro a ha
    exact List.mem_toFinset.mpr ((List.mem_inits a b).mpr ha))

lemma forest_finite_heads : ∀ S : Finset ForestNode, ∃ K : Finset ForestNode,
    S ⊆ K ∧ Ancestry.Ancestral (A := forestAncestry) (K : Set ForestNode) := by
  apply Ancestry.finite_heads_of_predecessors (A := forestAncestry)
  intro b
  have hfin : (({b.val.1} : Set ℕ) ×ˢ (b.val.2.inits.toFinset : Set (List ℕ))).Finite :=
    (Set.finite_singleton _).prod b.val.2.inits.toFinset.finite_toSet
  have hpre := hfin.preimage (f := (Subtype.val : ForestNode → ℕ × List ℕ)) Subtype.val_injective.injOn
  apply hpre.subset
  intro a ha
  exact ⟨ha.1, List.mem_toFinset.mpr ((List.mem_inits _ _).mpr ha.2)⟩

namespace Forest

def component (v : ForestNode) : ℕ := v.val.1

lemma same_component (S : Finset ForestNode) (hS : forestSegments.IsSegment S)
    (u : ForestNode) (hu : u ∈ S) (v : ForestNode) (hv : v ∈ S) :
    component u=component v := by
  obtain ⟨a,b,_,hm⟩ := hS
  exact ((hm u).mp hu).2.1.trans ((hm v).mp hv).2.1.symm

lemma segment_card_le (S : Finset ForestNode) (hS : forestSegments.IsSegment S)
    (u : ForestNode) (hu : u ∈ S) : S.card ≤ component u+1 := by
  obtain ⟨a,b,_,hm⟩ := hS
  have hcard : S.card ≤ (Finset.range (component b+1)).card := by
    apply Finset.card_le_card_of_injOn (fun v : ForestNode => v.val.2.length)
    · intro v hv
      have hvb := ((hm v).mp hv).2
      apply Finset.mem_range.mpr
      exact Nat.lt_succ_of_le (hvb.2.length_le.trans b.property.2)
    · intro v hv w hw he
      have hvb := ((hm v).mp hv).2
      have hwb := ((hm w).mp hw).2
      have hword : v.val.2=w.val.2 := by
        rcases List.prefix_or_prefix_of_prefix hvb.2 hwb.2 with h | h
        · exact h.eq_of_length he
        · exact (h.eq_of_length he.symm).symm
      exact Subtype.ext (Prod.ext (hvb.1.trans hwb.1.symm) hword)
  rw [Finset.card_range] at hcard
  have he : component u=component b := ((hm u).mp hu).2.1
  rwa [he]

lemma primal_sq_bounded_components (C : Finset ℕ) (p : ForestNode →₀ ℝ)
    (hp : ∀ v ∈ p.support, component v ∈ C) :
    (forestSegments.primalSeminorm p)^2 ≤ (((C.sup (id : ℕ → ℕ) : ℕ) : ℝ)+1)*(∑ v ∈ p.support,p v^2) := by
  apply forestSegments.primal_sq_le_of_segment p (by positivity)
  intro S hS
  by_cases hz : (∑ v ∈ S,p v)=0
  · rw [hz,zero_pow (by decide : (2 : ℕ) ≠ 0)]
    positivity
  obtain ⟨u,hu,hpu⟩ := Finset.exists_ne_zero_of_sum_ne_zero hz
  have hcu := hp u (Finsupp.mem_support_iff.mpr hpu)
  have hcard : (S.card : ℝ) ≤ ((C.sup (id : ℕ → ℕ) : ℕ) : ℝ)+1 := by
    have h := (segment_card_le S hS u hu).trans (Nat.add_le_add_right (Finset.le_sup (f := id) hcu) 1)
    exact_mod_cast h
  exact sq_sum_le_card_mul_sum_sq.trans (mul_le_mul_of_nonneg_right hcard
    (Finset.sum_nonneg (fun _ _ => sq_nonneg _)))

def coefficients (C : Finset ℕ) (x : forestSegments.Dual) (v : ForestNode) : ℝ :=
  if component v ∈ C then x (forestSegments.unitVector v) else 0

lemma coefficients_bounded (C : Finset ℕ) (x : forestSegments.Dual) (S : Finset ForestNode) :
    (∑ v ∈ S,coefficients C x v^2) ≤ (((C.sup (id : ℕ → ℕ) : ℕ) : ℝ)+1)*‖x‖^2 := by
  classical
  let a := coefficients C x
  let p := SegmentSystem.finiteArray S a
  let B := ∑ v ∈ S,a v^2
  have hB : 0 ≤ B := Finset.sum_nonneg (fun _ _ => sq_nonneg _)
  have hp : ∀ v ∈ p.support,component v ∈ C := by
    intro v hv
    by_contra hn
    have hav : a v=0 := ite_eq_right hn
    have hpv : p v=0 := by rw [SegmentSystem.finiteArray_apply,hav]; split_ifs <;> rfl
    exact (Finsupp.mem_support_iff.mp hv) hpv
  have hpenergy := primal_sq_bounded_components C p hp
  rw [SegmentSystem.finiteArray_energy] at hpenergy
  have he : x (forestSegments.finiteEmbedding p)=B := by
    rw [forestSegments.finiteArray_pairing]
    apply Finset.sum_congr rfl
    intro v _
    dsimp [a,coefficients]
    split_ifs <;> ring
  have hval : B ≤ ‖x‖*forestSegments.primalSeminorm p := by
    rw [← he]
    exact (Real.le_norm_self _).trans (by
      simpa only [SegmentSystem.finiteEmbedding_norm] using x.le_opNorm (forestSegments.finiteEmbedding p))
  have hsq := (sq_le_sq₀ hB
    (mul_nonneg (norm_nonneg _) (apply_nonneg _ _))).2 hval
  have hmul := mul_le_mul_of_nonneg_left hpenergy (sq_nonneg ‖x‖)
  change B ≤ (((C.sup (id : ℕ → ℕ) : ℕ) : ℝ)+1)*‖x‖^2
  by_contra hn
  have hpos : 0 < B := lt_of_le_of_lt (by positivity) (lt_of_not_ge hn)
  have hc := mul_pos hpos (sub_pos.mpr (lt_of_not_ge hn))
  change (forestSegments.primalSeminorm p)^2 ≤ (((C.sup (id : ℕ → ℕ) : ℕ) : ℝ)+1)*B at hpenergy
  change ‖x‖^2*(forestSegments.primalSeminorm p)^2 ≤ ‖x‖^2*((((C.sup (id : ℕ → ℕ) : ℕ) : ℝ)+1)*B) at hmul
  nlinarith only [hsq,hmul,hc]

lemma finite_component_tail (C : Finset ℕ) (x : forestSegments.Dual) {ε : ℝ} (hε : 0 < ε) :
    ∃ S : Finset ForestNode, ∀ p : ForestNode →₀ ℝ,
      (∀ v ∈ p.support, component v ∈ C) → (∀ v ∈ p.support,v ∉ S) →
      |x (forestSegments.finiteEmbedding p)| ≤ ε*forestSegments.primalSeminorm p := by
  classical
  obtain ⟨S,hS⟩ := SegmentSystem.finite_square_tails (coefficients C x)
    (coefficients_bounded C x) (sq_pos_of_pos hε)
  refine ⟨S,?_⟩
  intro p hp hout
  have hd : Disjoint S p.support := Finset.disjoint_left.mpr (fun v hv hvs => hout v hvs hv)
  have ha : Real.sqrt (∑ v ∈ p.support,coefficients C x v^2) ≤ ε :=
    (Real.sqrt_le_left hε.le).mpr (hS p.support hd).le
  have hb : Real.sqrt (∑ v ∈ p.support,p v^2) ≤ forestSegments.primalSeminorm p :=
    (Real.sqrt_le_left (apply_nonneg _ _)).mpr (forestSegments.coordinate_energy_le p p.support)
  have he : x (forestSegments.finiteEmbedding p) =
      ∑ v ∈ p.support,p v*coefficients C x v := by
    rw [SegmentSystem.finiteEmbedding_apply,SegmentSystem.dual_coe_apply]
    apply Finset.sum_congr rfl
    intro v hv
    rw [coefficients,ite_eq_left (hp v hv)]
    rfl
  rw [he]
  calc
    _ ≤ ∑ v ∈ p.support, |p v| * |coefficients C x v| := by
      simpa only [abs_mul] using Finset.abs_sum_le_sum_abs (fun v => p v*coefficients C x v) p.support
    _ ≤ Real.sqrt (∑ v ∈ p.support,p v^2) * Real.sqrt (∑ v ∈ p.support,coefficients C x v^2) := by
      simpa only [sq_abs] using Real.sum_mul_le_sqrt_mul_sqrt p.support
        (fun v => |p v|) (fun v => |coefficients C x v|)
    _ ≤ forestSegments.primalSeminorm p * ε := mul_le_mul hb ha (Real.sqrt_nonneg _) (apply_nonneg _ _)
    _ = _ := mul_comm _ _

lemma component_set_ancestral (C : Finset ℕ) :
    Ancestry.Ancestral (A := forestAncestry) {v : ForestNode | component v ∈ C} := by
  intro a b hab hb
  change ForestAncestor a b at hab
  change component a ∈ C
  change component b ∈ C at hb
  have he : component a=component b := hab.1
  rwa [he]

/-- The full finite-height forest dual really has finite ancestral head
    approximation. Both the component tail and coordinate tail arguments are
    proved from its disjoint-segment norm, rather than imposed as hypotheses. -/
lemma full_dual_approximation (x : forestSegments.Dual) {ε : ℝ} (hε : 0 < ε) :
    ∃ H : Finset ForestNode, Ancestry.Ancestral (A := forestAncestry) (H : Set ForestNode) ∧
      ‖forestSegments.tailDual H x‖ < ε := by
  classical
  have hd : 0 < ε/4 := by positivity
  obtain ⟨C,hC⟩ := forestSegments.small_color_tail component same_component x hd
  obtain ⟨S,hS⟩ := finite_component_tail C x hd
  obtain ⟨H,hSH,hH⟩ := forest_finite_heads S
  refine ⟨H,hH,?_⟩
  have hbound : ‖forestSegments.tailDual H x‖ ≤ ε/2 := by
    apply ContinuousLinearMap.opNorm_le_bound _ (by positivity)
    intro u
    induction u using UniformSpace.Completion.induction_on with
    | hp => exact isClosed_le (by fun_prop) (by fun_prop)
    | ih u =>
      let p := forestSegments.ofPrimal u
      let q := p.filter (fun v => v ∉ H)
      let qi := q.filter (fun v => component v ∈ C)
      let qo := q.filter (fun v => component v ∉ C)
      have hqi : ∀ v ∈ qi.support,component v ∈ C := by
        intro v hv
        rw [Finsupp.support_filter] at hv
        exact (Finset.mem_filter.mp hv).2
      have hqiS : ∀ v ∈ qi.support,v ∉ S := by
        intro v hv hvs
        rw [Finsupp.support_filter] at hv
        have hvq := (Finset.mem_filter.mp hv).1
        rw [Finsupp.support_filter] at hvq
        exact (Finset.mem_filter.mp hvq).2 (hSH hvs)
      have hqo : ∀ v ∈ qo.support,component v ∉ C := by
        intro v hv
        rw [Finsupp.support_filter] at hv
        exact (Finset.mem_filter.mp hv).2
      have hi := hS qi hqi hqiS
      have ho := hC qo hqo
      have hqin : forestSegments.primalSeminorm qi ≤ forestSegments.primalSeminorm q := by
        change (Ancestry.segments (A := forestAncestry)).primalSeminorm qi ≤
          (Ancestry.segments (A := forestAncestry)).primalSeminorm q
        convert Ancestry.primal_filter_le (A := forestAncestry) (component_set_ancestral C) q using 1
        all_goals dsimp [qi,qo]; congr
      have hqon : forestSegments.primalSeminorm qo ≤ forestSegments.primalSeminorm q := by
        change (Ancestry.segments (A := forestAncestry)).primalSeminorm qo ≤
          (Ancestry.segments (A := forestAncestry)).primalSeminorm q
        convert Ancestry.primal_filter_tail_le (A := forestAncestry) (component_set_ancestral C) q using 1
        all_goals dsimp [qi,qo]; congr
      have hqn : forestSegments.primalSeminorm q ≤ forestSegments.primalSeminorm p := by
        change (Ancestry.segments (A := forestAncestry)).primalSeminorm q ≤
          (Ancestry.segments (A := forestAncestry)).primalSeminorm p
        convert Ancestry.primal_filter_tail_le (A := forestAncestry) hH p using 1
        all_goals dsimp [q]; congr
      have hsum : qi+qo=q := by
        apply Finsupp.ext
        intro v
        by_cases hv : component v ∈ C <;> simp [qi,qo]
      have he : forestSegments.tailDual H x (u : forestSegments.JamesSpace) =
          x (forestSegments.finiteEmbedding q) := by
        rw [SegmentSystem.tailDual_apply_apply,SegmentSystem.headPrimal_coe,
          ← UniformSpace.Completion.coe_sub,SegmentSystem.sub_filterPrimal]
        congr 2
        apply Finsupp.ext
        intro v
        simp [SegmentSystem.filterPrimal,q,p,SegmentSystem.ofPrimal]
        congr
      rw [he,Real.norm_eq_abs,UniformSpace.Completion.norm_coe,SegmentSystem.norm_eq_primal]
      calc
        _ = |x (forestSegments.finiteEmbedding qi)+x (forestSegments.finiteEmbedding qo)| := by
          rw [← hsum,map_add,map_add]
        _ ≤ |x (forestSegments.finiteEmbedding qi)|+|x (forestSegments.finiteEmbedding qo)| := abs_add_le _ _
        _ ≤ (ε/4)*forestSegments.primalSeminorm qi+(ε/4)*forestSegments.primalSeminorm qo := add_le_add hi ho
        _ ≤ (ε/4)*forestSegments.primalSeminorm q+(ε/4)*forestSegments.primalSeminorm q :=
          add_le_add (mul_le_mul_of_nonneg_left hqin hd.le) (mul_le_mul_of_nonneg_left hqon hd.le)
        _ ≤ _ := by nlinarith [mul_le_mul_of_nonneg_left hqn hd.le]
  exact lt_of_le_of_lt hbound (by linarith)

end Forest

abbrev ForestDual := forestSegments.Dual
abbrev InfinitePredual := infiniteSegments.CoordinatePredual

end DiamondDistortion

end

end OAI