lean/OAI/Combinatorics/LowSpaceSubsetSum/Word/WordProgram.lean

import OAI.Combinatorics.LowSpaceSubsetSum.Counting.ExactWordDraw

namespace OAI

/-! # Sequential fair-word programs for the bounded samplers

A draw reads one fresh word. Continuations are evaluated only after that
word is read. The finite expectation is the operational probability law;
there are no eligible-backup draws in this interface.
-/

namespace LowSpaceSubsetSum.WordProgram

open scoped BigOperators
attribute [local instance] Classical.propDecidable

inductive Program (w : ℕ) (α : Type) where
  | pure : α → Program w α
  | draw : (Fin (2^w) → Program w α) → Program w α

variable {w : ℕ} {α β : Type}

def bind : Program w α → (α → Program w β) → Program w β
  | .pure a, next => next a
  | .draw next, tail => .draw (fun x => bind (next x) tail)

def map (f : α → β) (p : Program w α) : Program w β := bind p (fun a => .pure (f a))

noncomputable def expectation : Program w α → (α → ℝ) → ℝ
  | .pure a, f => f a
  | .draw next, f => (∑ x, expectation (next x) f) / (2^w : ℕ)

noncomputable def probability (p : Program w α) (P : α → Prop) : ℝ :=
  expectation p (fun a => if P a then 1 else 0)

theorem expectation_bind (p : Program w α) (next : α → Program w β) (f : β → ℝ) :
    expectation (bind p next) f = expectation p (fun a => expectation (next a) f) := by
  induction p with
  | pure a => rfl
  | draw branch ih =>
    simp only [bind, expectation, ih]

theorem probability_map (f : α → β) (p : Program w α) (P : β → Prop) :
    probability (map f p) P = probability p (fun a => P (f a)) := by
  simp only [map, probability, expectation_bind, expectation]

theorem expectation_sum {ι : Type} [Fintype ι] (p : Program w α) (f : ι → α → ℝ) :
    expectation p (fun a => ∑ i, f i a) = ∑ i, expectation p (f i) := by
  induction p with
  | pure a => rfl
  | draw branch ih =>
    simp only [expectation, ih]
    rw [Finset.sum_comm, Finset.sum_div]

theorem expectation_mul (p : Program w α) (f : α → ℝ) (c : ℝ) :
    expectation p (fun a => f a*c) = expectation p f*c := by
  induction p with
  | pure a => rfl
  | draw branch ih =>
    simp only [expectation, ih, ← Finset.sum_mul]
    ring

theorem expectation_eq_sum [Fintype α] (p : Program w α) (f : α → ℝ) :
    expectation p f = ∑ a, probability p (fun x => x=a)*f a := by
  classical
  calc
    expectation p f = expectation p (fun x => ∑ a, (if x=a then 1 else 0)*f a) := by
      congr 1
      funext x
      simp
    _ = ∑ a, expectation p (fun x => (if x=a then 1 else 0)*f a) := expectation_sum p _
    _ = _ := by simp only [expectation_mul, probability]

theorem expectation_of_probability [Fintype α] (p : Program w α) (μ : FiniteLaw α)
    (h : ∀ P, probability p P = μ.probability P) (f : α → ℝ) :
    expectation p f = μ.expectation f := by
  rw [expectation_eq_sum]
  simp only [h, FiniteLaw.probability_eq, FiniteLaw.expectation]

theorem expectation_const (p : Program w α) (c : ℝ) : expectation p (fun _ => c) = c := by
  induction p with
  | pure a => rfl
  | draw branch ih =>
    simp only [expectation, ih, Finset.sum_const, Finset.card_univ, Fintype.card_fin,
      nsmul_eq_mul]
    have h : ((2^w : ℕ) : ℝ) ≠ 0 := by positivity
    exact mul_div_cancel_left₀ c h

theorem probability_true (p : Program w α) : probability p (fun _ => True) = 1 := by
  simp only [probability, ↓reduceIte]
  exact expectation_const p 1

theorem expectation_nonneg (p : Program w α) (f : α → ℝ) (hf : ∀ a, 0 ≤ f a) :
    0 ≤ expectation p f := by
  induction p with
  | pure a => exact hf a
  | draw branch ih =>
    exact div_nonneg (Finset.sum_nonneg (fun x _ => ih x)) (by positivity)

theorem expectation_mono (p : Program w α) (f g : α → ℝ) (h : ∀ a, f a ≤ g a) :
    expectation p f ≤ expectation p g := by
  induction p with
  | pure a => exact h a
  | draw branch ih =>
    exact div_le_div_of_nonneg_right (Finset.sum_le_sum (fun x _ => ih x)) (by positivity)

/-- A read-only random stream supplies the words in order. -/
def run (stream : ℕ → Fin (2^w)) : Program w α → ℕ → α × ℕ
  | .pure a, offset => (a, offset)
  | .draw next, offset => run stream (next (stream offset)) (offset+1)

/-- A structural draw bound, independent of the stream's values. -/
inductive Bounded : Program w α → ℕ → Prop where
  | pure (a : α) (N : ℕ) : Bounded (.pure a) N
  | draw (next : Fin (2^w) → Program w α) (N : ℕ)
      (bound : ∀ x, Bounded (next x) N) : Bounded (.draw next) (N+1)

theorem run_bound (p : Program w α) (N : ℕ) (h : Bounded p N)
    (stream : ℕ → Fin (2^w)) (offset : ℕ) :
    offset ≤ (run stream p offset).2 ∧ (run stream p offset).2 ≤ offset+N := by
  induction h generalizing offset with
  | pure a N => exact ⟨le_rfl, Nat.le_add_right _ _⟩
  | draw next N bound ih =>
    have ht := ih (stream offset) (offset+1)
    change offset ≤ (run stream (next (stream offset)) (offset+1)).2 ∧
      (run stream (next (stream offset)) (offset+1)).2 ≤ offset+(N+1)
    omega

theorem bound_add (p : Program w α) (M : ℕ) (hp : Bounded p M) (N : ℕ) :
    Bounded p (N+M) := by
  induction hp with
  | pure a M => exact Bounded.pure a (N+M)
  | draw branch M hb ih =>
    simpa only [Nat.add_assoc] using Bounded.draw branch (N+M) ih

theorem bind_bound (p : Program w α) (N : ℕ) (hp : Bounded p N)
    (next : α → Program w β) (M : ℕ) (hn : ∀ a, Bounded (next a) M) :
    Bounded (bind p next) (N+M) := by
  induction hp with
  | pure a N => exact bound_add (next a) M (hn a) N
  | draw branch N hb ih =>
    simpa only [bind, Nat.add_assoc, Nat.add_comm 1 M, Nat.add_left_comm] using
      Bounded.draw (fun x => bind (branch x) next) (N+M) ih

end LowSpaceSubsetSum.WordProgram

end OAI