import OAI.Probability.MatroidProphet.Main

namespace OAI

/-!
# Full support of the actual source seed

All four masks and both coins remain in the source law, including coordinates
unused in the selected branch. Strictly positive atom masses justify finite
conditional reconstruction on every realizable observation fiber. No nonempty
label or positive-rank assumption is made.

Source: `sections/secretary.tex`, conditional reconstruction paragraph (lines
65–81), SHA256 `3554fe0f7296782edf63cc7f1305c377e7a7b9d8f8948b9510ea4ad02a702d63`.
These are supporting positivity obligations, not the secretary endpoint or a
replacement for the joint-law and prefix-only online-rule constructions.
-/

namespace MatroidProphet.SourceSeedSupport

open MeasureTheory Finset

lemma bitsWeight_pos {α : Type*} [DecidableEq α] (q : α → ℝ)
    (h0 : ∀ e, 0 < q e) (h1 : ∀ e, q e < 1) (V S : Finset α) :
    0 < bitsWeight q V S := by
  apply Finset.prod_pos
  intro e he
  split_ifs
  · exact h0 e
  · exact sub_pos.mpr (h1 e)

lemma bernoulliSeedLaw_singleton_pos {bits : ℕ} (q : Fin bits → ℝ)
    (h0 : ∀ e, 0 < q e) (h1 : ∀ e, q e < 1) (r : Seed bits) :
    0 < bernoulliSeedLaw q (fun e => (h0 e).le) (fun e => (h1 e).le) {r} := by
  rw [bernoulliSeedLaw, PMF.toMeasure_apply_singleton _ _ (measurableSet_singleton _)]
  change 0 < ENNReal.ofReal (bitsWeight q univ (seedSet r))
  exact ENNReal.ofReal_pos.mpr (bitsWeight_pos q h0 h1 _ _)

lemma maskCoinLaw_singleton_pos (n : ℕ) (p : ℝ) (h0 : 0 < p) (h1 : p < 1)
    (r : Seed n) : 0 < maskCoinLaw n p h0.le h1.le {r} :=
  bernoulliSeedLaw_singleton_pos (fun _ => p) (fun _ => h0) (fun _ => h1) r

lemma prod_singleton_pos {α β : Type*} [MeasurableSpace α] [MeasurableSpace β]
    [MeasurableSingletonClass α] [MeasurableSingletonClass β]
    (μ : Measure α) (ν : Measure β) [SFinite ν]
    (a : α) (b : β) (ha : 0 < μ {a}) (hb : 0 < ν {b}) :
    0 < μ.prod ν {(a,b)} := by
  rw [← Set.singleton_prod_singleton, Measure.prod_prod]
  exact ENNReal.mul_pos ha.ne' hb.ne'

lemma mainBlockLaw_singleton_pos (n : ℕ) (q : Fin 5 → ℝ)
    (h0 : ∀ j, 0 < q j) (h1 : ∀ j, q j < 1) (b : MainSeedBlocks n) :
    0 < mainBlockLaw n q (fun j => (h0 j).le) (fun j => (h1 j).le) {b} := by
  rcases b with ⟨H,D,C,T,b⟩
  unfold mainBlockLaw
  apply prod_singleton_pos
  · exact maskCoinLaw_singleton_pos n (q 0) (h0 0) (h1 0) H
  · apply prod_singleton_pos
    · exact maskCoinLaw_singleton_pos n (q 1) (h0 1) (h1 1) D
    · apply prod_singleton_pos
      · exact maskCoinLaw_singleton_pos n (q 2) (h0 2) (h1 2) C
      · apply prod_singleton_pos
        · exact maskCoinLaw_singleton_pos n (q 3) (h0 3) (h1 3) T
        · exact maskCoinLaw_singleton_pos 2 (q 4) (h0 4) (h1 4) b

/-- The block encoding retains every bit; it is onto even for an empty ground set. -/
lemma encodeMainSeed_surjective (n : ℕ) :
    Function.Surjective (@encodeMainSeed n) := by
  intro r
  let block (j : Fin 4) : Seed n := fun e =>
    r ⟨4 * e.val + j.val, by dsimp [mainSeedBits]; omega⟩
  let coins : Seed 2 := fun j =>
    r ⟨4 * n + j.val, by dsimp [mainSeedBits]; omega⟩
  refine ⟨(block 0, block 1, block 2, block 3, coins), ?_⟩
  funext i
  dsimp only [encodeMainSeed]
  split_ifs with hi h0 h1 h2
  all_goals
    dsimp only [block, coins]
    congr 1
    apply Fin.ext
    dsimp
    omega

