| import OAI.Combinatorics.LowSpaceSubsetSum.Word.WordRealization |
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.FiniteProductSamplerCoupling |
|
|
| namespace OAI |
|
|
| /-! # Exact bounded word programs for range and permutation calls -/ |
|
|
| noncomputable section |
| namespace LowSpaceSubsetSum.WordRealization |
|
|
| def enlarge {w N M : ℕ} {α : Type} [Fintype α] {S : SamplerCoupling α} |
| (X : Realization w N S) (h : N ≤ M) : Realization w M S where |
| program := X.program |
| faithful := X.faithful |
| bounded := by |
| have hb := WordProgram.bound_add X.program N X.bounded (M-N) |
| simpa only [Nat.sub_add_cancel h] using hb |
|
|
| def prod {w N M : ℕ} {α β : Type} [Fintype α] [Fintype β] |
| {S : SamplerCoupling α} {T : SamplerCoupling β} |
| (X : Realization w N S) (Y : Realization w M T) : |
| Realization w (N+M) (S.prod T) := |
| map (bind X (fun _ => β) (fun _ => T) (fun _ => Y)) (Equiv.sigmaEquivProd α β) |
|
|
| def range (w n D : ℕ) (hD : 1 < D) (hw : Nat.clog 2 D ≤ w) : |
| Realization w (n^3) (rangeCoupling hD n) := by |
| let : Nonempty (Fin D) := ⟨⟨0, by omega⟩⟩ |
| let : Nonempty {x : Fin (2 ^ Nat.clog 2 D) |
| ⟨(rangeEligibleEquiv D).symm ⟨0, by omega⟩⟩ |
| exact map (rejection w (Nat.clog 2 D) hw (n^3) (rangeEligible D)) (rangeEligibleEquiv D) |
|
|
| def fin (w n D : ℕ) [NeZero D] (hw : Nat.clog 2 D ≤ w) : |
| Realization w (n^3) (finCoupling n D) := by |
| unfold finCoupling |
| split |
| next h => exact range w n D h hw |
| next h => exact enlarge (pure (⟨0, Nat.pos_of_ne_zero (NeZero.ne D)⟩ : Fin D)) (Nat.zero_le _) |
|
|
| def pi (w N : ℕ) : (k : ℕ) → (A : Fin k → Type) → [∀ i, Fintype (A i)] → |
| (S : ∀ i, SamplerCoupling (A i)) → (∀ i, Realization w N (S i)) → |
| Realization w (k*N) (SamplerCoupling.pi k A S) |
| | 0, A, _, _, _ => by |
| simpa only [Nat.zero_mul, SamplerCoupling.pi] using |
| (pure (w := w) (fun i : Fin 0 => (Fin.elim0 i : A i))) |
| | k+1, A, _, S, X => by |
| have h := map (prod (X 0) |
| (pi w N k (fun i => A i.succ) (fun i => S i.succ) (fun i => X i.succ))) |
| (Fin.consEquiv A) |
| simpa only [SamplerCoupling.pi, Nat.add_mul, Nat.one_mul, Nat.add_comm] using h |
|
|
| def permutation (w n : ℕ) : (k : ℕ) → Nat.clog 2 k ≤ w → |
| Realization w (k*n^3) (permutationCoupling n k) |
| | 0, _ => by |
| simpa only [Nat.zero_mul, permutationCoupling] using (pure (w := w) (Equiv.refl (Fin 0))) |
| | k+1, hw => by |
| have hk : Nat.clog 2 k ≤ w := |
| (Nat.clog_mono_right 2 (by omega : k ≤ k+1)).trans hw |
| have h := map (prod (fin w n (k+1) hw) (permutation w n k hk)) |
| Equiv.Perm.decomposeFin.symm |
| simpa only [permutationCoupling, Nat.add_mul, Nat.one_mul, Nat.add_comm] using h |
|
|
| def finiteChoice (w n : ℕ) (A : Type) [Fintype A] [Nonempty A] |
| (hw : Nat.clog 2 (Fintype.card A) ≤ w) : |
| Realization w (n^3) (finiteChoiceCoupling n A) := |
| map (fin w n (Fintype.card A) hw) (Fintype.equivFin A).symm |
|
|
| def finitePermutation (w n : ℕ) (A : Type) [Fintype A] [DecidableEq A] |
| (hw : Nat.clog 2 (Fintype.card A) ≤ w) : |
| Realization w (Fintype.card A*n^3) (finitePermutationCoupling n A) := |
| map (permutation w n (Fintype.card A) hw) (Equiv.permCongr (Fintype.equivFin A).symm) |
|
|
| end LowSpaceSubsetSum.WordRealization |
|
|
| end |
|
|
| end OAI |
|
|
