math / data /lean /OAI /Probability /CubeShuffle /ParallelLayers.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
42 kB
import OAI.Probability.CubeShuffle.RoutingNetwork
namespace OAI
namespace CubeShuffle
open scoped BigOperators
open Filter
section ParallelButterfly
variable {α B : Type*} [Fintype α] [DecidableEq α] [Fintype B] [DecidableEq B] {d : ℕ}
def parallelPerm (ω : B × SwitchIndex d → Bool) : Equiv.Perm (B × Card d) where
toFun x := (x.1,butterflyPerm d (decodeButterfly d (fun i => ω (x.1,i))) x.2)
invFun y := (y.1,(butterflyPerm d (decodeButterfly d (fun i => ω (y.1,i)))).symm y.2)
left_inv x := by simp
right_inv y := by simp
def relabeledPerm (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(ω : B × SwitchIndex d → Bool) : Equiv.Perm α :=
(pre.trans (parallelPerm ω)).trans post
noncomputable def parallelPath (pre : α ≃ B × Card d)
(ω : B × SwitchIndex d → Bool) (x : α) : Finset (B × SwitchIndex d) :=
(routeDomain d (pre x).2
(butterflyPerm d (decodeButterfly d (fun i => ω ((pre x).1,i))) (pre x).2)).image
(fun i => ((pre x).1,i))
def parallelUsers (pre : α ≃ B × Card d) (ω : B × SwitchIndex d → Bool)
(i : B × SwitchIndex d) : α × α :=
let u := switchUsers d (decodeButterfly d (fun j => ω (i.1,j))) i.2
(pre.symm (i.1,u.1),pre.symm (i.1,u.2))
omit [Fintype α] [DecidableEq α] [Fintype B] [DecidableEq B] in
lemma parallelUsers_ne (pre : α ≃ B × Card d) (ω : B × SwitchIndex d → Bool)
(i : B × SwitchIndex d) : (parallelUsers pre ω i).1 ≠ (parallelUsers pre ω i).2 := by
intro h
exact switchUsers_ne d _ _ (congrArg Prod.snd (pre.symm.injective h))
omit [Fintype α] [DecidableEq α] [Fintype B] in
lemma mem_parallelPath (pre : α ≃ B × Card d) (ω : B × SwitchIndex d → Bool)
(x : α) (i : B × SwitchIndex d) :
i ∈ parallelPath pre ω x ↔ (parallelUsers pre ω i).1 = x ∨ (parallelUsers pre ω i).2 = x := by
classical
obtain ⟨b,j⟩ := i
simp only [parallelPath,Finset.mem_image,Prod.mk.injEq]
constructor
· rintro ⟨k,hk,hb,rfl⟩
subst b
rcases (mem_routeDomain_iff_user d _ _ _).mp hk with h | h
· left
apply pre.injective
change pre (pre.symm ((pre x).1,_)) = pre x
rw [Equiv.apply_symm_apply]
exact Prod.ext rfl h
· right
apply pre.injective
change pre (pre.symm ((pre x).1,_)) = pre x
rw [Equiv.apply_symm_apply]
exact Prod.ext rfl h
· intro h
have hh : (b,(switchUsers d (decodeButterfly d (fun j => ω (b,j))) j).1) = pre x ∨
(b,(switchUsers d (decodeButterfly d (fun j => ω (b,j))) j).2) = pre x := by
rcases h with h | h
· exact Or.inl (by simpa only [parallelUsers,Equiv.apply_symm_apply] using congrArg pre h)
· exact Or.inr (by simpa only [parallelUsers,Equiv.apply_symm_apply] using congrArg pre h)
have hb : b = (pre x).1 := hh.elim (congrArg Prod.fst) (congrArg Prod.fst)
subst b
refine ⟨j,?_,rfl,rfl⟩
apply (mem_routeDomain_iff_user d _ _ _).mpr
exact hh.elim (fun h => Or.inl (congrArg Prod.snd h)) (fun h => Or.inr (congrArg Prod.snd h))
omit [Fintype α] [DecidableEq α] [Fintype B] in
lemma card_parallelPath (pre : α ≃ B × Card d) (ω : B × SwitchIndex d → Bool) (x : α) :
(parallelPath pre ω x).card = d := by
classical
rw [parallelPath,Finset.card_image_of_injective _ (fun _ _ h => Prod.mk.inj h |>.2),card_routeDomain]
noncomputable def blockMarks (pre : α ≃ B × Card d) (S : Finset α) (b : B) : Finset (Card d) :=
Finset.univ.filter (fun x => pre.symm (b,x) ∈ S)
omit [Fintype α] [Fintype B] [DecidableEq B] in
@[simp] lemma mem_blockMarks (pre : α ≃ B × Card d) (S : Finset α) (b : B) (x : Card d) :
x ∈ blockMarks pre S b ↔ pre.symm (b,x) ∈ S := by
classical
simp [blockMarks]
omit [DecidableEq B] in
lemma sum_card_blockMarks (pre : α ≃ B × Card d) (S : Finset α) :
∑ b : B, (blockMarks pre S b).card = S.card := by
classical
calc
_ = ∑ b : B, ∑ x : Card d, if pre.symm (b,x) ∈ S then 1 else 0 := by
simp only [blockMarks,Finset.card_filter]
_ = ∑ u : B × Card d, if pre.symm u ∈ S then 1 else 0 := (Fintype.sum_prod_type (fun u : B × Card d => if pre.symm u ∈ S then (1:ℕ) else 0)).symm
_ = ∑ x : α, if x ∈ S then 1 else 0 := Equiv.sum_comp pre.symm (fun x : α => if x ∈ S then (1:ℕ) else 0)
_ = _ := by simp
omit [DecidableEq B] in
lemma card_blockMarks_le (pre : α ≃ B × Card d) (S : Finset α) (b : B) :
(blockMarks pre S b).card ≤ S.card := by
rw [←sum_card_blockMarks pre S]
exact Finset.single_le_sum (f := fun b : B => (blockMarks pre S b).card) (fun _ _ => Nat.zero_le _) (Finset.mem_univ b)
omit [DecidableEq B] in
lemma parallel_entropy (pre : α ≃ B × Card d) (ω : B × SwitchIndex d → Bool) (S : Finset α) :
(∑ i : B × SwitchIndex d,
if (parallelUsers pre ω i).1 ∈ S ∧ (parallelUsers pre ω i).2 ∈ S then (1:ℝ) else 0) ≤
(S.card : ℝ) * Real.log S.card / (2 * Real.log 2) := by
classical
rw [Fintype.sum_prod_type]
calc
_ ≤ ∑ b : B, (blockMarks pre S b).card * Real.log (blockMarks pre S b).card / (2*Real.log 2) := by
apply Finset.sum_le_sum
intro b _
simpa only [←mem_blockMarks,parallelUsers] using
marked_switch_entropy_bound d (decodeButterfly d (fun i => ω (b,i))) (blockMarks pre S b)
_ ≤ ∑ b : B, (blockMarks pre S b).card * Real.log S.card / (2*Real.log 2) := by
apply Finset.sum_le_sum
intro b _
by_cases hz : (blockMarks pre S b).card = 0
· simp [hz]
· apply div_le_div_of_nonneg_right _ (by positivity)
apply mul_le_mul_of_nonneg_left _ (by positivity)
exact Real.log_le_log (by exact_mod_cast Nat.pos_of_ne_zero hz)
(by exact_mod_cast card_blockMarks_le pre S b)
_ = _ := by rw [←Finset.sum_div,←Finset.sum_mul,←Nat.cast_sum,sum_card_blockMarks]
noncomputable def parallelFollow (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(x : α) (k : α → QueryTree (B × SwitchIndex d)) : QueryTree (B × SwitchIndex d) :=
QueryTree.followPath d (fun i => ((pre x).1,i)) (pre x).2 (fun y => k (post ((pre x).1,y)))
omit [Fintype α] [DecidableEq α] [Fintype B] [DecidableEq B] in
lemma parallelFollow_succeeds (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(x : α) (k : α → QueryTree (B × SwitchIndex d)) (ω : B × SwitchIndex d → Bool) :
(parallelFollow pre post x k).succeeds ω = (k (relabeledPerm pre post ω x)).succeeds ω := by
exact QueryTree.followPath_succeeds _ _ _ _ _
omit [Fintype α] [DecidableEq α] [Fintype B] [DecidableEq B] in
lemma parallelFollow_raw_charge (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(x : α) (k : α → QueryTree (B × SwitchIndex d)) (ω : B × SwitchIndex d → Bool) :
(parallelFollow pre post x k).charge ω = (k (relabeledPerm pre post ω x)).charge ω := by
exact QueryTree.followPath_raw_charge _ _ _ _ _
omit [Fintype α] [DecidableEq α] [Fintype B] in
lemma parallelFollow_stale_charge (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(x : α) (k : α → QueryTree (B × SwitchIndex d)) (R : Finset (B × SwitchIndex d))
(ω : B × SwitchIndex d → Bool) :
(parallelFollow pre post x k).staleCharge R ω =
(k (relabeledPerm pre post ω x)).staleCharge (R ∪ parallelPath pre ω x) ω := by
exact QueryTree.followPath_stale_charge _ _ _ _ _ _
noncomputable def closingDomain (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(x y : α) : Finset (B × SwitchIndex d) :=
(routeDomain d (pre x).2 (post.symm y).2).image (fun i => ((pre x).1,i))
def closingValue (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(x y : α) (i : B × SwitchIndex d) : Bool := routeValue d (pre x).2 (post.symm y).2 i.2
omit [Fintype α] [DecidableEq α] [Fintype B] [DecidableEq B] in
lemma relabeled_endpoint_pair (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(ω : B × SwitchIndex d → Bool) (x y : α) :
relabeledPerm pre post ω x = y ↔
(pre x).1 = (post.symm y).1 ∧
butterflyPerm d (decodeButterfly d (fun i => ω ((pre x).1,i))) (pre x).2 = (post.symm y).2 := by
change post ((pre x).1,_) = y ↔ _
rw [←post.eq_symm_apply,Prod.mk.injEq]
omit [Fintype α] [DecidableEq α] [Fintype B] in
lemma relabeled_endpoint_iff (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(ω : B × SwitchIndex d → Bool) (x y : α) :
relabeledPerm pre post ω x = y ↔
(pre x).1 = (post.symm y).1 ∧
∀ i ∈ closingDomain pre post x y, ω i = closingValue pre post x y i := by
classical
rw [relabeled_endpoint_pair,butterfly_endpoint_iff]
simp only [closingDomain,Finset.forall_mem_image,closingValue]
omit [Fintype α] [DecidableEq α] [Fintype B] in
lemma closingDomain_eq (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(ω : B × SwitchIndex d → Bool) (x y : α) (h : relabeledPerm pre post ω x = y) :
closingDomain pre post x y = parallelPath pre ω x := by
rw [closingDomain,parallelPath,(relabeled_endpoint_pair _ _ _ _ _).mp h |>.2]
noncomputable def parallelClose (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(x y : α) (k : QueryTree (B × SwitchIndex d)) : QueryTree (B × SwitchIndex d) :=
if (pre x).1 = (post.symm y).1 then
QueryTree.forceList (closingDomain pre post x y).toList (closingValue pre post x y) k
else QueryTree.reject
omit [Fintype α] in
lemma parallelClose_succeeds (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(x y : α) (k : QueryTree (B × SwitchIndex d)) (ω : B × SwitchIndex d → Bool) :
(parallelClose pre post x y k).succeeds ω =
if relabeledPerm pre post ω x = y then k.succeeds ω else false := by
classical
simp only [relabeled_endpoint_iff,parallelClose]
by_cases hb : (pre x).1 = (post.symm y).1
· rw [ite_eq_left hb,QueryTree.forceList_succeeds]
simp only [Finset.mem_toList,hb,true_and]
· simp [hb,QueryTree.succeeds]
omit [Fintype α] [DecidableEq α] [Fintype B] in
lemma parallelClose_raw_charge (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(x y : α) (k : QueryTree (B × SwitchIndex d)) (ω : B × SwitchIndex d → Bool)
(h : relabeledPerm pre post ω x = y) :
(parallelClose pre post x y k).charge ω = k.charge ω + d := by
have hh := (relabeled_endpoint_iff _ _ _ _ _).mp h
rw [parallelClose,ite_eq_left hh.1,QueryTree.forceList_raw_charge _ _ _ _
(by simpa only [Finset.mem_toList] using hh.2),Finset.length_toList,
closingDomain_eq _ _ _ _ _ h,card_parallelPath]
omit [Fintype α] [DecidableEq α] [Fintype B] in
lemma parallelClose_fresh_charge (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(x y : α) (k : QueryTree (B × SwitchIndex d)) (R : Finset (B × SwitchIndex d))
(ω : B × SwitchIndex d → Bool) (h : relabeledPerm pre post ω x = y) :
(parallelClose pre post x y k).freshCharge R ω =
k.freshCharge (R ∪ parallelPath pre ω x) ω + (parallelPath pre ω x \ R).card := by
have hh := (relabeled_endpoint_iff _ _ _ _ _).mp h
rw [parallelClose,ite_eq_left hh.1,QueryTree.forceList_charge _ _ _ _ _
(by simpa only [Finset.mem_toList] using hh.2),Finset.toList_toFinset,
closingDomain_eq _ _ _ _ _ h]
omit [Fintype α] [DecidableEq α] [Fintype B] in
lemma parallelClose_stale_charge (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(x y : α) (k : QueryTree (B × SwitchIndex d)) (R : Finset (B × SwitchIndex d))
(ω : B × SwitchIndex d → Bool) (h : relabeledPerm pre post ω x = y) :
(parallelClose pre post x y k).staleCharge R ω =
k.staleCharge (R ∪ parallelPath pre ω x) ω + (parallelPath pre ω x ∩ R).card := by
have h₀ := QueryTree.fresh_add_stale (parallelClose pre post x y k) R ω
have h₁ := QueryTree.fresh_add_stale k (R ∪ parallelPath pre ω x) ω
rw [parallelClose_raw_charge _ _ _ _ _ _ h,parallelClose_fresh_charge _ _ _ _ _ _ _ h] at h₀
have h₂ : (parallelPath pre ω x \ R).card + (parallelPath pre ω x ∩ R).card = d := by
rw [Finset.card_sdiff_add_card_inter,card_parallelPath]
omega
/-- Independent fair butterflies in parallel with completely arbitrary fixed
bijections at either end. All certificate fields are proved from the explicit
Boolean query algorithms and deterministic butterfly geometry. -/
noncomputable def parallelNetwork (pre : α ≃ B × Card d) (post : B × Card d ≃ α) :
RoutingNetwork α (B × SwitchIndex d) d where
perm := relabeledPerm pre post
path := parallelPath pre
users := parallelUsers pre
users_ne := parallelUsers_ne pre
mem_path := mem_parallelPath pre
card_path := card_parallelPath pre
entropy := parallel_entropy pre
follow := parallelFollow pre post
close := parallelClose pre post
follow_succeeds := parallelFollow_succeeds pre post
follow_raw_charge := parallelFollow_raw_charge pre post
follow_stale_charge := parallelFollow_stale_charge pre post
close_succeeds := parallelClose_succeeds pre post
close_raw_charge := parallelClose_raw_charge pre post
close_stale_charge := parallelClose_stale_charge pre post
/-- The source FAC.4 estimate for independent parallel butterflies, allowing
arbitrary fixed identifications on both sides. -/
lemma parallel_cycle_log_mgf (pre : α ≃ B × Card d) (post : B × Card d ≃ α)
(S : Finset α) (J : ℕ) (hJ : 0 < J) (q : ℝ) (hq : 1 ≤ q) :
Real.log (finiteMean (fun ω : B × SwitchIndex d → Bool =>
q^(Fintype.card (RoutingNetwork.SelectedCycle (relabeledPerm pre post ω) S)))) ≤
(S.card : ℝ)/J * Real.log q + 2*q*S.card*Real.sqrt J / Real.sqrt ((2:ℝ)^d) := by
exact (parallelNetwork pre post).butterfly_cycle_log_mgf S J hJ q hq
end ParallelButterfly
/-- Separate the first r coordinates from the remaining s coordinates. The
sum is written s+r so its recursion agrees literally with the network. -/
def cardSplit : (r s : ℕ) → Card (s+r) ≃ Card r × Card s
| 0, s =>
{ toFun := fun x => ((fun i => Fin.elim0 i), x)
invFun := fun x => x.2
left_inv := fun _ => rfl
right_inv := fun x => by
apply Prod.ext
· exact Subsingleton.elim _ _
· rfl }
| r+1, s =>
{ toFun := fun x => (Fin.cons (x 0) ((cardSplit r s (Fin.tail x)).1),
(cardSplit r s (Fin.tail x)).2)
invFun := fun x => Fin.cons (x.1 0) ((cardSplit r s).symm (Fin.tail x.1,x.2))
left_inv := by
intro x
simp only [Fin.cons_zero, Fin.tail_cons, Prod.mk.eta, Equiv.symm_apply_apply, Fin.cons_self_tail]
right_inv := by
intro x
simp only [Fin.cons_zero, Fin.tail_cons, Equiv.apply_symm_apply, Fin.cons_self_tail] }
/-- Assemble the previously exposed low layers and the still-fresh high layers
without identifying or resampling any switch coin. -/
def assembleBits : (r s : ℕ) → (Card r × SwitchIndex s → Bool) →
(Card s × SwitchIndex r → Bool) → SwitchIndex (s+r) → Bool
| 0, _, lo, _, i => lo ((fun j => Fin.elim0 j), i)
| r+1, s, _, hi, Sum.inl y => hi ((cardSplit r s y).2,Sum.inl (cardSplit r s y).1)
| r+1, s, lo, hi, Sum.inr (b,i) => assembleBits r s
(fun j => lo (Fin.cons b j.1,j.2)) (fun j => hi (j.1,Sum.inr (b,j.2))) i
lemma butterfly_split (r s : ℕ) (lo : Card r × SwitchIndex s → Bool)
(hi : Card s × SwitchIndex r → Bool) (x : Card (s+r)) :
cardSplit r s (butterflyPerm (s+r) (decodeButterfly (s+r) (assembleBits r s lo hi)) x) =
let y := cardSplit r s x
let z := butterflyPerm s (decodeButterfly s (fun i => lo (y.1,i))) y.2
(butterflyPerm r (decodeButterfly r (fun i => hi (z,i))) y.1,z) := by
induction r with
| zero =>
apply Prod.ext
· funext i
exact Fin.elim0 i
· rfl
| succ r ih =>
let lo' : Card r × SwitchIndex s → Bool := fun j => lo (Fin.cons (x 0) j.1,j.2)
let hi' : Card s × SwitchIndex r → Bool := fun j => hi (j.1,Sum.inr (x 0,j.2))
have hh := ih lo' hi' (Fin.tail x)
let u := butterflyPerm (s+r) (decodeButterfly (s+r) (assembleBits r s lo' hi')) (Fin.tail x)
let y := cardSplit r s (Fin.tail x)
let z := butterflyPerm s (decodeButterfly s (fun i => lo' (y.1,i))) y.2
let w := butterflyPerm r (decodeButterfly r (fun i => hi' (z,i))) y.1
change cardSplit r s u = (w,z) at hh
change ((Fin.cons (Bool.xor (x 0) (hi ((cardSplit r s u).2,Sum.inl (cardSplit r s u).1)))
((cardSplit r s u).1) : Card (r+1)), (cardSplit r s u).2) =
((Fin.cons (Bool.xor (x 0) (hi (z,Sum.inl w))) w : Card (r+1)),z)
rw [hh]
/-- Disjoint partition of all switch locations into the exposed low butterflies
and the remaining high butterflies. -/
def splitSwitch : (r s : ℕ) → SwitchIndex (s+r) ≃
(Card r × SwitchIndex s) ⊕ (Card s × SwitchIndex r)
| 0, _ =>
{ toFun := fun i => Sum.inl ((fun j => Fin.elim0 j),i)
invFun := fun i => match i with
| Sum.inl (_,j) => j
| Sum.inr (_,j) => nomatch j
left_inv := fun _ => rfl
right_inv := by
intro i
rcases i with ⟨x,j⟩ | ⟨x,j⟩
· exact congrArg Sum.inl (Prod.ext (Subsingleton.elim _ _) rfl)
· exact Empty.elim j }
| r+1, s =>
{ toFun := fun i => match i with
| Sum.inl y => Sum.inr ((cardSplit r s y).2,Sum.inl (cardSplit r s y).1)
| Sum.inr (b,j) => match splitSwitch r s j with
| Sum.inl (p,j) => Sum.inl (Fin.cons b p,j)
| Sum.inr (q,j) => Sum.inr (q,Sum.inr (b,j))
invFun := fun i => match i with
| Sum.inl (p,j) => Sum.inr (p 0,(splitSwitch r s).symm (Sum.inl (Fin.tail p,j)))
| Sum.inr (q,Sum.inl p) => Sum.inl ((cardSplit r s).symm (p,q))
| Sum.inr (q,Sum.inr (b,j)) => Sum.inr (b,(splitSwitch r s).symm (Sum.inr (q,j)))
left_inv := by
intro i
rcases i with y | ⟨b,j⟩
· dsimp only
rw [Prod.mk.eta, Equiv.symm_apply_apply]
· dsimp only
cases hz : splitSwitch r s j with
| inl z =>
rcases z with ⟨p,k⟩
simp only [Fin.cons_zero, Fin.tail_cons]
rw [←hz,Equiv.symm_apply_apply]
| inr z =>
rcases z with ⟨q,k⟩
dsimp only
rw [←hz,Equiv.symm_apply_apply]
right_inv := by
intro i
rcases i with ⟨p,j⟩ | ⟨q,j⟩
· simp only [Equiv.apply_symm_apply, Fin.cons_self_tail]
· rcases j with p | ⟨b,j⟩ <;> simp only [Equiv.apply_symm_apply] }
lemma assembleBits_eq (r s : ℕ) (lo : Card r × SwitchIndex s → Bool)
(hi : Card s × SwitchIndex r → Bool) (i : SwitchIndex (s+r)) :
assembleBits r s lo hi i = Sum.elim lo hi (splitSwitch r s i) := by
induction r with
| zero => rfl
| succ r ih =>
rcases i with y | ⟨b,j⟩
· rfl
· simp only [assembleBits,splitSwitch,Equiv.coe_fn_mk]
rw [ih]
cases splitSwitch r s j <;> rfl
/-- The actual uniform coin law splits as a product; this is an equivalence of
finite sample spaces, rather than an independence assumption. -/
def splitCoinEquiv (r s : ℕ) :
((Card r × SwitchIndex s → Bool) × (Card s × SwitchIndex r → Bool)) ≃
(SwitchIndex (s+r) → Bool) :=
(Equiv.sumArrowEquivProdArrow _ _ Bool).symm.trans
(Equiv.arrowCongr (splitSwitch r s).symm (Equiv.refl Bool))
lemma splitCoinEquiv_apply (r s : ℕ) (lo : Card r × SwitchIndex s → Bool)
(hi : Card s × SwitchIndex r → Bool) :
splitCoinEquiv r s (lo,hi) = assembleBits r s lo hi := by
funext i
exact (assembleBits_eq r s lo hi i).symm
lemma finiteMean_prod {Ω Ω' : Type*} [Fintype Ω] [Fintype Ω'] (f : Ω × Ω' → ℝ) :
finiteMean f = finiteMean (fun x => finiteMean (fun y => f (x,y))) := by
simp only [finiteMean, Fintype.sum_prod_type, Fintype.card_prod, Nat.cast_mul,
←Finset.sum_div, div_div, mul_comm]
lemma finiteMean_split (r s : ℕ) (f : (SwitchIndex (s+r) → Bool) → ℝ) :
finiteMean f = finiteMean (fun lo : Card r × SwitchIndex s → Bool =>
finiteMean (fun hi : Card s × SwitchIndex r → Bool => f (assembleBits r s lo hi))) := by
rw [finiteMean_equiv (splitCoinEquiv r s).symm]
simp only [Equiv.symm_symm]
rw [finiteMean_prod]
apply finiteMean_congr
intro lo
apply finiteMean_congr
intro hi
rw [splitCoinEquiv_apply]
section PartiallyExposed
variable {α : Type*} {r s : ℕ}
def freshPre (pre : α ≃ Card (s+r)) (lo : Card r × SwitchIndex s → Bool) :
α ≃ Card s × Card r :=
((pre.trans (cardSplit r s)).trans (parallelPerm lo)).trans (Equiv.prodComm _ _)
def freshPost (post : Card (s+r) ≃ α) : Card s × Card r ≃ α :=
((Equiv.prodComm _ _).trans (cardSplit r s).symm).trans post
lemma exposed_perm_eq (pre : α ≃ Card (s+r)) (post : Card (s+r) ≃ α)
(lo : Card r × SwitchIndex s → Bool) (hi : Card s × SwitchIndex r → Bool) :
(pre.trans (butterflyPerm (s+r) (decodeButterfly (s+r) (assembleBits r s lo hi)))).trans post =
relabeledPerm (freshPre pre lo) (freshPost post) hi := by
ext x
simpa only [relabeledPerm, freshPre, freshPost, parallelPerm, Equiv.trans_apply,
Equiv.coe_fn_mk, Equiv.prodComm_apply, Prod.swap, Equiv.symm_apply_apply] using
congrArg (fun y => post ((cardSplit r s).symm y)) (butterfly_split r s lo hi (pre x))
/-- Single-level FAC.4 after any fixed exposure of the first s outward layers.
The expectation is over the genuinely unexposed disjoint high-layer coins. -/
lemma partially_exposed_cycle_log_mgf [Fintype α] [DecidableEq α]
(pre : α ≃ Card (s+r)) (post : Card (s+r) ≃ α)
(lo : Card r × SwitchIndex s → Bool) (S : Finset α)
(J : ℕ) (hJ : 0 < J) (q : ℝ) (hq : 1 ≤ q) :
Real.log (finiteMean (fun hi : Card s × SwitchIndex r → Bool =>
q^(Fintype.card (RoutingNetwork.SelectedCycle
((pre.trans (butterflyPerm (s+r)
(decodeButterfly (s+r) (assembleBits r s lo hi)))).trans post) S)))) ≤
(S.card : ℝ)/J * Real.log q + 2*q*S.card*Real.sqrt J / Real.sqrt ((2:ℝ)^r) := by
simp only [exposed_perm_eq]
exact parallel_cycle_log_mgf (freshPre pre lo) (freshPost post) S J hJ q hq
end PartiallyExposed
lemma inclusionMoment_eq {α Ω : Type*} [DecidableEq α] [Fintype Ω]
(F : Ω → Finset α) (S : Finset α) :
inclusionMoment F S = finiteMean (fun ω => if S ⊆ F ω then (1:ℝ) else 0) := by
unfold inclusionMoment
apply finiteMean_congr
intro ω
split_ifs <;> rfl
lemma finiteMean_bool (f : Bool → ℝ) : finiteMean f = (f false+f true)/2 := by
simp only [finiteMean, Fintype.sum_bool, Fintype.card_bool, Nat.cast_ofNat]
ring
lemma finiteMean_const {Ω : Type*} [Fintype Ω] [Nonempty Ω] (c : ℝ) :
finiteMean (fun _ : Ω => c) = c := by
simp only [finiteMean,Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
exact mul_div_cancel_left₀ c (Nat.cast_ne_zero.mpr Fintype.card_ne_zero)
lemma finiteMean_pi_prod {ι : Type*} [Fintype ι] [DecidableEq ι] {Ω : ι → Type*}
[∀ i, Fintype (Ω i)] (f : (i : ι) → Ω i → ℝ) :
finiteMean (fun ω : (i : ι) → Ω i => ∏ i, f i (ω i)) = ∏ i, finiteMean (f i) := by
simp only [finiteMean,←Fintype.prod_sum,Fintype.card_pi,Nat.cast_prod,Finset.prod_div_distrib]
section ParallelFairLayer
variable {β : Type*} [Fintype β] [DecidableEq β]
def pairLayer (ξ : β → Bool) : Equiv.Perm (Bool × β) where
toFun x := (Bool.xor x.1 (ξ x.2),x.2)
invFun x := (Bool.xor x.1 (ξ x.2),x.2)
left_inv x := by
rcases x with ⟨b,x⟩
change (Bool.xor (Bool.xor b (ξ x)) (ξ x),x) = (b,x)
cases b <;> cases ξ x <;> rfl
right_inv x := by
rcases x with ⟨b,x⟩
change (Bool.xor (Bool.xor b (ξ x)) (ξ x),x) = (b,x)
cases b <;> cases ξ x <;> rfl
noncomputable def pairFiber (S : Finset (Bool × β)) (b : β) : Finset Bool :=
Finset.univ.filter (fun ε => (ε,b) ∈ S)
lemma prod_pairFiber (S : Finset (Bool × β)) (f : Bool × β → ℝ) :
(∏ x ∈ S, f x) = ∏ b : β, ∏ ε ∈ pairFiber S b, f (ε,b) := by
classical
simp only [pairFiber,Finset.prod_filter]
rw [Finset.prod_comm,←Fintype.prod_prod_type (fun x : Bool × β => if x ∈ S then f x else 1)]
rw [←Finset.prod_filter]
congr 1
ext x
simp
lemma fiber_average_bound (S : Finset Bool) (p : Bool → ℝ) (hp : ∀ b, 0 ≤ p b) :
finiteMean (fun c : Bool => ∏ ε ∈ S, p (Bool.xor ε c)) ≤
∏ ε ∈ S, (p ε + p (!ε))/2 := by
rw [finiteMean_bool]
have hxor : ∀ ε : Bool, Bool.xor ε true = Equiv.swap false true ε := by decide
simp only [Bool.xor_false,hxor]
calc
_ ≤ ∏ ε ∈ S, (p ε+p (Equiv.swap false true ε))/2 :=
swap_average_product S p hp false true
_ = _ := Finset.prod_congr rfl (fun ε _ => by cases ε <;> rfl)
/-- A whole layer of independent fair pair coins preserves the upper-product
bound. Dependence in the random marked set is not discarded. -/
lemma CylinderBound.fair_parallel {m : Finset (Bool × β) → ℝ} {p : Bool × β → ℝ}
(h : CylinderBound m p) (hp : ∀ x, 0 ≤ p x) :
CylinderBound (fun S => finiteMean (fun ξ : β → Bool => m (S.image (pairLayer ξ))))
(fun x => (p x+p (!x.1,x.2))/2) := by
intro S
calc
_ ≤ finiteMean (fun ξ : β → Bool => ∏ x ∈ S, p (pairLayer ξ x)) := by
apply finiteMean_mono
intro ξ
simpa only [Finset.prod_image (pairLayer ξ).injective.injOn] using h (S.image (pairLayer ξ))
_ = ∏ b : β, finiteMean (fun c : Bool => ∏ ε ∈ pairFiber S b, p (Bool.xor ε c,b)) := by
calc
_ = finiteMean (fun ξ : β → Bool => ∏ b : β,
∏ ε ∈ pairFiber S b, p (Bool.xor ε (ξ b),b)) :=
finiteMean_congr (fun ξ => prod_pairFiber S (fun x => p (pairLayer ξ x)))
_ = _ := finiteMean_pi_prod (fun b c => ∏ ε ∈ pairFiber S b, p (Bool.xor ε c,b))
_ ≤ ∏ b : β, ∏ ε ∈ pairFiber S b, (p (ε,b)+p (!ε,b))/2 := by
apply Finset.prod_le_prod₀
· intro b _
exact div_nonneg (Finset.sum_nonneg (fun c _ =>
Finset.prod_nonneg (fun ε _ => hp (Bool.xor ε c,b)))) (Nat.cast_nonneg _)
· intro b _
exact fiber_average_bound (pairFiber S b) (fun ε => p (ε,b)) (fun ε => hp (ε,b))
_ = _ := (prod_pairFiber S (fun x => (p x+p (!x.1,x.2))/2)).symm
omit [Fintype β] in
lemma subset_pairLayer_image_iff (S A : Finset (Bool × β)) (ξ : β → Bool) :
S ⊆ A.image (pairLayer ξ) ↔ S.image (pairLayer ξ) ⊆ A := by
have hi (x : Bool × β) : pairLayer ξ (pairLayer ξ x) = x := (pairLayer ξ).left_inv x
constructor
· intro h
have h' := Finset.image_subset_image h (f := pairLayer ξ)
simpa only [Finset.image_image,Function.comp_def,hi,Finset.image_id'] using h'
· intro h
have h' := Finset.image_subset_image h (f := pairLayer ξ)
simpa only [Finset.image_image,Function.comp_def,hi,Finset.image_id'] using h'
noncomputable def fairSetLayer {Ω : Type*} (F : Ω → Finset (Bool × β)) :
Ω × (β → Bool) → Finset (Bool × β) := fun ω => (F ω.1).image (pairLayer ω.2)
lemma finiteMean_comm {Ω Ω' : Type*} [Fintype Ω] [Fintype Ω'] (f : Ω → Ω' → ℝ) :
finiteMean (fun x => finiteMean (f x)) = finiteMean (fun y => finiteMean (fun x => f x y)) := by
simp only [finiteMean,←Finset.sum_div,div_div]
rw [Finset.sum_comm,mul_comm]
lemma inclusionMoment_fairSetLayer {Ω : Type*} [Fintype Ω]
(F : Ω → Finset (Bool × β)) (S : Finset (Bool × β)) :
inclusionMoment (fairSetLayer F) S =
finiteMean (fun ξ : β → Bool => inclusionMoment F (S.image (pairLayer ξ))) := by
classical
simp only [inclusionMoment_eq]
have he : (fun ω : Ω × (β → Bool) => if S ⊆ fairSetLayer F ω then (1:ℝ) else 0) =
(fun ω : Ω × (β → Bool) => if S.image (pairLayer ω.2) ⊆ F ω.1 then (1:ℝ) else 0) := by
funext ω
simp only [fairSetLayer,subset_pairLayer_image_iff]
apply (congrArg finiteMean he).trans
exact (finiteMean_prod (fun ω : Ω × (β → Bool) =>
if S.image (pairLayer ω.2) ⊆ F ω.1 then (1:ℝ) else 0)).trans
(finiteMean_comm (fun ω ξ => if S.image (pairLayer ξ) ⊆ F ω then (1:ℝ) else 0))
lemma inclusionMoment_fairSetLayer_singleton {Ω : Type*} [Fintype Ω]
(F : Ω → Finset (Bool × β)) (x : Bool × β) :
inclusionMoment (fairSetLayer F) {x} =
(inclusionMoment F {x}+inclusionMoment F {(!x.1,x.2)})/2 := by
rw [inclusionMoment_fairSetLayer]
simp only [Finset.image_singleton,pairLayer,Equiv.coe_fn_mk]
rw [finiteMean_pi_eval (A := fun _ : β => Bool) x.2 (fun c : Bool => inclusionMoment F {(Bool.xor x.1 c,x.2)})]
rw [finiteMean_bool]
rcases x with ⟨b,x⟩
cases b <;> simp only [Bool.xor_false,Bool.false_xor,Bool.true_xor, Bool.not_false,Bool.not_true]
lemma cylinder_fairSetLayer {Ω : Type*} [Fintype Ω]
(F : Ω → Finset (Bool × β))
(h : CylinderBound (inclusionMoment F) (fun x => inclusionMoment F {x})) :
CylinderBound (inclusionMoment (fairSetLayer F))
(fun x => inclusionMoment (fairSetLayer F) {x}) := by
have hh := h.fair_parallel (fun x => inclusionMoment_nonneg F {x})
intro S
rw [inclusionMoment_fairSetLayer]
simp only [inclusionMoment_fairSetLayer_singleton]
exact hh S
end ParallelFairLayer
section RelabelMarks
variable {α β Ω Ω' : Type*} [DecidableEq α] [DecidableEq β] [Fintype Ω] [Fintype Ω']
omit [Fintype Ω] [Fintype Ω'] in
lemma subset_image_equiv_iff (e : α ≃ β) (A : Finset α) (S : Finset β) :
S ⊆ A.image e ↔ S.image e.symm ⊆ A := by
constructor
· intro h x hx
obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp hx
obtain ⟨x,hx,hxy⟩ := Finset.mem_image.mp (h hy)
simpa only [←hxy,Equiv.symm_apply_apply] using hx
· intro h y hy
exact Finset.mem_image.mpr ⟨e.symm y,h (Finset.mem_image_of_mem _ hy),e.apply_symm_apply y⟩
omit [Fintype Ω'] in
lemma inclusionMoment_image_equiv (e : α ≃ β) (F : Ω → Finset α) (S : Finset β) :
inclusionMoment (fun ω => (F ω).image e) S = inclusionMoment F (S.image e.symm) := by
classical
simp only [inclusionMoment_eq]
apply finiteMean_congr
intro ω
simp only [subset_image_equiv_iff]
omit [Fintype Ω'] in
lemma cylinder_image_equiv (e : α ≃ β) (F : Ω → Finset α)
(h : CylinderBound (inclusionMoment F) (fun x => inclusionMoment F {x})) :
CylinderBound (inclusionMoment (fun ω => (F ω).image e))
(fun x => inclusionMoment (fun ω => (F ω).image e) {x}) := by
intro S
simp only [inclusionMoment_image_equiv,Finset.image_singleton]
have hh := h (S.image e.symm)
simpa only [Finset.prod_image e.symm.injective.injOn] using hh
omit [DecidableEq β] in
lemma inclusionMoment_comp_equiv (e : Ω ≃ Ω') (F : Ω' → Finset α) (S : Finset α) :
inclusionMoment (fun ω => F (e ω)) S = inclusionMoment F S := by
classical
simp only [inclusionMoment_eq]
simpa only [Equiv.apply_symm_apply] using
finiteMean_equiv e (fun ω => if S ⊆ F (e ω) then (1 : ℝ) else 0)
omit [DecidableEq β] in
lemma cylinder_comp_equiv (e : Ω ≃ Ω') (F : Ω' → Finset α)
(h : CylinderBound (inclusionMoment F) (fun x => inclusionMoment F {x})) :
CylinderBound (inclusionMoment (fun ω => F (e ω)))
(fun x => inclusionMoment (fun ω => F (e ω)) {x}) := by
intro S
simpa only [inclusionMoment_comp_equiv] using h S
end RelabelMarks
lemma finiteMean_prod_mul {Ω Ω' : Type*} [Fintype Ω] [Fintype Ω']
(f : Ω → ℝ) (g : Ω' → ℝ) :
finiteMean (fun ω : Ω × Ω' => f ω.1*g ω.2) = finiteMean f * finiteMean g := by
simp only [finiteMean,Fintype.sum_prod_type,Fintype.card_prod,Nat.cast_mul,
←Finset.mul_sum,←Finset.sum_mul]
ring
section JoinChildren
variable {β : Type*} [DecidableEq β]
noncomputable def childJoin (A B : Finset β) : Finset (Bool × β) :=
A.image (fun x => (false,x)) ∪ B.image (fun x => (true,x))
lemma mem_childJoin (A B : Finset β) (b : Bool) (x : β) :
(b,x) ∈ childJoin A B ↔ (if b then x ∈ B else x ∈ A) := by
cases b <;> simp [childJoin]
noncomputable def boolFiber (S : Finset (Bool × β)) (b : Bool) : Finset β :=
(S.filter (fun x => x.1 = b)).image Prod.snd
lemma mem_boolFiber (S : Finset (Bool × β)) (b : Bool) (x : β) :
x ∈ boolFiber S b ↔ (b,x) ∈ S := by
constructor
· intro h
obtain ⟨⟨c,y⟩,hy,hxy⟩ := Finset.mem_image.mp h
obtain ⟨hy,hc⟩ := Finset.mem_filter.mp hy
change c = b at hc
change y = x at hxy
simpa only [hc,hxy] using hy
· intro h
exact Finset.mem_image.mpr ⟨(b,x),Finset.mem_filter.mpr ⟨h,rfl⟩,rfl⟩
lemma childJoin_boolFiber (S : Finset (Bool × β)) :
childJoin (boolFiber S false) (boolFiber S true) = S := by
ext ⟨b,x⟩
rw [mem_childJoin]
cases b <;> simp only [Bool.false_eq_true,↓reduceIte,mem_boolFiber]
lemma subset_childJoin_iff (S : Finset (Bool × β)) (A B : Finset β) :
S ⊆ childJoin A B ↔ boolFiber S false ⊆ A ∧ boolFiber S true ⊆ B := by
constructor
· intro h
constructor
· intro x hx
exact (mem_childJoin A B false x).mp (h ((mem_boolFiber S false x).mp hx))
· intro x hx
exact (mem_childJoin A B true x).mp (h ((mem_boolFiber S true x).mp hx))
· rintro ⟨h₀,h₁⟩ ⟨b,x⟩ hx
rw [mem_childJoin]
cases b
· exact h₀ ((mem_boolFiber S false x).mpr hx)
· exact h₁ ((mem_boolFiber S true x).mpr hx)
lemma prod_childJoin (A B : Finset β) (f : Bool × β → ℝ) :
(∏ x ∈ childJoin A B, f x) = (∏ x ∈ A, f (false,x)) * ∏ x ∈ B, f (true,x) := by
classical
have hd : Disjoint (A.image (fun x => (false,x))) (B.image (fun x => (true,x))) := by
apply Finset.disjoint_left.mpr
rintro x hx hy
obtain ⟨a,ha,rfl⟩ := Finset.mem_image.mp hx
obtain ⟨b,hb,hba⟩ := Finset.mem_image.mp hy
exact Bool.false_ne_true (congrArg Prod.fst hba).symm
rw [childJoin,Finset.prod_union hd,
Finset.prod_image (fun _ _ _ _ h => congrArg Prod.snd h),
Finset.prod_image (fun _ _ _ _ h => congrArg Prod.snd h)]
lemma prod_boolFibers (S : Finset (Bool × β)) (f : Bool × β → ℝ) :
(∏ x ∈ S, f x) = (∏ x ∈ boolFiber S false, f (false,x)) *
∏ x ∈ boolFiber S true, f (true,x) := by
rw [←prod_childJoin,childJoin_boolFiber]
lemma inclusionMoment_childJoin {Ω Ω' : Type*} [Fintype Ω] [Fintype Ω']
(F : Ω → Finset β) (G : Ω' → Finset β) (S : Finset (Bool × β)) :
inclusionMoment (fun ω : Ω × Ω' => childJoin (F ω.1) (G ω.2)) S =
inclusionMoment F (boolFiber S false) * inclusionMoment G (boolFiber S true) := by
classical
simp only [inclusionMoment_eq]
rw [←finiteMean_prod_mul]
apply finiteMean_congr
intro ω
simp only [subset_childJoin_iff]
split_ifs <;> simp_all
lemma cylinder_childJoin {Ω Ω' : Type*} [Fintype Ω] [Fintype Ω'] [Nonempty Ω] [Nonempty Ω']
(F : Ω → Finset β) (G : Ω' → Finset β)
(hF : CylinderBound (inclusionMoment F) (fun x => inclusionMoment F {x}))
(hG : CylinderBound (inclusionMoment G) (fun x => inclusionMoment G {x})) :
CylinderBound (inclusionMoment (fun ω : Ω × Ω' => childJoin (F ω.1) (G ω.2)))
(fun x => inclusionMoment (fun ω : Ω × Ω' => childJoin (F ω.1) (G ω.2)) {x}) := by
intro S
rw [inclusionMoment_childJoin,prod_boolFibers]
have hf (b : Bool) (x : β) : boolFiber {(b,x)} b = {x} := by
ext y
simp only [mem_boolFiber,Finset.mem_singleton,Prod.mk.injEq,true_and]
have hn (b : Bool) (x : β) : boolFiber {(!b,x)} b = ∅ := by
ext y
cases b <;> simp [mem_boolFiber]
have h₀ (x : β) : inclusionMoment (fun ω : Ω × Ω' => childJoin (F ω.1) (G ω.2)) {(false,x)} =
inclusionMoment F {x} * inclusionMoment G ∅ := by
rw [inclusionMoment_childJoin,hf]
have hh := hn true x
exact congrArg (fun T => inclusionMoment F {x} * inclusionMoment G T) hh
have h₁ (x : β) : inclusionMoment (fun ω : Ω × Ω' => childJoin (F ω.1) (G ω.2)) {(true,x)} =
inclusionMoment F ∅ * inclusionMoment G {x} := by
rw [inclusionMoment_childJoin,hf]
have hh := hn false x
exact congrArg (fun T => inclusionMoment F T * inclusionMoment G {x}) hh
have emF : inclusionMoment F ∅ = 1 := by simp [inclusionMoment,finiteMean_const]
have emG : inclusionMoment G ∅ = 1 := by simp [inclusionMoment,finiteMean_const]
simp only [h₀,h₁,emF,emG,mul_one,one_mul]
exact mul_le_mul (hF _) (hG _) (inclusionMoment_nonneg _ _)
(Finset.prod_nonneg (fun x _ => inclusionMoment_nonneg F {x}))
end JoinChildren
/-- Exact independent split of a butterfly's last layer and its two children. -/
def coinStepEquiv (d : ℕ) : (SwitchIndex (d+1) → Bool) ≃
((SwitchIndex d → Bool) × (SwitchIndex d → Bool)) × (Card d → Bool) where
toFun ω := ((fun i => ω (Sum.inr (false,i)),fun i => ω (Sum.inr (true,i))),
fun x => ω (Sum.inl x))
invFun ω := Sum.elim ω.2 (fun bi => if bi.1 then ω.1.2 bi.2 else ω.1.1 bi.2)
left_inv ω := by
funext i
cases i with
| inl x => rfl
| inr bi => cases bi with | mk b i => cases b <;> rfl
right_inv ω := by
rcases ω with ⟨⟨ω₀,ω₁⟩,ξ⟩
rfl
def headTailEquiv (d : ℕ) : Card (d+1) ≃ Bool × Card d :=
(Fin.consEquiv (fun _ : Fin (d+1) => Bool)).symm
lemma childMarks_join (d : ℕ) (A : Finset (Card (d+1))) :
A = (childMarks A false).image (Fin.cons false) ∪
(childMarks A true).image (Fin.cons true) := by
classical
ext x
constructor
· intro hx
cases hb : x 0
· exact Finset.mem_union_left _ (Finset.mem_image.mpr
⟨Fin.tail x,(mem_childMarks _ _ _).mpr (by simpa only [←hb,Fin.cons_self_tail] using hx),
by simp only [←hb,Fin.cons_self_tail]⟩)
· exact Finset.mem_union_right _ (Finset.mem_image.mpr
⟨Fin.tail x,(mem_childMarks _ _ _).mpr (by simpa only [←hb,Fin.cons_self_tail] using hx),
by simp only [←hb,Fin.cons_self_tail]⟩)
· intro hx
rcases Finset.mem_union.mp hx with hx | hx
· obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp hx
exact (mem_childMarks _ _ _).mp hy
· obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp hx
exact (mem_childMarks _ _ _).mp hy
noncomputable def butterflyMarks (d : ℕ) (A : Finset (Card d))
(ω : SwitchIndex d → Bool) : Finset (Card d) :=
A.image (butterflyPerm d (decodeButterfly d ω))
lemma butterflyMarks_succ (d : ℕ) (A : Finset (Card (d+1))) (ω : SwitchIndex (d+1) → Bool) :
butterflyMarks (d+1) A ω =
(fairSetLayer (fun p : (SwitchIndex d → Bool) × (SwitchIndex d → Bool) =>
childJoin (butterflyMarks d (childMarks A false) p.1)
(butterflyMarks d (childMarks A true) p.2)) (coinStepEquiv d ω)).image
(headTailEquiv d).symm := by
classical
unfold butterflyMarks fairSetLayer childJoin
rw [Finset.image_union,Finset.image_union]
simp only [Finset.image_image]
conv_lhs => rw [childMarks_join d A]
rw [Finset.image_union]
simp only [Finset.image_image]
apply congrArg₂ (· ∪ ·)
· apply Finset.image_congr
intro x _
simp only [Function.comp_def,butterflyPerm,decodeButterfly,Equiv.Perm.coe_mul,
childLift,pairSwitch,switchFun,Equiv.coe_fn_mk,Fin.cons_zero,Fin.tail_cons,
coinStepEquiv,headTailEquiv,Equiv.symm_symm,pairLayer]
rfl
· apply Finset.image_congr
intro x _
simp only [Function.comp_def,butterflyPerm,decodeButterfly,Equiv.Perm.coe_mul,
childLift,pairSwitch,switchFun,Equiv.coe_fn_mk,Fin.cons_zero,Fin.tail_cons,
coinStepEquiv,headTailEquiv,Equiv.symm_symm,pairLayer]
rfl
/-- The actual central marked positions obey the product-of-marginals upper
bound, not just an independently resampled proxy. -/
lemma butterflyMarks_cylinder (d : ℕ) (A : Finset (Card d)) :
CylinderBound (inclusionMoment (butterflyMarks d A))
(fun x => inclusionMoment (butterflyMarks d A) {x}) := by
induction d with
| zero =>
have he : butterflyMarks 0 A = fun _ : SwitchIndex 0 → Bool => A := by
funext ω
simp [butterflyMarks,butterflyPerm]
rw [he]
exact cylinder_const A
| succ d ih =>
have h := cylinder_childJoin (butterflyMarks d (childMarks A false))
(butterflyMarks d (childMarks A true)) (ih _) (ih _)
have hh := cylinder_image_equiv (headTailEquiv d).symm _ (cylinder_fairSetLayer _ h)
have hs := cylinder_comp_equiv (coinStepEquiv d) _ hh
simpa only [←butterflyMarks_succ] using hs
lemma indicator_mem_image_perm {α : Type*} [DecidableEq α]
(A : Finset α) (p : Equiv.Perm α) (y : α) :
(if y ∈ A.image p then (1 : ℝ) else 0) = ∑ x ∈ A, if p x = y then 1 else 0 := by
classical
by_cases h : y ∈ A.image p
· obtain ⟨x,hx,hxy⟩ := Finset.mem_image.mp h
rw [ite_eq_left (Finset.mem_image.mpr ⟨x,hx,hxy⟩)]
symm
calc
_ = (if p x = y then (1:ℝ) else 0) := Finset.sum_eq_single_of_mem x hx (by
intro z _ hzx
exact ite_eq_right (fun hz => hzx (p.injective (hz.trans hxy.symm))))
_ = 1 := ite_eq_left hxy
· rw [ite_eq_right h]
symm
apply Finset.sum_eq_zero
intro x hx
exact ite_eq_right (fun hxy => h (Finset.mem_image.mpr ⟨x,hx,hxy⟩))
lemma butterflyMarks_singleton (d : ℕ) (A : Finset (Card d)) (y : Card d) :
inclusionMoment (butterflyMarks d A) {y} = (A.card : ℝ)/(2:ℝ)^d := by
classical
unfold inclusionMoment
simp only [Finset.singleton_subset_iff,butterflyMarks,indicator_mem_image_perm]
rw [finiteMean_sum]
simp only [butterfly_single_card_uniform,Finset.sum_const,nsmul_eq_mul]
ring
/-- The joint inclusion bound used for the low levels of FAC.1. -/
lemma butterflyMarks_inclusion (d : ℕ) (A S : Finset (Card d)) :
inclusionMoment (butterflyMarks d A) S ≤ ((A.card : ℝ)/(2:ℝ)^d)^S.card := by
have h := butterflyMarks_cylinder d A S
simpa only [butterflyMarks_singleton,Finset.prod_const] using h
end CubeShuffle
end OAI