lemma mainSeedLaw_singleton_pos (n : ℕ) (q : Fin 5 → ℝ)
    (h0 : ∀ j, 0 < q j) (h1 : ∀ j, q j < 1) (r : Seed (mainSeedBits n)) :
    0 < mainSeedLaw n q (fun j => (h0 j).le) (fun j => (h1 j).le) {r} := by
  obtain ⟨b, hb⟩ := encodeMainSeed_surjective n r
  rw [mainSeedLaw, Measure.map_apply (measurable_of_countable _) (measurableSet_singleton _)]
  apply lt_of_lt_of_le (mainBlockLaw_singleton_pos n q h0 h1 b)
  apply measure_mono
  intro x hx
  have hx' : x = b := Set.mem_singleton_iff.mp hx
  subst x
  exact hb

lemma sourceCoinProbability_pos (j : Fin 5) : 0 < sourceCoinProbability j := by
  unfold sourceCoinProbability
  split_ifs <;> norm_num [thinningRate]

lemma sourceCoinProbability_lt_one (j : Fin 5) : sourceCoinProbability j < 1 := by
  unfold sourceCoinProbability
  split_ifs <;> norm_num [thinningRate]

/-- Every complete source seed has positive mass, with no exceptional labels or ranks. -/
theorem sourceSeedLaw_singleton_pos (n : ℕ) (r : Seed (mainSeedBits n)) :
    0 < sourceSeedLaw n {r} :=
  mainSeedLaw_singleton_pos n sourceCoinProbability sourceCoinProbability_pos
    sourceCoinProbability_lt_one r

/-- A source observation fiber has positive probability exactly when it is realizable.
The observation may keep branch, mask, and any additional seed coordinates. -/
theorem sourceSeedLaw_fiber_pos_iff (n : ℕ) {β : Type*}
    (f : Seed (mainSeedBits n) → β) (b : β) :
    0 < sourceSeedLaw n {r | f r = b} ↔ ∃ r, f r = b := by
  constructor
  · intro h
    by_contra hn
    have he : {r | f r = b} = ∅ := by
      ext r
      simp only [Set.mem_ofPred_eq, Set.mem_empty_iff_false, iff_false]
      exact fun hr => hn ⟨r,hr⟩
    rw [he, measure_empty] at h
    exact (lt_irrefl 0) h
  · rintro ⟨r,hr⟩
    apply lt_of_lt_of_le (sourceSeedLaw_singleton_pos n r)
    apply measure_mono
    intro s hs
    have hs' : s = r := Set.mem_singleton_iff.mp hs
    subst s
    exact hr

/-- Real-valued finite conditional-kernel denominators are strictly positive. -/
theorem sourceSeedLaw_fiber_toReal_pos (n : ℕ) {β : Type*}
    (f : Seed (mainSeedBits n) → β) (r : Seed (mainSeedBits n)) :
    0 < (sourceSeedLaw n {s | f s = f r}).toReal := by
  apply ENNReal.toReal_pos
  · exact ((sourceSeedLaw_fiber_pos_iff n f (f r)).mpr ⟨r,rfl⟩).ne'
  · exact measure_ne_top _ _

/-- Every assignment of all four masks, parity, and branch is realized by a seed. -/
theorem exists_mainMasks_mainBranch {n : ℕ} (d : MainMasks n) (j : Bool) :
    ∃ r : Seed (mainSeedBits n), mainMasks r = d ∧ mainBranch r = j := by
  let coins : Seed 2 := fun k => if k = 0 then j else d.odd
  let b : MainSeedBlocks n :=
    (setSeed d.H, setSeed d.D, setSeed d.C, setSeed d.T, coins)
  refine ⟨encodeMainSeed b, ?_, ?_⟩
  · rw [mainMasks_encodeMainSeed]
    simp only [b, seedSet_setSeed, coins]
    simp
  · rw [encodeMainSeed_branch]
    simp [b, coins]

/-- The entire mask/coin assignment has positive mass, including either unused branch. -/
theorem sourceSeedLaw_masks_branch_pos {n : ℕ} (d : MainMasks n) (j : Bool) :
    0 < sourceSeedLaw n {r | mainMasks r = d ∧ mainBranch r = j} := by
  obtain ⟨r, hd, hj⟩ := exists_mainMasks_mainBranch d j
  apply lt_of_lt_of_le (sourceSeedLaw_singleton_pos n r)
  apply measure_mono
  intro s hs
  have hs' : s = r := Set.mem_singleton_iff.mp hs
  subst s
  exact ⟨hd,hj⟩

