lean/OAI/Combinatorics/GraphThreshold/TreeCovering.lean

import OAI.Combinatorics.GraphThreshold.ProbabilityTreeTrim
import OAI.Combinatorics.GraphThreshold.CapacityIteration
import OAI.Combinatorics.GraphThreshold.AdaptiveTrials
import OAI.Combinatorics.GraphThreshold.TreeReduction
import OAI.Combinatorics.GraphThreshold.BernoulliMonotonicity
import OAI.Combinatorics.GraphThreshold.TreePotential
import Mathlib.Tactic

namespace OAI

/-!
# Covering a probability tree by iterative reductions

Recovery keeps the original and retained path histories distinct, even when
their labels agree. All draws are retained in the accumulating union.
-/

noncomputable section
open Classical

namespace LeanBlast.SecondKahnKalai

/-- A nondecreasing finite list of capacities has a zero prefix followed by
strictly positive capacities. The empty positive suffix is permitted. -/
theorem exists_zero_prefix_positive_suffix (m : ℕ → ℕ) (d : ℕ)
    (hmono : MonotoneOn m (Set.Iio d)) :
    ∃ k, k ≤ d ∧ (∀ i, i < k → m i = 0) ∧
      (∀ i, i < d - k → 0 < m (i + k)) := by
  classical
  by_cases h : ∃ k, k < d ∧ 0 < m k
  · let k := Nat.find h
    have hk : k < d ∧ 0 < m k := Nat.find_spec h
    refine ⟨k, hk.1.le, ?_, ?_⟩
    · intro i hi
      by_contra hzero
      have hip : 0 < m i := Nat.pos_of_ne_zero hzero
      have hki : k ≤ i := Nat.find_min' h ⟨lt_trans hi hk.1, hip⟩
      omega
    · intro i hi
      have hik : i + k < d := by omega
      exact lt_of_lt_of_le hk.2 (hmono hk.1 hik (by omega))
  · refine ⟨d, le_rfl, ?_, ?_⟩
    · intro i hi
      by_contra hzero
      exact h ⟨i, hi, Nat.pos_of_ne_zero hzero⟩
    · intro i hi
      omega

theorem capacityReserve_div_sampling_le {σ : ℝ} (hσ : 0 < σ) (m : ℕ) :
    capacityReserve σ m / (Real.exp 50 * (4 * σ)) ≤ Real.exp (-50) := by
  have hp : 0 < Real.exp 50 * (4 * σ) := by positivity
  calc
    _ ≤ (4 * σ) / (Real.exp 50 * (4 * σ)) :=
      div_le_div_of_nonneg_right (capacityReserve_upper hσ.le m) hp.le
    _ = Real.exp (-50) := by
      rw [Real.exp_neg]
      field_simp

theorem sampling_budget_le {σ : ℝ} (hσ : 0 ≤ σ) (L : ℕ) :
    ((4 * successesNeeded L : ℕ) : ℝ) * (Real.exp 50 * (4 * σ)) ≤
      16 * Real.exp 50 * σ * (1 + Real.logb 2 (L : ℝ)) := by
  calc
    _ = (16 * Real.exp 50 * σ) * (successesNeeded L : ℝ) := by push_cast; ring
    _ ≤ _ := mul_le_mul_of_nonneg_left (successesNeeded_le_logb L) (by positivity)

namespace ProbabilityTree

variable {X : Type} [DecidableEq X]

/-- Each path of a retained tree recovers a path of the original tree after
the already collected coordinates are added. -/
def Recovers {d e : ℕ} (T : ProbabilityTree X d) (S : ProbabilityTree X e)
    (W : Finset X) : Prop :=
  ∀ q : S.Path, ∃ p : T.Path, T.pathUnion p ⊆ W ∪ S.pathUnion q

theorem Recovers.refl {d : ℕ} (T : ProbabilityTree X d) : Recovers T T ∅ := by
  intro p
  exact ⟨p, by simp⟩

theorem Recovers.mono {d e : ℕ} {T : ProbabilityTree X d} {S : ProbabilityTree X e}
    {W V : Finset X} (h : Recovers T S W) (hWV : W ⊆ V) : Recovers T S V := by
  intro q
  obtain ⟨p, hp⟩ := h q
  exact ⟨p, hp.trans (Finset.union_subset_union hWV (Finset.Subset.refl _))⟩

