| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.RejectionSamplerCoupling |
|
|
| namespace OAI |
|
|
| /-! # Exact power-of-two draws from fair machine words |
|
|
| These projections discard high bits, so their law is exactly uniform. |
| The rejection sampler's independent eligible backup is absent from the |
| bounded execution and can be integrated out without changing its law. |
| -/ |
|
|
| noncomputable section |
| namespace LowSpaceSubsetSum.ExactWordDraw |
|
|
| def low (w k : ℕ) (x : Fin (2^w)) : Fin (2^k) := |
| ⟨x.val % 2^k, Nat.mod_lt _ (by positivity)⟩ |
|
|
| def wordSplit (w k : ℕ) (hk : k ≤ w) : |
| Fin (2^w) ≃ Fin (2^k) × Fin (2^(w-k)) := |
| (finCongr (by rw [← pow_add, Nat.sub_add_cancel hk])).trans |
| ((finProdFinEquiv (m := 2^(w-k)) (n := 2^k)).symm.trans (Equiv.prodComm _ _)) |
|
|
| theorem wordSplit_low (w k : ℕ) (hk : k ≤ w) (x : Fin (2^w)) : |
| (wordSplit w k hk x).1 = low w k x := by |
| apply Fin.ext |
| rfl |
|
|
| def tupleSplit (w k : ℕ) (hk : k ≤ w) (N : ℕ) : |
| (Fin N → Fin (2^w)) ≃ (Fin N → Fin (2^k)) × (Fin N → Fin (2^(w-k))) where |
| toFun f := (fun i => (wordSplit w k hk (f i)).1, fun i => (wordSplit w k hk (f i)).2) |
| invFun p i := (wordSplit w k hk).symm (p.1 i, p.2 i) |
| left_inv f := by |
| funext i |
| exact (wordSplit w k hk).symm_apply_apply (f i) |
| right_inv p := by |
| apply Prod.ext |
| · funext i |
| exact congrArg Prod.fst ((wordSplit w k hk).apply_symm_apply (p.1 i, p.2 i)) |
| · funext i |
| exact congrArg Prod.snd ((wordSplit w k hk).apply_symm_apply (p.1 i, p.2 i)) |
|
|
| theorem uniform_tuple (w k : ℕ) (hk : k ≤ w) (N : ℕ) |
| (P : (Fin N → Fin (2^k)) → Prop) : |
| (FiniteLaw.uniform : FiniteLaw (Fin N → Fin (2^w))).probability |
| (fun f => P (fun i => low w k (f i))) = |
| (FiniteLaw.uniform : FiniteLaw (Fin N → Fin (2^k))).probability P := by |
| rw [FiniteLaw.uniform_probability, FiniteLaw.uniform_probability] |
| have he := finiteUniformProbability_equiv (tupleSplit w k hk N) (fun p => P p.1) |
| have hfun (f : Fin N → Fin (2^w)) : |
| (tupleSplit w k hk N f).1 = fun i => low w k (f i) := by |
| funext i |
| exact wordSplit_low w k hk (f i) |
| simpa only [hfun] using he.trans (finiteUniformProbability_fst P) |
|
|
| private theorem uniform_projection {Ω Ψ : Type} [Fintype Ω] [Fintype Ψ] |
| [Nonempty Ω] [Nonempty Ψ] (P : Ω → Prop) : |
| (FiniteLaw.uniform : FiniteLaw (Ω × Ψ)).probability (fun s => P s.1) = |
| (FiniteLaw.uniform : FiniteLaw Ω).probability P := by |
| rw [FiniteLaw.uniform_probability, FiniteLaw.uniform_probability] |
| exact finiteUniformProbability_fst P |
|
|
| theorem firstAccept_no_backup {Ω : Type} [Fintype Ω] [Nonempty Ω] |
| (A : Ω → Prop) [DecidablePred A] [Nonempty {a : Ω // A a}] |
| (N : ℕ) (P : Option {a : Ω // A a} → Prop) : |
| (firstAcceptCoupling A N).law.probability |
| (fun s => P ((firstAcceptCoupling A N).bounded s)) = |
| (FiniteLaw.uniform : FiniteLaw (Fin N → Ω)).probability |
| (fun f => P (firstAcceptSubtype A N f)) := by |
| change (FiniteLaw.uniform : FiniteLaw ((Fin N → Ω) × {a : Ω // A a})).probability |
| (fun s => P (firstAcceptSubtype A N s.1)) = _ |
| exact uniform_projection (Ψ := {a : Ω // A a}) (fun f => P (firstAcceptSubtype A N f)) |
|
|
| theorem firstAccept_words (w k : ℕ) (hk : k ≤ w) |
| (A : Fin (2^k) → Prop) [DecidablePred A] [Nonempty {a : Fin (2^k) // A a}] |
| (N : ℕ) (P : Option {a : Fin (2^k) // A a} → Prop) : |
| (firstAcceptCoupling A N).law.probability |
| (fun s => P ((firstAcceptCoupling A N).bounded s)) = |
| (FiniteLaw.uniform : FiniteLaw (Fin N → Fin (2^w))).probability |
| (fun f => P (firstAcceptSubtype A N (fun i => low w k (f i)))) := by |
| rw [firstAccept_no_backup] |
| exact (uniform_tuple w k hk N (fun f => P (firstAcceptSubtype A N f))).symm |
|
|
| / |
| theorem candidates_words (w k : ℕ) (hk : k ≤ w) |
| (A : Fin (2^k) → Prop) [DecidablePred A] [Nonempty {a : Fin (2^k) // A a}] |
| (N : ℕ) (P : (Fin N → Fin (2^k)) → Prop) : |
| (firstAcceptCoupling A N).law.probability (fun s => P s.1) = |
| (FiniteLaw.uniform : FiniteLaw (Fin N → Fin (2^w))).probability |
| (fun f => P (fun i => low w k (f i))) := by |
| exact (uniform_projection (Ψ := {a : Fin (2^k) // A a}) P).trans |
| (uniform_tuple w k hk N P).symm |
|
|
| end LowSpaceSubsetSum.ExactWordDraw |
|
|
| end |
|
|
| end OAI |
|
|
