Download data/lean/OAI/Algorithms/SubexponentialSAT/ConditionalExpectation.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 15.3 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/ConditionalExpectation.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/ConditionalExpectation.lean
-
curl -L -o ConditionalExpectation.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/ConditionalExpectation.lean
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 | |