math / data /lean /OAI /Algorithms /SubexponentialSAT /ConditionalExpectation.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
15.3 kB
import OAI.Algorithms.SubexponentialSAT.LeanCompat
namespace OAI.Algorithms
/-!
# Finite conditional expectation by executable sequential search
An alphabet is given as an explicit nonempty list. With a duplicate-free list,
the averages below are uniform averages on words over that alphabet. No choice
oracle is used: `chooseMin` and `assign` are recursive finite algorithms.
-/
namespace SubexponentialSAT.ConditionalExpectation
open scoped BigOperators
variable {α : Type*}
/-- The arithmetic mean of a score on an explicitly enumerated alphabet. -/
def mean (alphabet : List α) (score : α → ℚ) : ℚ :=
(alphabet.map score).sum / (alphabet.length : ℚ)
/-- Deterministic finite search; ties favor the first candidate. -/
def chooseMin (score : α → ℚ) (a : α) : List α → α
| [] => a
| b :: bs =>
let c := chooseMin score b bs
if score a ≤ score c then a else c
theorem chooseMin_mem (score : α → ℚ) (a : α) (tail : List α) :
chooseMin score a tail ∈ a :: tail := by
induction tail generalizing a with
| nil => simp [chooseMin]
| cons b bs ih =>
simp only [chooseMin]
split_ifs with h
· exact List.mem_cons_self
· exact List.mem_cons_of_mem a (ih b)
theorem chooseMin_le (score : α → ℚ) (a : α) (tail : List α) :
∀ x ∈ a :: tail, score (chooseMin score a tail) ≤ score x := by
induction tail generalizing a with
| nil => simp [chooseMin]
| cons b bs ih =>
intro x hx
simp only [chooseMin]
split_ifs with h
· rcases List.mem_cons.mp hx with rfl | hx
· exact le_rfl
· exact h.trans (ih b x hx)
· rcases List.mem_cons.mp hx with rfl | hx
· exact le_of_lt (lt_of_not_ge h)
· exact ih b x hx
theorem le_mean (alphabet : List α) (score : α → ℚ)
(hne : alphabet ≠ []) (r : ℚ) (h : ∀ x ∈ alphabet, r ≤ score x) :
r ≤ mean alphabet score := by
have hsum : (alphabet.length : ℚ) * r ≤ (alphabet.map score).sum := by
clear hne
revert h
induction alphabet with
| nil => intro h; simp
| cons a as ih =>
intro h
have ha : r ≤ score a := h a List.mem_cons_self
have ht : ∀ x ∈ as, r ≤ score x := fun x hx => h x (List.mem_cons_of_mem a hx)
have hi := ih ht
simp only [List.length_cons, Nat.cast_add, Nat.cast_one, List.map_cons,
List.sum_cons]
nlinarith
have hpos : (0 : ℚ) < alphabet.length := by
exact_mod_cast List.length_pos_iff.mpr hne
exact (le_div_iff₀ hpos).2 (by simpa [mul_comm] using hsum)
theorem chooseMin_le_mean (score : α → ℚ) (a : α) (tail : List α) :
score (chooseMin score a tail) ≤ mean (a :: tail) score :=
le_mean (a :: tail) score (List.cons_ne_nil _ _)
(score (chooseMin score a tail)) (chooseMin_le score a tail)
/-- The abstract finite-uniform interface. The proof applies the same finite
search to an enumeration; executable users can supply that enumeration directly
to `chooseMin`. -/
theorem exists_le_uniform_mean [Fintype α] [Nonempty α] (score : α → ℚ) :
∃ x, score x ≤ (∑ y, score y) / (Fintype.card α : ℚ) := by
classical
obtain ⟨a, tail, h⟩ := List.exists_cons_of_ne_nil
((Finset.univ_nonempty : (Finset.univ : Finset α).Nonempty).toList_ne_nil)
have hmean : mean (a :: tail) score =
(∑ y, score y) / (Fintype.card α : ℚ) := by
rw [← h]
simp [mean]
exact ⟨chooseMin score a tail, hmean ▸ chooseMin_le_mean score a tail⟩
theorem exists_le_of_uniform_mean_le [Fintype α] [Nonempty α]
(score : α → ℚ) (bound : ℚ)
(h : (∑ y, score y) / (Fintype.card α : ℚ) ≤ bound) :
∃ x, score x ≤ bound := by
obtain ⟨x, hx⟩ := exists_le_uniform_mean score
exact ⟨x, hx.trans h⟩
/-- Conditional uniform mean over all assignments of the remaining variables.
The list `fixed` records coordinates already fixed, in reverse order. -/
def conditionalMean (alphabet : List α) (objective : List α → ℚ) :
ℕ → List α → ℚ
| 0, fixed => objective fixed
| n + 1, fixed =>
mean alphabet (fun a => conditionalMean alphabet objective n (a :: fixed))
/-- Fix one coordinate at a time by minimizing its exact conditional mean. -/
def assign (a : α) (tail : List α) (objective : List α → ℚ) :
ℕ → List α → List α
| 0, fixed => fixed
| n + 1, fixed =>
let next := chooseMin
(fun x => conditionalMean (a :: tail) objective n (x :: fixed)) a tail
assign a tail objective n (next :: fixed)
/-- The same executable search accepts a separately implemented conditional
mean evaluator. Its computation cost is not hidden in the correctness theorem. -/
def assignWithEvaluator (a : α) (tail : List α)
(evaluate : ℕ → List α → ℚ) : ℕ → List α → List α
| 0, fixed => fixed
| n + 1, fixed =>
let next := chooseMin (fun x => evaluate n (x :: fixed)) a tail
assignWithEvaluator a tail evaluate n (next :: fixed)
/-- Terminal evaluation and the finite averaging identity independently
characterize the required conditional means. -/
theorem evaluator_eq_conditionalMean (alphabet : List α)
(objective : List α → ℚ) (evaluate : ℕ → List α → ℚ)
(hzero : ∀ fixed, evaluate 0 fixed = objective fixed)
(hstep : ∀ n fixed, evaluate (n + 1) fixed =
mean alphabet (fun x => evaluate n (x :: fixed)))
(n : ℕ) (fixed : List α) :
evaluate n fixed = conditionalMean alphabet objective n fixed := by
induction n generalizing fixed with
| zero => exact hzero fixed
| succ n ih =>
rw [hstep, conditionalMean]
congr 1
funext x
exact ih (x :: fixed)
/-- Correctness of the search with a supplied exact evaluator. An efficient
local-probability evaluator may replace exhaustive enumeration once its two
identities below and its separate runtime bounds have been established. -/
theorem assignWithEvaluator_le (a : α) (tail : List α)
(objective : List α → ℚ) (evaluate : ℕ → List α → ℚ)
(hzero : ∀ fixed, evaluate 0 fixed = objective fixed)
(hstep : ∀ n fixed, evaluate (n + 1) fixed =
mean (a :: tail) (fun x => evaluate n (x :: fixed)))
(n : ℕ) (fixed : List α) :
objective (assignWithEvaluator a tail evaluate n fixed) ≤ evaluate n fixed := by
induction n generalizing fixed with
| zero => simp [assignWithEvaluator, hzero]
| succ n ih =>
rw [assignWithEvaluator, hstep]
exact (ih _).trans (chooseMin_le_mean _ a tail)
theorem assignWithEvaluator_exhaustive (a : α) (tail : List α)
(objective : List α → ℚ) (n : ℕ) (fixed : List α) :
assignWithEvaluator a tail (conditionalMean (a :: tail) objective) n fixed =
assign a tail objective n fixed := by
induction n generalizing fixed with
| zero => rfl
| succ n ih => simp only [assignWithEvaluator, assign, ih]
/-- Every step preserves the conditional-expectation upper bound. -/
theorem assign_le_conditionalMean (a : α) (tail : List α)
(objective : List α → ℚ) (n : ℕ) (fixed : List α) :
objective (assign a tail objective n fixed) ≤
conditionalMean (a :: tail) objective n fixed := by
induction n generalizing fixed with
| zero => exact le_rfl
| succ n ih =>
simp only [assign, conditionalMean]
exact (ih _).trans (chooseMin_le_mean _ a tail)
theorem assign_length (a : α) (tail : List α) (objective : List α → ℚ)
(n : ℕ) (fixed : List α) :
(assign a tail objective n fixed).length = n + fixed.length := by
induction n generalizing fixed with
| zero => simp [assign]
| succ n ih => simp only [assign, ih, List.length_cons]; omega
/-- All newly selected coordinates belong to the supplied alphabet. -/
theorem assign_mem (a : α) (tail : List α) (objective : List α → ℚ)
(n : ℕ) (fixed : List α) (hprefix : ∀ x ∈ fixed, x ∈ a :: tail) :
∀ x ∈ assign a tail objective n fixed, x ∈ a :: tail := by
induction n generalizing fixed with
| zero => exact hprefix
| succ n ih =>
simp only [assign]
apply ih
intro x hx
rcases List.mem_cons.mp hx with rfl | hx
· exact chooseMin_mem _ a tail
· exact hprefix x hx
/-- Explicit exhaustive enumeration of completions. Prefixes are stored in
reverse coordinate order, consistently with `assign`. -/
def completions (alphabet : List α) : ℕ → List α → List (List α)
| 0, fixed => [fixed]
| n + 1, fixed => alphabet.flatMap (fun a => completions alphabet n (a :: fixed))
/-- The returned assignment extends precisely the coordinates already fixed. -/
theorem assign_mem_completions (a : α) (tail : List α)
(objective : List α → ℚ) (n : ℕ) (fixed : List α) :
assign a tail objective n fixed ∈ completions (a :: tail) n fixed := by
induction n generalizing fixed with
| zero => simp [assign, completions]
| succ n ih =>
simp only [assign, completions, List.mem_flatMap]
exact ⟨_, chooseMin_mem _ a tail, ih _⟩
private theorem length_flatMap_const {β : Type*} (xs : List β)
(f : β → List α) (m : ℕ) (h : ∀ x, (f x).length = m) :
(xs.flatMap f).length = xs.length * m := by
induction xs with
| nil => simp
| cons x xs ih => simp [List.flatMap_cons, h, ih, Nat.add_mul, Nat.add_comm]
theorem completions_length (alphabet : List α) (n : ℕ) (fixed : List α) :
(completions alphabet n fixed).length = alphabet.length ^ n := by
induction n generalizing fixed with
| zero => simp [completions]
| succ n ih =>
rw [completions, length_flatMap_const _ _ _ (fun x => ih (x :: fixed))]
simp [pow_succ, Nat.mul_comm]
private theorem sum_map_flatMap {β : Type*} (xs : List β)
(f : β → List α) (g : α → ℚ) :
((xs.flatMap f).map g).sum = (xs.map (fun x => ((f x).map g).sum)).sum := by
induction xs with
| nil => simp
| cons x xs ih => simp [List.flatMap_cons, ih]
private theorem sum_map_div {β : Type*} (xs : List β) (f : β → ℚ) (d : ℚ) :
(xs.map (fun x => f x / d)).sum = (xs.map f).sum / d := by
induction xs with
| nil => simp
| cons x xs ih => simp [ih, add_div]
/-- The recursive conditional mean is the ordinary finite average over all
complete assignments extending the fixed coordinates. -/
theorem conditionalMean_eq_mean_completions (alphabet : List α)
(objective : List α → ℚ) (n : ℕ) (fixed : List α) :
conditionalMean alphabet objective n fixed =
mean (completions alphabet n fixed) objective := by
induction n generalizing fixed with
| zero => simp [conditionalMean, completions, mean]
| succ n ih =>
simp only [conditionalMean]
simp_rw [ih]
simp only [mean, completions_length, Nat.cast_pow]
rw [sum_map_div]
rw [completions, sum_map_flatMap]
simp [pow_succ, div_div, mul_comm]
/-- An instrumented evaluator recording calls to the complete-assignment
objective. This deliberately exposes the cost of exhaustive evaluation. -/
def conditionalMeanCounted (alphabet : List α) (objective : List α → ℚ) :
ℕ → List α → ℚ × ℕ
| 0, fixed => (objective fixed, 1)
| n + 1, fixed =>
let children := alphabet.map
(fun a => conditionalMeanCounted alphabet objective n (a :: fixed))
((children.map Prod.fst).sum / (alphabet.length : ℚ),
(children.map Prod.snd).sum)
theorem conditionalMeanCounted_value (alphabet : List α)
(objective : List α → ℚ) (n : ℕ) (fixed : List α) :
(conditionalMeanCounted alphabet objective n fixed).1 =
conditionalMean alphabet objective n fixed := by
induction n generalizing fixed with
| zero => rfl
| succ n ih =>
simp [conditionalMeanCounted, conditionalMean, mean, List.map_map, ih,
Function.comp_def]
/-- Exactly `q^n` complete-assignment evaluations for `n` remaining variables
over an alphabet of size `q`. This is not a polynomial-time evaluator. -/
theorem conditionalMeanCounted_evaluations (alphabet : List α)
(objective : List α → ℚ) (n : ℕ) (fixed : List α) :
(conditionalMeanCounted alphabet objective n fixed).2 = alphabet.length ^ n := by
induction n generalizing fixed with
| zero => rfl
| succ n ih =>
simp [conditionalMeanCounted, List.map_map, ih, Function.comp_def,
pow_succ, Nat.mul_comm]
/-- Deterministic derandomization from any established bound on the initial
uniform average. This supplies both an explicit witness and its guarantee. -/
theorem assign_le_initial_mean (a : α) (tail : List α)
(objective : List α → ℚ) (n : ℕ) :
objective (assign a tail objective n []) ≤
mean (completions (a :: tail) n []) objective := by
rw [← conditionalMean_eq_mean_completions]
exact assign_le_conditionalMean a tail objective n []
theorem assign_le_of_initial_mean_le (a : α) (tail : List α)
(objective : List α → ℚ) (n : ℕ) (bound : ℚ)
(h : mean (completions (a :: tail) n []) objective ≤ bound) :
objective (assign a tail objective n []) ≤ bound :=
(assign_le_initial_mean a tail objective n).trans h
/-- Instrumented minimum search. Its second component counts exactly one for
each rational comparison; evaluating a score is a separate cost. -/
def chooseMinCounted (score : α → ℚ) (a : α) : List α → α × ℕ
| [] => (a, 0)
| b :: bs =>
let c := chooseMinCounted score b bs
(if score a ≤ score c.1 then a else c.1, c.2 + 1)
theorem chooseMinCounted_value (score : α → ℚ) (a : α) (tail : List α) :
(chooseMinCounted score a tail).1 = chooseMin score a tail := by
induction tail generalizing a with
| nil => rfl
| cons b bs ih => simp [chooseMinCounted, chooseMin, ih]
theorem chooseMinCounted_comparisons (score : α → ℚ) (a : α) (tail : List α) :
(chooseMinCounted score a tail).2 = tail.length := by
induction tail generalizing a with
| nil => rfl
| cons b bs ih => simp [chooseMinCounted, ih]
/-- Instrumented sequential assignment. This measures rational comparisons,
not the bit cost of computing the conditional means supplied to the search. -/
def assignCounted (a : α) (tail : List α) (objective : List α → ℚ) :
ℕ → List α → List α × ℕ
| 0, fixed => (fixed, 0)
| n + 1, fixed =>
let next := chooseMinCounted
(fun x => conditionalMean (a :: tail) objective n (x :: fixed)) a tail
let result := assignCounted a tail objective n (next.1 :: fixed)
(result.1, next.2 + result.2)
theorem assignCounted_value (a : α) (tail : List α) (objective : List α → ℚ)
(n : ℕ) (fixed : List α) :
(assignCounted a tail objective n fixed).1 = assign a tail objective n fixed := by
induction n generalizing fixed with
| zero => rfl
| succ n ih => simp [assignCounted, assign, ih, chooseMinCounted_value]
theorem assignCounted_comparisons (a : α) (tail : List α) (objective : List α → ℚ)
(n : ℕ) (fixed : List α) :
(assignCounted a tail objective n fixed).2 = n * tail.length := by
induction n generalizing fixed with
| zero => simp [assignCounted]
| succ n ih =>
simp [assignCounted, ih, chooseMinCounted_comparisons, Nat.add_mul, Nat.add_comm]
end SubexponentialSAT.ConditionalExpectation
end OAI.Algorithms