math / data /lean /OAI /Probability /CubeShuffle /QueryTree.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
27 kB
import OAI.Probability.CubeShuffle.Basic
import OAI.Probability.CubeShuffle.ButterflyRoutes
namespace OAI
namespace CubeShuffle
open scoped BigOperators
open Filter
/-- A finite adaptive experiment. A `force` instruction aborts on the wrong bit;
it carries likelihood-ratio weight 2 on success. Ordinary queries have no cost.
Freshness is a theorem hypothesis BELOW ON THE ACTUAL QUERY TREE, not an
independence assumption about a subsequently selected event. -/
inductive QueryTree (ι : Type*)
| reject : QueryTree ι
| accept : QueryTree ι
| branch (i : ι) (zero one : QueryTree ι) : QueryTree ι
| force (i : ι) (b : Bool) (next : QueryTree ι) : QueryTree ι
namespace QueryTree
variable {ι : Type*} [DecidableEq ι]
def queries : QueryTree ι → Finset ι
| reject => ∅
| accept => ∅
| branch i zero one => insert i (queries zero ∪ queries one)
| force i _ next => insert i (queries next)
/-- No coin is requested twice along any branch of the experiment. -/
def Fresh : QueryTree ι → Prop
| reject => True
| accept => True
| branch i zero one => i ∉ queries zero ∧ i ∉ queries one ∧ Fresh zero ∧ Fresh one
| force i _ next => i ∉ queries next ∧ Fresh next
def weighted : QueryTree ι → (ι → Bool) → ℝ
| reject, _ => 0
| accept, _ => 1
| branch i zero one, ω => if ω i then weighted one ω else weighted zero ω
| force i b next, ω => if ω i = b then 2 * weighted next ω else 0
omit [DecidableEq ι] in
lemma weighted_nonneg (T : QueryTree ι) (ω : ι → Bool) : 0 ≤ T.weighted ω := by
induction T with
| reject => exact le_rfl
| accept => exact zero_le_one
| branch i zero one ih₀ ih₁ => simpa only [weighted] using ite_nonneg ih₁ ih₀
| force i b next ih => simpa only [weighted] using ite_nonneg (mul_nonneg (by norm_num) ih) le_rfl
lemma weighted_congr (T : QueryTree ι) {ω η : ι → Bool}
(h : ∀ i ∈ T.queries, ω i = η i) : T.weighted ω = T.weighted η := by
induction T with
| reject => rfl
| accept => rfl
| branch i zero one ih₀ ih₁ =>
have hi := h i (Finset.mem_insert_self _ _)
simp only [weighted, hi]
rw [ih₀ (fun j hj => h j (Finset.mem_insert_of_mem (Finset.mem_union_left _ hj))),
ih₁ (fun j hj => h j (Finset.mem_insert_of_mem (Finset.mem_union_right _ hj)))]
| force i b next ih =>
have hi := h i (Finset.mem_insert_self _ _)
simp only [weighted, hi]
rw [ih (fun j hj => h j (Finset.mem_insert_of_mem hj))]
lemma weighted_flip_of_not_mem (T : QueryTree ι) (i : ι) (hi : i ∉ T.queries)
(ω : ι → Bool) : T.weighted (flipCoin i ω) = T.weighted ω := by
apply weighted_congr
intro j hj
exact flipCoin_apply_ne i j (fun h => hi (h ▸ hj)) ω
/-- Sequential forcing identity/inequality. Its weight is determined by the
realized trace; there is no conditioning on a favorable choice of certificate. -/
lemma mean_weighted_le_one [Fintype ι] (T : QueryTree ι) (hT : T.Fresh) :
finiteMean T.weighted ≤ 1 := by
induction T with
| reject => simp [weighted, finiteMean]
| accept => simp [weighted, finiteMean]
| branch i zero one ih₀ ih₁ =>
obtain ⟨hz, ho, hfz, hfo⟩ := hT
have h₀ := mean_indicator_bit zero.weighted i false (zero.weighted_flip_of_not_mem i hz)
have h₁ := mean_indicator_bit one.weighted i true (one.weighted_flip_of_not_mem i ho)
have he : finiteMean (branch i zero one).weighted =
finiteMean (fun ω => if ω i = false then zero.weighted ω else 0) +
finiteMean (fun ω => if ω i = true then one.weighted ω else 0) := by
unfold finiteMean
rw [← add_div, ← Finset.sum_add_distrib]
congr 1
apply Finset.sum_congr rfl
intro ω _
cases hω : ω i <;> simp [weighted, hω]
rw [he, h₀, h₁]
linarith [ih₀ hfz, ih₁ hfo]
| force i b next ih =>
obtain ⟨hi, hn⟩ := hT
have hm := mean_indicator_bit next.weighted i b (next.weighted_flip_of_not_mem i hi)
have he : finiteMean (force i b next).weighted =
2 * finiteMean (fun ω => if ω i = b then next.weighted ω else 0) := by
unfold finiteMean
rw [← mul_div_assoc, Finset.mul_sum]
congr 1
apply Finset.sum_congr rfl
intro ω _
by_cases h : ω i = b <;> simp [weighted, h]
rw [he, hm]
linarith [ih hn]
def succeeds : QueryTree ι → (ι → Bool) → Bool
| reject, _ => false
| accept, _ => true
| branch i zero one, ω => if ω i then succeeds one ω else succeeds zero ω
| force i b next, ω => if ω i = b then succeeds next ω else false
/-- Number of successful forced fresh-bit queries along the realized trace. -/
def charge : QueryTree ι → (ι → Bool) → ℕ
| reject, _ => 0
| accept, _ => 0
| branch i zero one, ω => if ω i then charge one ω else charge zero ω
| force i b next, ω => if ω i = b then charge next ω + 1 else 0
omit [DecidableEq ι] in
lemma weighted_eq (T : QueryTree ι) (ω : ι → Bool) :
T.weighted ω = if T.succeeds ω then (2 : ℝ) ^ T.charge ω else 0 := by
induction T with
| reject => rfl
| accept => norm_num [weighted, succeeds, charge]
| branch i zero one ih₀ ih₁ =>
cases h : ω i <;> simp [weighted, succeeds, charge, h, ih₀, ih₁]
| force i b next ih =>
by_cases h : ω i = b
· simp only [weighted, succeeds, charge, h, ↓reduceIte, ih]
cases hs : next.succeeds ω <;> simp [pow_succ, mul_comm]
· simp [weighted, succeeds, h]
/-- Acceptance probability is at most `2^(-K)` whenever every accepted trace
contains at least `K` forced fresh bits; unsuccessful shorter traces need not
make `K` queries. This is precisely the stopping-threshold issue in the fixed
certificate proof (`10-network.tex:84`). -/
lemma success_probability_le [Fintype ι] (T : QueryTree ι) (hT : T.Fresh)
(K : ℕ) (hK : ∀ ω, T.succeeds ω = true → K ≤ T.charge ω) :
finiteMean (fun ω => if T.succeeds ω then (1 : ℝ) else 0) ≤ 1 / (2 : ℝ) ^ K := by
have hw (ω : ι → Bool) :
(2 : ℝ) ^ K * (if T.succeeds ω then (1 : ℝ) else 0) ≤ T.weighted ω := by
rw [weighted_eq]
cases hs : T.succeeds ω
· simp
· simpa using pow_le_pow_right₀ (show (1 : ℝ) ≤ 2 by norm_num) (hK ω hs)
have hn : 0 ≤ (Fintype.card (ι → Bool) : ℝ) := Nat.cast_nonneg _
have hm := div_le_div_of_nonneg_right
(Finset.sum_le_sum (fun ω (_ : ω ∈ Finset.univ) => hw ω)) hn
rw [← Finset.mul_sum, mul_div_assoc] at hm
change (2 : ℝ) ^ K * finiteMean (fun ω => if T.succeeds ω then 1 else 0) ≤
finiteMean T.weighted at hm
exact (le_div_iff₀ (pow_pos (by norm_num) K)).mpr (by
rw [mul_comm]
exact hm.trans (mean_weighted_le_one T hT))
end QueryTree
namespace QueryTree
variable {ι : Type*} [DecidableEq ι]
/-- Eliminate repeated queries against an explicit exposure record. Repeated
forced bits test compatibility but acquire no likelihood-ratio factor. -/
def memo : QueryTree ι → Finset ι → (ι → Bool) → QueryTree ι
| reject, _, _ => reject
| accept, _, _ => accept
| branch i zero one, R, η =>
if i ∈ R then (if η i then memo one R η else memo zero R η) else
branch i (memo zero (insert i R) (Function.update η i false))
(memo one (insert i R) (Function.update η i true))
| force i b next, R, η =>
if i ∈ R then (if η i = b then memo next R η else reject) else
force i b (memo next (insert i R) (Function.update η i b))
lemma memo_queries_disjoint (T : QueryTree ι) (R : Finset ι) (η : ι → Bool) :
Disjoint (memo T R η).queries R := by
induction T generalizing R η with
| reject => simp [memo,queries]
| accept => simp [memo,queries]
| branch i zero one ih₀ ih₁ =>
by_cases hi : i ∈ R
· simp only [memo,hi,↓reduceIte]
cases η i <;> simp only [Bool.false_eq_true,↓reduceIte]
· exact ih₀ R η
· exact ih₁ R η
· simp only [memo,hi,↓reduceIte,queries,Finset.disjoint_insert_left,Finset.disjoint_union_left]
exact ⟨by simp, (ih₀ (insert i R) _).mono_right (Finset.subset_insert _ _),
(ih₁ (insert i R) _).mono_right (Finset.subset_insert _ _)⟩
| force i b next ih =>
by_cases hi : i ∈ R
· simp only [memo,hi,↓reduceIte]
by_cases hb : η i = b
· simpa only [hb,↓reduceIte] using ih R η
· simp [hb,queries]
· simp only [memo,hi,↓reduceIte,queries,Finset.disjoint_insert_left]
exact ⟨by simp,(ih (insert i R) _).mono_right (Finset.subset_insert _ _)⟩
lemma memo_fresh (T : QueryTree ι) (R : Finset ι) (η : ι → Bool) :
(memo T R η).Fresh := by
induction T generalizing R η with
| reject => trivial
| accept => trivial
| branch i zero one ih₀ ih₁ =>
by_cases hi : i ∈ R
· simp only [memo,hi,↓reduceIte]
cases η i <;> simp only [Bool.false_eq_true,↓reduceIte]
· exact ih₀ R η
· exact ih₁ R η
· simp only [memo,hi,↓reduceIte,Fresh]
exact ⟨fun hm => Finset.disjoint_left.mp (memo_queries_disjoint zero (insert i R) _) hm
(Finset.mem_insert_self _ _),
fun hm => Finset.disjoint_left.mp (memo_queries_disjoint one (insert i R) _) hm
(Finset.mem_insert_self _ _), ih₀ _ _,ih₁ _ _⟩
| force i b next ih =>
by_cases hi : i ∈ R
· simp only [memo,hi,↓reduceIte]
by_cases hb : η i = b
· simpa only [hb,↓reduceIte] using ih R η
· simp [hb,Fresh]
· simp only [memo,hi,↓reduceIte,Fresh]
exact ⟨fun hm => Finset.disjoint_left.mp (memo_queries_disjoint next (insert i R) _) hm
(Finset.mem_insert_self _ _),ih _ _⟩
lemma update_agrees {R : Finset ι} {η ω : ι → Bool}
(h : ∀ i ∈ R, η i = ω i) (i : ι) :
∀ j ∈ insert i R, Function.update η i (ω i) j = ω j := by
intro j hj
rcases Finset.mem_insert.mp hj with rfl | hj
· simp
· by_cases hji : j = i
· subst j; simp
· rw [Function.update_of_ne hji]
exact h j hj
lemma memo_succeeds (T : QueryTree ι) (R : Finset ι) (η ω : ι → Bool)
(h : ∀ i ∈ R, η i = ω i) : (memo T R η).succeeds ω = T.succeeds ω := by
induction T generalizing R η with
| reject => rfl
| accept => rfl
| branch i zero one ih₀ ih₁ =>
by_cases hi : i ∈ R
· simp only [memo,hi,↓reduceIte,succeeds,h i hi]
cases ω i <;> simp only [Bool.false_eq_true,↓reduceIte]
· exact ih₀ R η h
· exact ih₁ R η h
· simp only [memo,hi,↓reduceIte,succeeds]
cases hb : ω i <;> simp only [Bool.false_eq_true,↓reduceIte]
· exact ih₀ _ _ (by simpa only [hb] using update_agrees h i)
· exact ih₁ _ _ (by simpa only [hb] using update_agrees h i)
| force i b next ih =>
by_cases hi : i ∈ R
· simp only [memo,hi,↓reduceIte,h i hi]
by_cases hb : ω i = b
· simp only [hb,↓reduceIte,succeeds]
exact ih R η h
· simp [hb,succeeds]
· simp only [memo,hi,↓reduceIte,succeeds]
by_cases hb : ω i = b
· simp only [hb,↓reduceIte]
exact ih _ _ (by simpa only [hb] using update_agrees h i)
· simp [hb]
/-- Forced bits counted only when fresh; ordinary path queries insert their
bits into the same record, so subsequent closures cannot charge them twice. -/
def freshCharge : QueryTree ι → Finset ι → (ι → Bool) → ℕ
| reject, _, _ => 0
| accept, _, _ => 0
| branch i zero one, R, ω => if ω i then freshCharge one (insert i R) ω else freshCharge zero (insert i R) ω
| force i b next, R, ω => if ω i = b then
freshCharge next (insert i R) ω + (if i ∈ R then 0 else 1) else 0
lemma memo_charge (T : QueryTree ι) (R : Finset ι) (η ω : ι → Bool)
(h : ∀ i ∈ R, η i = ω i) : (memo T R η).charge ω = freshCharge T R ω := by
induction T generalizing R η with
| reject => rfl
| accept => rfl
| branch i zero one ih₀ ih₁ =>
by_cases hi : i ∈ R
· simp only [memo,hi,↓reduceIte,freshCharge,h i hi,Finset.insert_eq_of_mem hi]
cases ω i <;> simp only [Bool.false_eq_true,↓reduceIte]
· exact ih₀ R η h
· exact ih₁ R η h
· simp only [memo,hi,↓reduceIte,charge,freshCharge]
cases hb : ω i <;> simp only [Bool.false_eq_true,↓reduceIte]
· exact ih₀ _ _ (by simpa only [hb] using update_agrees h i)
· exact ih₁ _ _ (by simpa only [hb] using update_agrees h i)
| force i b next ih =>
by_cases hi : i ∈ R
· simp only [memo,hi,↓reduceIte,h i hi,freshCharge,Finset.insert_eq_of_mem hi,Nat.add_zero]
by_cases hb : ω i = b
· simp only [hb,↓reduceIte]
exact ih R η h
· simp [hb,charge]
· simp only [memo,hi,↓reduceIte,charge,freshCharge]
by_cases hb : ω i = b
· simp only [hb,↓reduceIte]
rw [ih _ _ (by simpa only [hb] using update_agrees h i)]
· simp [hb]
/-- Adaptive weighted closing constraints remain valid with arbitrary repeated
ordinary/closing queries, after accounting exactly for exposed coins. -/
lemma mean_freshCharge_le_one [Fintype ι] (T : QueryTree ι) :
finiteMean (fun ω : ι → Bool =>
if T.succeeds ω then (2:ℝ) ^ T.freshCharge ∅ ω else 0) ≤ 1 := by
let η : ι → Bool := fun _ => false
have hm := mean_weighted_le_one (memo T ∅ η) (memo_fresh T ∅ η)
have he : finiteMean (memo T ∅ η).weighted =
finiteMean (fun ω : ι → Bool =>
if T.succeeds ω then (2:ℝ) ^ T.freshCharge ∅ ω else 0) := by
apply finiteMean_congr
intro ω
rw [weighted_eq, memo_succeeds _ _ _ _ (by simp), memo_charge _ _ _ _ (by simp)]
rw [he] at hm
exact hm
end QueryTree
namespace QueryTree
variable {ι : Type*} [DecidableEq ι]
/-- Query just the switches on one actual butterfly route, then pass its
endpoint to a continuation. The index map permits parallel sub-butterflies. -/
def followPath : (d : ℕ) → (SwitchIndex d → ι) → Card d →
(Card d → QueryTree ι) → QueryTree ι
| 0, _, x, k => k x
| d + 1, e, x, k => followPath d (fun i => e (Sum.inr (x 0,i))) (Fin.tail x)
(fun y => branch (e (Sum.inl y))
(k (Fin.cons (Bool.xor (x 0) false) y))
(k (Fin.cons (Bool.xor (x 0) true) y)))
omit [DecidableEq ι] in
lemma followPath_succeeds (d : ℕ) (e : SwitchIndex d → ι) (x : Card d)
(k : Card d → QueryTree ι) (ω : ι → Bool) :
(followPath d e x k).succeeds ω =
(k (butterflyPerm d (decodeButterfly d (ω ∘ e)) x)).succeeds ω := by
induction d with
| zero => rfl
| succ d ih =>
rw [followPath, ih]
let y := butterflyPerm d
(decodeButterfly d (fun i => ω (e (Sum.inr (x 0,i))))) (Fin.tail x)
change (if ω (e (Sum.inl y)) then
(k (Fin.cons (Bool.xor (x 0) true) y)).succeeds ω else
(k (Fin.cons (Bool.xor (x 0) false) y)).succeeds ω) =
(k (Fin.cons (Bool.xor (x 0) (ω (e (Sum.inl y)))) y)).succeeds ω
cases ω (e (Sum.inl y)) <;> rfl
lemma followPath_charge (d : ℕ) (e : SwitchIndex d → ι) (x : Card d)
(k : Card d → QueryTree ι) (R : Finset ι) (ω : ι → Bool) :
freshCharge (followPath d e x k) R ω =
freshCharge (k (butterflyPerm d (decodeButterfly d (ω ∘ e)) x))
(R ∪ (routeDomain d x (butterflyPerm d (decodeButterfly d (ω ∘ e)) x)).image e) ω := by
classical
induction d generalizing R with
| zero => simp only [followPath, routeDomain, Finset.image_empty, Finset.union_empty]; rfl
| succ d ih =>
rw [followPath, ih]
let y := butterflyPerm d
(decodeButterfly d (fun i => ω (e (Sum.inr (x 0,i))))) (Fin.tail x)
let S := (routeDomain d (Fin.tail x) y).image (fun i => e (Sum.inr (x 0,i)))
change (if ω (e (Sum.inl y)) then
freshCharge (k (Fin.cons (Bool.xor (x 0) true) y)) (insert (e (Sum.inl y)) (R ∪ S)) ω else
freshCharge (k (Fin.cons (Bool.xor (x 0) false) y)) (insert (e (Sum.inl y)) (R ∪ S)) ω) =
freshCharge (k (Fin.cons (Bool.xor (x 0) (ω (e (Sum.inl y)))) y))
(R ∪ (routeDomain (d+1) x
(Fin.cons (Bool.xor (x 0) (ω (e (Sum.inl y)))) y)).image e) ω
have hs : (routeDomain (d+1) x
(Fin.cons (Bool.xor (x 0) (ω (e (Sum.inl y)))) y)).image e =
insert (e (Sum.inl y)) S := by
let e' : Sum (Card d) (Bool × SwitchIndex d) → ι := e
change (insert (Sum.inl y)
((routeDomain d (Fin.tail x) y).image
(fun i => (Sum.inr (x 0,i) : Sum (Card d) (Bool × SwitchIndex d)))) :
Finset (Sum (Card d) (Bool × SwitchIndex d))).image e' = _
rw [Finset.image_insert, Finset.image_image]
rfl
rw [hs,Finset.union_insert]
cases ω (e (Sum.inl y)) <;> rfl
/-- Force a finite list of coin requirements; compatibility with previous
ordinary or forced queries is handled by `memo`. -/
def forceList : List ι → (ι → Bool) → QueryTree ι → QueryTree ι
| [], _, k => k
| i :: L, v, k => force i (v i) (forceList L v k)
omit [DecidableEq ι] in
lemma forceList_succeeds (L : List ι) (v : ι → Bool) (k : QueryTree ι) (ω : ι → Bool) :
(forceList L v k).succeeds ω =
if ∀ i ∈ L, ω i = v i then k.succeeds ω else false := by
induction L with
| nil => simp [forceList]
| cons i L ih =>
simp only [forceList,succeeds,ih,List.mem_cons,forall_eq_or_imp]
by_cases h : ω i = v i <;> simp [h]
lemma forceList_charge (L : List ι) (v : ι → Bool) (k : QueryTree ι)
(R : Finset ι) (ω : ι → Bool) (h : ∀ i ∈ L, ω i = v i) :
freshCharge (forceList L v k) R ω =
freshCharge k (R ∪ L.toFinset) ω + (L.toFinset \ R).card := by
induction L generalizing R with
| nil => simp [forceList]
| cons i L ih =>
rw [forceList,freshCharge,ite_eq_left (h i List.mem_cons_self),
ih (insert i R) (fun j hj => h j (List.mem_cons_of_mem _ hj))]
simp only [List.toFinset_cons]
have hs : insert i R ∪ L.toFinset = R ∪ insert i L.toFinset := by ext j; simp
rw [hs]
by_cases hi : i ∈ R
· rw [ite_eq_left hi]
have he : L.toFinset \ insert i R = insert i L.toFinset \ R := by
ext j
by_cases hji : j = i
· subst j; simp [hi]
· simp [hji]
rw [he,Nat.add_zero]
· rw [ite_eq_right hi]
have he : insert i L.toFinset \ R = insert i (L.toFinset \ insert i R) := by
ext j
by_cases hji : j = i
· subst j; simp [hi]
· simp [hji]
rw [he, Finset.card_insert_of_notMem (by simp)]
omega
end QueryTree
namespace QueryTree
variable {ι : Type*} [DecidableEq ι]
/-- The number of forced queries already determined by earlier exposures. -/
def staleCharge : QueryTree ι → Finset ι → (ι → Bool) → ℕ
| reject, _, _ => 0
| accept, _, _ => 0
| branch i zero one, R, ω => if ω i then staleCharge one (insert i R) ω
else staleCharge zero (insert i R) ω
| force i b next, R, ω => if ω i = b then
staleCharge next (insert i R) ω + (if i ∈ R then 1 else 0) else 0
lemma fresh_add_stale (T : QueryTree ι) (R : Finset ι) (ω : ι → Bool) :
T.freshCharge R ω + T.staleCharge R ω = T.charge ω := by
induction T generalizing R with
| reject => rfl
| accept => rfl
| branch i zero one ih₀ ih₁ =>
cases hb : ω i <;> simp [freshCharge,staleCharge,charge,hb,ih₀,ih₁]
| force i b next ih =>
by_cases hb : ω i = b
· simp only [freshCharge,staleCharge,charge,hb,↓reduceIte]
have he := ih (insert i R)
by_cases hi : i ∈ R <;> simp only [hi,↓reduceIte] <;> omega
· simp [freshCharge,staleCharge,charge,hb]
omit [DecidableEq ι] in
lemma followPath_raw_charge (d : ℕ) (e : SwitchIndex d → ι) (x : Card d)
(k : Card d → QueryTree ι) (ω : ι → Bool) :
(followPath d e x k).charge ω =
(k (butterflyPerm d (decodeButterfly d (ω ∘ e)) x)).charge ω := by
induction d with
| zero => rfl
| succ d ih =>
rw [followPath, ih]
let y := butterflyPerm d
(decodeButterfly d (fun i => ω (e (Sum.inr (x 0,i))))) (Fin.tail x)
change (if ω (e (Sum.inl y)) then
(k (Fin.cons (Bool.xor (x 0) true) y)).charge ω else
(k (Fin.cons (Bool.xor (x 0) false) y)).charge ω) =
(k (Fin.cons (Bool.xor (x 0) (ω (e (Sum.inl y)))) y)).charge ω
cases ω (e (Sum.inl y)) <;> rfl
omit [DecidableEq ι] in
lemma forceList_raw_charge (L : List ι) (v : ι → Bool) (k : QueryTree ι) (ω : ι → Bool)
(h : ∀ i ∈ L, ω i = v i) :
(forceList L v k).charge ω = k.charge ω + L.length := by
induction L with
| nil => simp [forceList]
| cons i L ih =>
rw [forceList,charge,ite_eq_left (h i List.mem_cons_self),
ih (fun j hj => h j (List.mem_cons_of_mem _ hj))]
simp only [List.length_cons,Nat.add_assoc]
/-- A closing path has a specified endpoint rather than an adaptively chosen
one. It issues exactly the route's coin requirements. -/
noncomputable def closePath (d : ℕ) (x y : Card d) (k : QueryTree (SwitchIndex d)) :
QueryTree (SwitchIndex d) :=
forceList (routeDomain d x y).toList (routeValue d x y) k
lemma closePath_succeeds (d : ℕ) (x y : Card d) (k : QueryTree (SwitchIndex d))
(ω : SwitchIndex d → Bool) :
(closePath d x y k).succeeds ω =
if butterflyPerm d (decodeButterfly d ω) x = y then k.succeeds ω else false := by
unfold closePath
rw [forceList_succeeds]
simp only [Finset.mem_toList, ← butterfly_endpoint_iff]
lemma closePath_raw_charge (d : ℕ) (x y : Card d) (k : QueryTree (SwitchIndex d))
(ω : SwitchIndex d → Bool) (h : butterflyPerm d (decodeButterfly d ω) x = y) :
(closePath d x y k).charge ω = k.charge ω + d := by
unfold closePath
rw [forceList_raw_charge _ _ _ _ (by simpa only [Finset.mem_toList] using
(butterfly_endpoint_iff d ω x y).mp h), Finset.length_toList, card_routeDomain]
lemma closePath_fresh_charge (d : ℕ) (x y : Card d) (k : QueryTree (SwitchIndex d))
(R : Finset (SwitchIndex d)) (ω : SwitchIndex d → Bool)
(h : butterflyPerm d (decodeButterfly d ω) x = y) :
(closePath d x y k).freshCharge R ω =
k.freshCharge (R ∪ routeDomain d x y) ω + (routeDomain d x y \ R).card := by
unfold closePath
rw [forceList_charge _ _ _ _ _ (by simpa only [Finset.mem_toList] using
(butterfly_endpoint_iff d ω x y).mp h), Finset.toList_toFinset]
lemma closePath_stale_charge (d : ℕ) (x y : Card d) (k : QueryTree (SwitchIndex d))
(R : Finset (SwitchIndex d)) (ω : SwitchIndex d → Bool)
(h : butterflyPerm d (decodeButterfly d ω) x = y) :
(closePath d x y k).staleCharge R ω =
k.staleCharge (R ∪ routeDomain d x y) ω + (routeDomain d x y ∩ R).card := by
have h₀ := fresh_add_stale (closePath d x y k) R ω
have h₁ := fresh_add_stale k (R ∪ routeDomain d x y) ω
rw [closePath_raw_charge _ _ _ _ _ h,closePath_fresh_charge _ _ _ _ _ _ h] at h₀
have h₂ : (routeDomain d x y \ R).card + (routeDomain d x y ∩ R).card = d := by
rw [Finset.card_sdiff_add_card_inter,card_routeDomain]
omega
/-- Inspect one proposed length-(r+1) cycle. Every queried input must be in S
and must not have appeared in an earlier slot or earlier in this cycle. -/
noncomputable def seekCycle (d : ℕ) (S : Finset (Card d)) (a : Card d) :
ℕ → Card d → Finset (Card d) → (Finset (Card d) → QueryTree (SwitchIndex d)) →
QueryTree (SwitchIndex d)
| 0, x, V, k => if x ∈ S ∧ x ∉ V then closePath d x a (k (insert x V)) else reject
| r + 1, x, V, k => if x ∈ S ∧ x ∉ V then followPath d id x
(fun y => seekCycle d S a r y (insert x V) k) else reject
lemma seekCycle_raw_charge (d : ℕ) (S : Finset (Card d)) (a : Card d) (r : ℕ)
(x : Card d) (V : Finset (Card d)) (k : Finset (Card d) → QueryTree (SwitchIndex d))
(ω : SwitchIndex d → Bool) (K : ℕ)
(hK : ∀ V, (k V).succeeds ω = true → (k V).charge ω = K)
(hs : (seekCycle d S a r x V k).succeeds ω = true) :
(seekCycle d S a r x V k).charge ω = K + d := by
induction r generalizing x V with
| zero =>
by_cases hv : x ∈ S ∧ x ∉ V
· rw [seekCycle,ite_eq_left hv,closePath_succeeds] at hs
split_ifs at hs with he
· rw [seekCycle,ite_eq_left hv,closePath_raw_charge _ _ _ _ _ he,hK _ hs]
· simp [seekCycle,hv,succeeds] at hs
| succ r ih =>
by_cases hv : x ∈ S ∧ x ∉ V
· rw [seekCycle,ite_eq_left hv,followPath_succeeds] at hs
rw [seekCycle,ite_eq_left hv,followPath_raw_charge]
exact ih _ _ hs
· simp [seekCycle,hv,succeeds] at hs
/-- Distinguishable cycle slots, with each requested length encoded as r+1.
Later factorial-moment counting divides by precisely these rotation counts. -/
noncomputable def seekCycles (d : ℕ) (S : Finset (Card d)) :
List (Card d × ℕ) → Finset (Card d) → QueryTree (SwitchIndex d)
| [], _ => accept
| (a,r) :: L, V => seekCycle d S a r a V (fun V => seekCycles d S L V)
lemma seekCycles_raw_charge (d : ℕ) (S : Finset (Card d)) (L : List (Card d × ℕ))
(V : Finset (Card d)) (ω : SwitchIndex d → Bool)
(hs : (seekCycles d S L V).succeeds ω = true) :
(seekCycles d S L V).charge ω = L.length * d := by
induction L generalizing V with
| nil => simp [seekCycles,charge]
| cons ar L ih =>
obtain ⟨a,r⟩ := ar
rw [seekCycles]
rw [seekCycle_raw_charge d S a r a V (fun V => seekCycles d S L V) ω (L.length*d)
(fun V hs => ih V hs) hs]
simp [Nat.add_mul]
/-- The actual fixed-start weighted exploration inequality in FAC.3. The
stale charge counts exposed closing-path switches exactly, not a postulated
conditional-independence bound. Failure includes repeats, short cycles and
visiting outside the marked subset, and can occur at ANY earlier query. -/
lemma cycles_weighted_success (d : ℕ) (S : Finset (Card d)) (L : List (Card d × ℕ)) :
finiteMean (fun ω : SwitchIndex d → Bool =>
if (seekCycles d S L ∅).succeeds ω then
((2:ℝ)^d)^L.length / (2:ℝ)^(seekCycles d S L ∅).staleCharge ∅ ω else 0) ≤ 1 := by
let T := seekCycles d S L ∅
have hh := mean_freshCharge_le_one T
have he : finiteMean (fun ω : SwitchIndex d → Bool =>
if T.succeeds ω then (2:ℝ)^T.freshCharge ∅ ω else 0) =
finiteMean (fun ω : SwitchIndex d → Bool =>
if T.succeeds ω then ((2:ℝ)^d)^L.length / (2:ℝ)^T.staleCharge ∅ ω else 0) := by
apply finiteMean_congr
intro ω
cases hs : T.succeeds ω
· simp
· simp only [↓reduceIte]
have hc := fresh_add_stale T ∅ ω
rw [seekCycles_raw_charge d S L ∅ ω hs] at hc
have hp : ((2:ℝ)^d)^L.length = (2:ℝ)^T.freshCharge ∅ ω * (2:ℝ)^T.staleCharge ∅ ω := by
rw [←pow_add,hc,←pow_mul,Nat.mul_comm]
rw [hp,mul_div_cancel_right₀ _ (pow_ne_zero _ (by norm_num))]
rw [← he]
exact hh
end QueryTree
end CubeShuffle
end OAI