/-- Both source branches admit every sacrificed-mask fiber with positive mass. -/
theorem sourceSeedLaw_branch_mask_pos (n : ℕ) (j : Bool) (P : Finset (Fin n)) :
    0 < sourceSeedLaw n {r | mainBranch r = j ∧
      (if mainBranch r then (mainMasks r).H ∪ (mainMasks r).D ∪ (mainMasks r).C
        else (mainMasks r).H) = P} := by
  let d : MainMasks n := ⟨P, ∅, ∅, ∅, false⟩
  apply lt_of_lt_of_le (sourceSeedLaw_masks_branch_pos d j)
  apply measure_mono
  intro r hr
  exact ⟨hr.2, by simp [hr.1, d]⟩

/-- The positivity statement for the actual algorithmic sacrificed mask, rather
than a surrogate observation map. -/
theorem sourceSeedLaw_actual_branch_mask_pos {n : ℕ} (M : Matroid (Fin n))
    (hE : M.E = Set.univ) (j : Bool) (P : Finset (Fin n)) :
    0 < sourceSeedLaw n {r | mainBranch r = j ∧ (completeHiddenRule M hE).mask r = P} := by
  simpa only [completeHiddenRule, branchHiddenRule, MainAlgorithm.hidden,
    roundedMaximumHidden, Maximum.maximumHidden] using sourceSeedLaw_branch_mask_pos n j P

/-- The four masks, parity, and branch determine every original seed coordinate. -/
theorem mainMasks_mainBranch_injective (n : ℕ) :
    Function.Injective (fun r : Seed (mainSeedBits n) => (mainMasks r, mainBranch r)) := by
  intro r s hrs
  have hd : mainMasks r = mainMasks s := congrArg Prod.fst hrs
  have hb : mainBranch r = mainBranch s := congrArg Prod.snd hrs
  have hm (j : Fin 4) : seedMask r j = seedMask s j := by
    fin_cases j
    · exact congrArg MainMasks.H hd
    · exact congrArg MainMasks.D hd
    · exact congrArg MainMasks.C hd
    · exact congrArg MainMasks.T hd
  funext i
  by_cases hi : i.val < 4*n
  · let e : Fin n := ⟨i.val / 4, by omega⟩
    let j : Fin 4 := ⟨i.val % 4, Nat.mod_lt _ (by omega)⟩
    have he := congrArg (fun P : Finset (Fin n) => e ∈ P) (hm j)
    simp only [seedMask, Finset.mem_filter, Finset.mem_univ, true_and] at he
    apply Bool.eq_iff_iff.mpr
    have hx : (⟨4*e.val+j.val, by dsimp [mainSeedBits]; omega⟩ : Fin (mainSeedBits n)) = i := by
      apply Fin.ext
      dsimp [e,j]
      omega
    simpa only [hx] using (iff_of_eq he)
  · have hival := i.isLt
    dsimp [mainSeedBits] at hival
    by_cases hlast : i.val = 4*n
    · have hx : (⟨4*n, by dsimp [mainSeedBits]; omega⟩ : Fin (mainSeedBits n)) = i := by
        apply Fin.ext
        exact hlast.symm
      simpa only [mainBranch, hx] using hb
    · have hlast' : i.val = 4*n+1 := by omega
      have hx : (⟨4*n+1, by dsimp [mainSeedBits]; omega⟩ : Fin (mainSeedBits n)) = i := by
        apply Fin.ext
        exact hlast'.symm
      have ho := congrArg MainMasks.odd hd
      simpa only [mainMasks, hx] using ho

/-- Every statistic of the complete source seed can be written using all masks and coins. -/
theorem source_statistic_factors {n : ℕ} {β : Type*}
    (f : Seed (mainSeedBits n) → β) :
    ∃ g : MainMasks n → Bool → β, ∀ r, g (mainMasks r) (mainBranch r) = f r := by
  classical
  let chooseSeed (d : MainMasks n) (j : Bool) :=
    Classical.choose (exists_mainMasks_mainBranch d j)
  have choose_spec (d : MainMasks n) (j : Bool) :
      (mainMasks (chooseSeed d j), mainBranch (chooseSeed d j)) = (d,j) := by
    exact Prod.ext (Classical.choose_spec (exists_mainMasks_mainBranch d j)).1
      (Classical.choose_spec (exists_mainMasks_mainBranch d j)).2
  refine ⟨fun d j => f (chooseSeed d j), ?_⟩
  intro r
  exact congrArg f (mainMasks_mainBranch_injective n
    (choose_spec (mainMasks r) (mainBranch r)))

/-- Since there are no null source atoms, almost-sure seed properties are pointwise. -/
theorem sourceSeedLaw_ae_iff (n : ℕ) (P : Seed (mainSeedBits n) → Prop) :
    (∀ᵐ r ∂sourceSeedLaw n, P r) ↔ ∀ r, P r := by
  rw [ae_iff_of_countable]
  exact ⟨fun h r => h r (sourceSeedLaw_singleton_pos n r).ne', fun h r _ => h r⟩

end MatroidProphet.SourceSeedSupport

end OAI