/-- Recovery composes through the union of the independent draws. -/
theorem Recovers.trans {d e f : ℕ}
    {T : ProbabilityTree X d} {S : ProbabilityTree X e} {U : ProbabilityTree X f}
    {W V : Finset X} (hTS : Recovers T S W) (hSU : Recovers S U V) :
    Recovers T U (W ∪ V) := by
  intro r
  obtain ⟨q, hq⟩ := hSU r
  obtain ⟨p, hp⟩ := hTS q
  refine ⟨p, ?_⟩
  simpa only [Finset.union_assoc] using
    hp.trans (Finset.union_subset_union (Finset.Subset.refl W) hq)

/-- A covered retained path yields a covered original path. -/
theorem Recovers.coveredBy {d e : ℕ} {T : ProbabilityTree X d} {S : ProbabilityTree X e}
    {W V : Finset X} (h : Recovers T S W) (hS : S.CoveredBy V) :
    T.CoveredBy (W ∪ V) := by
  obtain ⟨q, hq⟩ := hS
  obtain ⟨p, hp⟩ := h q
  exact ⟨p, hp.trans (Finset.union_subset_union (Finset.Subset.refl W) hq)⟩

/-- When no levels remain, recovery is already a covering certificate. -/
theorem Recovers.coveredBy_of_depth_zero {d : ℕ} {T : ProbabilityTree X d}
    {S : ProbabilityTree X 0} {W : Finset X} (h : Recovers T S W) : T.CoveredBy W := by
  cases S
  obtain ⟨p, hp⟩ := h PUnit.unit
  exact ⟨p, by simpa only [pathUnion, Finset.union_empty] using hp⟩

theorem Recovers.coveredBy_of_depth_eq_zero {d e : ℕ} {T : ProbabilityTree X d}
    {S : ProbabilityTree X e} {W : Finset X} (h : Recovers T S W) (he : e = 0) :
    T.CoveredBy W := by
  subst e
  exact h.coveredBy_of_depth_zero

/-- Removing empty initial labels preserves recovery without adding any
coordinates. The path lifting premise is supplied by deterministic prefix
removal. -/
theorem Recovers.of_pathUnion_eq {d e : ℕ}
    {T : ProbabilityTree X d} {S : ProbabilityTree X e}
    (h : ∀ q : S.Path, ∃ p : T.Path, T.pathUnion p = S.pathUnion q) :
    Recovers T S ∅ := by
  intro q
  obtain ⟨p, hp⟩ := h q
  exact ⟨p, by simp [hp]⟩

/-- Increasing each nonnegative level spread parameter preserves spread. -/
theorem HasSpread.mono {d : ℕ} {T : ProbabilityTree X d} {a b : ℕ → ℝ}
    (hT : T.HasSpread a) (ha : ∀ i, i < d → 0 ≤ a i)
    (hab : ∀ i, i < d → a i ≤ b i) : T.HasSpread b := by
  induction T generalizing a b with
  | leaf => trivial
  | @node d B inst law positive label child ih =>
      constructor
      · intro J hJ
        exact (hT.1 J hJ).trans (pow_le_pow_left₀ (ha 0 (by omega)) (hab 0 (by omega)) _)
      · intro c
        exact ih c (hT.2 c) (fun i hi => ha (i + 1) (by omega))
          (fun i hi => hab (i + 1) (by omega))

theorem coveredBy_probability_one [Fintype X] {d : ℕ} (T : ProbabilityTree X d) :
    bernoulliProbability 1 T.CoveredBy = 1 := by
  apply le_antisymm
  · exact (bernoulliLaw 1 (by norm_num) le_rfl).prob_le_one T.CoveredBy
  · have h := (bernoulliLaw (X := X) 1 (by norm_num) le_rfl).prob_mono
      (P := fun W => Finset.univ ⊆ W) (Q := T.CoveredBy)
      (fun _ hW => coveredBy_mono (coveredBy_univ T) hW)
    change bernoulliProbability 1 (fun W => Finset.univ ⊆ W) ≤
      bernoulliProbability 1 T.CoveredBy at h
    simpa only [bernoulliProbability_subset, one_pow] using h

