| import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationSurvival |
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.SamplerExecution |
|
|
| namespace OAI |
|
|
| /-! # Canonical consecutive labels for representation partitions |
|
|
| The base labeling is determined by the sorted mixer domain. Randomly |
| permuting these labels gives the analyzed uniform balanced partition, with |
| no choice of an arbitrary initial coloring required by the runtime. |
| -/ |
|
|
| noncomputable section |
| namespace LowSpaceSubsetSum.CanonicalPartition |
|
|
| private def rankFiber (m g : ℕ) (j : Fin m) : |
| {x : Fin (m * g) // (finProdFinEquiv.symm x).1 = j} ≃ Fin g where |
| toFun x := (finProdFinEquiv.symm x.1).2 |
| invFun k := ⟨finProdFinEquiv (j, k), by simp⟩ |
| left_inv x := by |
| apply Subtype.ext |
| apply finProdFinEquiv.symm.injective |
| change finProdFinEquiv.symm (finProdFinEquiv (j, (finProdFinEquiv.symm x.val).2)) = |
| finProdFinEquiv.symm x.val |
| rw [Equiv.symm_apply_apply] |
| exact Prod.ext x.property.symm rfl |
| right_inv k := by simp |
|
|
| variable {n : ℕ} |
|
|
| theorem size_eq (R : RepresentationSetup n) (z : RepresentationSetup.Layout n) (i : Fin 3) : |
| (R.orderedMixers z i).card = RepresentationSetup.blockCount i * (2 * RepresentationSetup.blockHalf n i) := by |
| rw [R.orderedMixers_card, ← R.blockCount_half i] |
| ring |
|
|
| def ranks (R : RepresentationSetup n) (z : RepresentationSetup.Layout n) (i : Fin 3) : |
| ↥(R.orderedMixers z i) ≃ Fin (RepresentationSetup.blockCount i * (2 * RepresentationSetup.blockHalf n i)) := |
| ((R.orderedMixers z i).orderIsoOfFin (size_eq R z i)).symm.toEquiv |
|
|
| def labels (R : RepresentationSetup n) (z : RepresentationSetup.Layout n) (i : Fin 3) |
| (a : ↥(R.orderedMixers z i)) : Fin (RepresentationSetup.blockCount i) := |
| (finProdFinEquiv.symm (ranks R z i a)).1 |
|
|
| private def labelFiber (R : RepresentationSetup n) (z : RepresentationSetup.Layout n) |
| (i : Fin 3) (j : Fin (RepresentationSetup.blockCount i)) : |
| {a : ↥(R.orderedMixers z i) // labels R z i a = j} ≃ |
| Fin (2 * RepresentationSetup.blockHalf n i) := |
| ((ranks R z i).subtypeEquivOfSubtype |
| (p := fun x => (finProdFinEquiv.symm x).1 = j)).trans (rankFiber _ _ j) |
|
|
| def base (R : RepresentationSetup n) (z : RepresentationSetup.Layout n) (i : Fin 3) : |
| R.Partition z i := |
| ⟨labels R z i, by |
| funext j |
| exact (Fintype.card_congr (labelFiber R z i j)).trans (Fintype.card_fin _)⟩ |
|
|
| def coupling (R : RepresentationSetup n) (z : RepresentationSetup.Layout n) (i : Fin 3) : |
| SamplerCoupling (R.Partition z i) := |
| ((permutationCoupling n (RepresentationSetup.blockCount i * (2 * RepresentationSetup.blockHalf n i))).map |
| (Equiv.permCongr (ranks R z i).symm)).map (coloringOfPermutation (base R z i)) |
|
|
| theorem coupling_uniform (R : RepresentationSetup n) (z : RepresentationSetup.Layout n) (i : Fin 3) : |
| (coupling R z i).idealLaw = @FiniteLaw.uniform _ inferInstance ⟨base R z i⟩ := by |
| rw [coupling, SamplerCoupling.map_idealLaw, SamplerCoupling.map_idealLaw, |
| permutationCoupling_uniform, FiniteLaw.map_equiv_uniform] |
| exact coloringOfPermutation_uniform (base R z i) |
|
|
| theorem coupling_failure (R : RepresentationSetup n) (z : RepresentationSetup.Layout n) (i : Fin 3) : |
| (coupling R z i).failure ≤ mixerSize n / (2 : ℝ) ^ (n ^ 3) := by |
| rw [coupling, SamplerCoupling.map_failure, SamplerCoupling.map_failure] |
| have h := permutationCoupling_failure n |
| (RepresentationSetup.blockCount i * (2 * RepresentationSetup.blockHalf n i)) |
| have hc : RepresentationSetup.blockCount i * (2 * RepresentationSetup.blockHalf n i) = mixerSize n := by |
| rw [← size_eq R z i, R.orderedMixers_card, RepresentationSetup.halfSize] |
| unfold mixerSize |
| omega |
| simpa only [hc] using h |
|
|
|
|
| def execution (R : RepresentationSetup n) (z : RepresentationSetup.Layout n) (i : Fin 3) : |
| SamplerExecution.Execution (coupling R z i) := |
| SamplerExecution.map |
| (SamplerExecution.map |
| (SamplerExecution.permutation n (RepresentationSetup.blockCount i * |
| (2 * RepresentationSetup.blockHalf n i))) |
| (Equiv.permCongr (ranks R z i).symm)) |
| (coloringOfPermutation (base R z i)) |
|
|
| theorem execution_bounded (R : RepresentationSetup n) (z : RepresentationSetup.Layout n) (i : Fin 3) : |
| (execution R z i).Bounded (mixerSize n * n ^ 3) 0 := by |
| have hc : RepresentationSetup.blockCount i * (2 * RepresentationSetup.blockHalf n i) = mixerSize n := by |
| rw [← size_eq R z i, R.orderedMixers_card, RepresentationSetup.halfSize] |
| unfold mixerSize |
| omega |
| unfold execution |
| apply SamplerExecution.map_bounded |
| apply SamplerExecution.map_bounded |
| simpa only [hc] using SamplerExecution.permutation_bounded n |
| (RepresentationSetup.blockCount i * (2 * RepresentationSetup.blockHalf n i)) |
|
|
| end LowSpaceSubsetSum.CanonicalPartition |
|
|
| end |
|
|
| end OAI |
|
|