/-- The actual retained tree, its spread budget, and recovery to the fixed
original tree. Only positive-capacity levels are stored. -/
structure CoverState {k : ℕ} (original : ProbabilityTree X k) (σ : ℝ) where
  depth : ℕ
  tree : ProbabilityTree X depth
  capacity : ℕ → ℕ
  disjoint : tree.IsDisjoint
  capacities : tree.HasCapacities capacity
  spread : tree.HasSpread (fun i => capacityReserve σ (capacity i))
  positive : ∀ i, i < depth → 0 < capacity i
  growth : ∀ i, i + 1 < depth → 16 * capacity i ≤ capacity (i + 1)
  seen : Finset X
  recovery : Recovers original tree seen

namespace CoverState

variable {k : ℕ} {original : ProbabilityTree X k} {σ : ℝ}

def initial (original : ProbabilityTree X k) (σ : ℝ) (m : ℕ → ℕ)
    (hσ : 0 < σ) (hdisjoint : original.IsDisjoint)
    (hcapacity : original.HasCapacities m)
    (hspread : original.HasSpread (fun _ => σ))
    (hpositive : ∀ i, i < k → 0 < m i)
    (hgrowth : ∀ i, i + 1 < k → 16 * m i ≤ m (i + 1)) : CoverState original σ :=
  { depth := k
    tree := original
    capacity := m
    disjoint := hdisjoint
    capacities := hcapacity
    spread := hspread.mono (fun _ _ => hσ.le) (fun i _ => capacityReserve_lower hσ.le (m i))
    positive := hpositive
    growth := hgrowth
    seen := ∅
    recovery := Recovers.refl original }

def rank (state : CoverState original σ) : ℕ :=
  if state.depth = 0 then 0 else successesNeeded (state.capacity (state.depth - 1))

@[simp] theorem rank_eq_zero_iff (state : CoverState original σ) :
    state.rank = 0 ↔ state.depth = 0 := by
  unfold rank
  split_ifs with h
  · simp [h]
  · simp [h, ne_of_gt (successesNeeded_pos _)]

theorem coveredBy_of_rank_zero (state : CoverState original σ) (h : state.rank = 0) :
    original.CoveredBy state.seen :=
  state.recovery.coveredBy_of_depth_eq_zero ((rank_eq_zero_iff state).mp h)

/-- Every draw is retained even when the reduction attempt fails. -/
def accumulate (state : CoverState original σ) (W : Finset X) : CoverState original σ :=
  { state with
    seen := state.seen ∪ W
    recovery := state.recovery.mono Finset.subset_union_left }

@[simp] theorem accumulate_rank (state : CoverState original σ) (W : Finset X) :
    (state.accumulate W).rank = state.rank := rfl

def Advances (state : CoverState original σ) (W : Finset X)
    (next : CoverState original σ) : Prop :=
  next.rank < state.rank ∧ next.seen = state.seen ∪ W

/-- Choose a strict improvement when one exists; otherwise keep the tree.
Existence of improvements will be supplied by the actual good-tree reduction. -/
def step (state : CoverState original σ) (W : Finset X) : CoverState original σ :=
  if h : ∃ next, state.Advances W next then Classical.choose h else state.accumulate W

theorem step_seen (state : CoverState original σ) (W : Finset X) :
    (state.step W).seen = state.seen ∪ W := by
  unfold step
  split_ifs with h
  · exact (Classical.choose_spec h).2
  · rfl

theorem step_rank_le (state : CoverState original σ) (W : Finset X) :
    (state.step W).rank ≤ state.rank := by
  unfold step
  split_ifs with h
  · exact (Classical.choose_spec h).1.le
  · exact le_rfl

theorem step_rank_lt_of_exists (state : CoverState original σ) (W : Finset X)
    (h : ∃ next, state.Advances W next) : (state.step W).rank < state.rank := by
  unfold step
  rw [dite_eq_left h]
  exact (Classical.choose_spec h).1

theorem biUnion_fin_succ {n : ℕ} (draws : Fin (n + 1) → Finset X) :
    Finset.univ.biUnion draws = draws 0 ∪ Finset.univ.biUnion (fun i : Fin n => draws i.succ) := by
  ext x
  simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_union]
  constructor
  · rintro ⟨i, hi⟩
    refine Fin.cases (fun hx => Or.inl hx) (fun j hx => Or.inr ⟨j, hx⟩) i hi
  · rintro (h | ⟨i, hi⟩)
    · exact ⟨0, h⟩
    · exact ⟨i.succ, hi⟩

/-- The recorded set is exactly the union of all draws, including failures. -/
theorem run_seen (n : ℕ) (state : CoverState original σ) (draws : Fin n → Finset X) :
    (adaptiveRun step n state draws).seen = state.seen ∪ Finset.univ.biUnion draws := by
  induction n generalizing state with
  | zero => simp [adaptiveRun]
  | succ n ih =>
      rw [adaptiveRun, ih, step_seen, biUnion_fin_succ, Finset.union_assoc]

/-- The finite adaptive theorem transfers actual strict advances to covering.
The good-tree probability estimate supplies the premise in the final theorem. -/
theorem prob_covered_of_advance_probability [Fintype X] (μ : FiniteLaw (Finset X))
    (hprogress : ∀ state : CoverState original σ, state.rank ≠ 0 →
      (3 / 4 : ℝ) ≤ μ.prob (fun W => ∃ next, state.Advances W next))
    (s : ℕ) (state : CoverState original σ) (hrank : state.rank ≤ s) :
    (2 / 3 : ℝ) ≤ (μ.iid (4 * s)).prob
      (fun draws => original.CoveredBy (state.seen ∪ Finset.univ.biUnion draws)) := by
  have hp : ∀ st : CoverState original σ, st.rank ≠ 0 →
      (3 / 4 : ℝ) ≤ μ.prob (fun W => (st.step W).rank < st.rank) := by
    intro st hst
    exact (hprogress st hst).trans (μ.prob_mono fun W hW => st.step_rank_lt_of_exists W hW)
  have hcomplete := adaptive_rank_completion μ rank step step_rank_le hp s state hrank
  apply hcomplete.trans
  apply (μ.iid (4 * s)).prob_mono
  intro draws hdraws
  have hcover := (adaptiveRun step (4 * s) state draws).coveredBy_of_rank_zero hdraws
  rwa [run_seen] at hcover

/-- A halved tree, after its zero prefix is removed, is a strict improvement
of the current positive-capacity tree. -/
theorem exists_advance_of_halved (state : CoverState original σ) (W : Finset X)
    (hdepth : state.depth ≠ 0) (U : ProbabilityTree X state.depth)
    (hdisjoint : U.IsDisjoint)
    (hcapacity : U.HasCapacities (fun i => state.capacity i / 2))
    (hspread : U.HasSpread (fun i => capacityReserve σ (state.capacity i / 2)))
    (hrecovery : Recovers state.tree U W) :
    ∃ next, state.Advances W next := by
  let m : ℕ → ℕ := fun i => state.capacity i / 2
  have hgrowth : ∀ i, i + 1 < state.depth → 16 * m i ≤ m (i + 1) := by
    intro i hi
    simpa [m, reducedCapacity] using reducedCapacity_growth (state.growth i hi) 1
  obtain ⟨j, hj, hzero, hpositive⟩ := exists_zero_prefix_positive_suffix m state.depth
    (monotoneOn_capacities m state.depth hgrowth)
  let V := U.dropPrefix j hj
  have htrim : Recovers U V ∅ := by
    apply Recovers.of_pathUnion_eq
    intro q
    exact ⟨liftDropPrefixPath U j hj q,
      pathUnion_liftDropPrefixPath_eq hcapacity j hj hzero q⟩
  let next : CoverState original σ :=
    { depth := state.depth - j
      tree := V
      capacity := fun i => m (i + j)
      disjoint := dropPrefix_isDisjoint hdisjoint j hj
      capacities := dropPrefix_hasCapacities hcapacity j hj
      spread := dropPrefix_hasSpread hspread j hj
      positive := hpositive
      growth := by
        intro i hi
        simpa only [Nat.add_assoc, Nat.add_comm 1 j] using hgrowth (i + j) (by omega)
      seen := state.seen ∪ W
      recovery := by
        simpa only [Finset.union_empty] using (state.recovery.trans hrecovery).trans htrim }
  refine ⟨next, ?_, rfl⟩
  change (if state.depth - j = 0 then 0 else
    successesNeeded (m (state.depth - j - 1 + j))) < state.rank
  by_cases hempty : state.depth - j = 0
  · rw [ite_eq_left hempty]
    exact Nat.pos_of_ne_zero (fun h => hdepth ((rank_eq_zero_iff state).mp h))
  · rw [ite_eq_right hempty]
    have hindex : state.depth - j - 1 + j = state.depth - 1 := by omega
    rw [hindex]
    unfold rank
    rw [ite_eq_right hdepth]
    apply successesNeeded_half_lt
    have hp := hpositive (state.depth - j - 1) (by omega)
    simpa only [hindex] using hp

/-- A good draw produces an actual strict advance: construct the pruned tree,
preserve the reserve budget, and delete exactly its zero-capacity prefix. -/
theorem exists_advance_of_good (state : CoverState original σ) (W : Finset X)
    (hσ : 0 < σ) {ρ : ℝ} (hρ : 0 < ρ) (hrank : state.rank ≠ 0)
    (hgood : Good ρ state.capacity W state.tree) :
    ∃ next, state.Advances W next := by
  let U := reduceTree ρ state.capacity W state.tree hρ state.positive hgood
  have ha : ∀ i, i < state.depth → 0 ≤ capacityReserve σ (state.capacity i) :=
    fun i _ => (capacityReserve_pos hσ (state.capacity i)).le
  have hspread := reduceTree_hasSpread ρ state.capacity W state.tree hρ state.positive
    hgood (fun i => capacityReserve σ (state.capacity i)) ha state.spread
  refine state.exists_advance_of_halved W
    (fun hd => hrank ((rank_eq_zero_iff state).mpr hd)) U
    (reduceTree_isDisjoint ρ state.capacity W state.tree hρ state.positive hgood state.disjoint)
    (reduceTree_hasCapacities ρ state.capacity W state.tree hρ state.positive hgood) ?_
    (reduceTree_path_recovery ρ state.capacity W state.tree hρ state.positive hgood)
  exact hspread.mono
    (fun i hi => div_nonneg (ha i hi) (retentionFactor_pos (state.positive i hi)).le)
    (fun i hi => capacityReserve_div_le_half hσ.le (state.positive i hi))

end CoverState

end ProbabilityTree

/-- The finite random experiment and final parameter comparison. The next
theorem supplies this private lemma's progress estimate from actual reduction. -/
private theorem tree_covering_of_progress {X : Type} [Fintype X] [DecidableEq X]
    {k : ℕ} (T : ProbabilityTree X k) (hk : 0 < k) (hdis : T.IsDisjoint)
    (m : ℕ → ℕ) (hcap : T.HasCapacities m) (hpos : ∀ i, i < k → 0 < m i)
    (hgrowth : ∀ i, i + 1 < k → 16 * m i ≤ m (i + 1))
    (σ : ℝ) (hσ : 0 < σ) (hspread : T.HasSpread (fun _ => σ))
    (hprogress : Real.exp 50 * (4 * σ) < 1 →
      ∀ state : ProbabilityTree.CoverState T σ, state.rank ≠ 0 →
        (3 / 4 : ℝ) ≤ bernoulliProbability (Real.exp 50 * (4 * σ))
          (fun W => ∃ next, state.Advances W next)) :
    (2 / 3 : ℝ) ≤ bernoulliProbability
      (min 1 (16 * Real.exp 50 * σ * (1 + Real.logb 2 (m (k - 1) : ℝ)))) T.CoveredBy := by
  let B := 16 * Real.exp 50 * σ * (1 + Real.logb 2 (m (k - 1) : ℝ))
  change (2 / 3 : ℝ) ≤ bernoulliProbability (min 1 B) T.CoveredBy
  by_cases hB : 1 ≤ B
  · rw [min_eq_left hB, ProbabilityTree.coveredBy_probability_one]
    norm_num
  have hB1 : B < 1 := lt_of_not_ge hB
  let p := Real.exp 50 * (4 * σ)
  have hp : 0 < p := by dsimp [p]; positivity
  have hlog : 0 ≤ Real.logb 2 (m (k - 1) : ℝ) :=
    capacity_logb_nonneg (hpos (k - 1) (by omega))
  have hBp : 4 * p ≤ B := by
    calc
      4 * p = (16 * Real.exp 50 * σ) * 1 := by dsimp [p]; ring
      _ ≤ B := mul_le_mul_of_nonneg_left (by linarith : (1 : ℝ) ≤
        1 + Real.logb 2 (m (k - 1) : ℝ)) (by positivity)
  have hp1 : p < 1 := by linarith
  let μ := bernoulliLaw (X := X) p hp.le hp1.le
  let state := ProbabilityTree.CoverState.initial T σ m hσ hdis hcap hspread hpos hgrowth
  let s := successesNeeded (m (k - 1))
  have hrank : state.rank ≤ s := by
    change (if k = 0 then 0 else successesNeeded (m (k - 1))) ≤ s
    rw [ite_eq_right (Nat.ne_of_gt hk)]
  have hprog : ∀ st : ProbabilityTree.CoverState T σ, st.rank ≠ 0 →
      (3 / 4 : ℝ) ≤ μ.prob (fun W => ∃ next, st.Advances W next) :=
    fun st hst => hprogress hp1 st hst
  have hc := ProbabilityTree.CoverState.prob_covered_of_advance_probability μ hprog s state hrank
  have hseen : state.seen = ∅ := rfl
  simp only [hseen, Finset.empty_union] at hc
  change (2 / 3 : ℝ) ≤ ((bernoulliLaw p hp.le hp1.le).iid (4 * s)).prob
    (fun draws => T.CoveredBy (Finset.univ.biUnion draws)) at hc
  rw [iid_bernoulli_union_probability] at hc
  have hq0 := (bernoulli_union_parameter_mem hp.le hp1.le (4 * s)).1
  have hqB : 1 - (1 - p) ^ (4 * s) ≤ B :=
    (bernoulli_union_parameter_le hp.le hp1.le (4 * s)).trans
      (sampling_budget_le hσ.le (m (k - 1)))
  have hmono := bernoulliProbability_mono_parameter hq0 hqB hB1.le T.CoveredBy
    (fun _ _ hUV hU => ProbabilityTree.coveredBy_mono hU hUV)
  rw [min_eq_right hB1.le]
  exact hc.trans hmono

theorem tree_covering {X : Type} [Fintype X] [DecidableEq X] {k : ℕ}
    (T : ProbabilityTree X k) (hk : 0 < k) (hdis : T.IsDisjoint)
    (m : ℕ → ℕ) (hcap : T.HasCapacities m) (hpos : ∀ i, i < k → 0 < m i)
    (hgrowth : ∀ i, i + 1 < k → 16 * m i ≤ m (i + 1))
    (σ : ℝ) (hσ : 0 < σ) (hspread : T.HasSpread (fun _ => σ)) :
    (2 / 3 : ℝ) ≤ bernoulliProbability
      (min 1 (16 * Real.exp 50 * σ * (1 + Real.logb 2 (m (k - 1) : ℝ)))) T.CoveredBy := by
  apply tree_covering_of_progress T hk hdis m hcap hpos hgrowth σ hσ hspread
  intro hp1 state hrank
  have hp : 0 < Real.exp 50 * (4 * σ) := by positivity
  have hgood := reduction_good_probability_ge hp hp1 state.capacity
    (fun i => capacityReserve σ (state.capacity i)) state.tree
    state.disjoint state.capacities state.spread state.positive
    (fun i _ => (capacityReserve_pos hσ (state.capacity i)).le)
    (fun i _ => capacityReserve_div_sampling_le hσ (state.capacity i)) state.growth
  have hmono := (bernoulliLaw (X := X) (Real.exp 50 * (4 * σ)) hp.le hp1.le).prob_mono
    (P := fun W => Good (Real.exp 50 * (4 * σ)) state.capacity W state.tree)
    (Q := fun W => ∃ next, state.Advances W next)
    (fun W hW => state.exists_advance_of_good W hσ hp hrank hW)
  exact hgood.trans hmono

end LeanBlast.SecondKahnKalai

end

end OAI