| import OAI.Probability.CubeShuffle.ModifiedDensity |
| import OAI.Probability.CubeShuffle.FiniteKernel |
|
|
| namespace OAI |
|
|
| namespace CubeShuffle |
| namespace PairRouting |
| open scoped BigOperators |
|
|
| lemma tupleProbability_row_sum {ι β Ω : Type*} [Fintype ι] [Fintype β] |
| [DecidableEq β] [Fintype Ω] [Nonempty Ω] |
| (P : Ω → Equiv.Perm β) (e : ι ↪ β) : |
| (∑ f : ι ↪ β, tupleProbability P e f) = 1 := by |
| classical |
| simp only [tupleProbability] |
| rw [←finiteMean_sum] |
| have h (ω : Ω) (f : ι ↪ β) : (∀ i, P ω (e i) = f i) ↔ e.trans (P ω).toEmbedding = f := by |
| constructor |
| · intro h; ext i; exact h i |
| · intro h i; exact congrArg (fun g : ι ↪ β => g i) h |
| simp_rw [h] |
| simp only [Finset.sum_ite_eq,Finset.mem_univ,↓reduceIte,finiteMean_const] |
|
|
| lemma tupleProbability_inverse {ι β Ω : Type*} [Fintype ι] [DecidableEq β] |
| [Fintype Ω] (P : Ω → Equiv.Perm β) (e f : ι → β) : |
| tupleProbability (fun ω => (P ω)⁻¹) e f = tupleProbability P f e := by |
| classical |
| apply finiteMean_congr |
| intro ω |
| congr 1 |
| apply propext |
| constructor |
| · intro h i |
| have hh := congrArg (P ω) (h i) |
| simpa only [Equiv.Perm.inv_def,Equiv.apply_symm_apply] using hh.symm |
| · intro h i |
| have hh := congrArg (fun x => (P ω).symm x) (h i) |
| simpa only [Equiv.Perm.inv_def,Equiv.symm_apply_apply] using hh.symm |
|
|
| lemma tupleProbability_equiv {ι β Ω Ω' : Type*} [Fintype ι] [DecidableEq β] |
| [Fintype Ω] [Fintype Ω'] (P : Ω → Equiv.Perm β) (τ : Ω ≃ Ω') (e f : ι → β) : |
| tupleProbability P e f = tupleProbability (fun ω => P (τ.symm ω)) e f := |
| finiteMean_equiv τ _ |
|
|
| lemma tupleProbability_symmetric {ι β Ω : Type*} [Fintype ι] [DecidableEq β] |
| [Fintype Ω] (P : Ω → Equiv.Perm β) (τ : Equiv.Perm Ω) |
| (hτ : ∀ ω, P (τ ω) = (P ω)⁻¹) (e f : ι → β) : |
| tupleProbability P e f = tupleProbability P f e := by |
| rw [tupleProbability_equiv P τ.symm] |
| simp only [Equiv.symm_symm,hτ] |
| exact tupleProbability_inverse P e f |
|
|
| end PairRouting |
|
|
| lemma palindromePerm_reverse (d : ℕ) (ω : BenesCoins d) : |
| palindromePerm d (ω.2,ω.1) = (palindromePerm d ω)⁻¹ := by |
| simp only [palindromePerm,mul_inv_rev] |
| rfl |
|
|
| lemma palindrome_kernel_symmetric (d : ℕ) {ι : Type*} [Fintype ι] |
| (e f : ι ↪ Card d) : |
| PairRouting.tupleProbability (palindromePerm d) e f = |
| PairRouting.tupleProbability (palindromePerm d) f e := |
| PairRouting.tupleProbability_symmetric _ (Equiv.prodComm _ _) (palindromePerm_reverse d) e f |
|
|
| /-- The actual palindrome density estimate combined with the proved finite |
| Schur/Bessel transfer. The family is an arbitrary orthonormal family in the |
| literal tuple space, not an assumed representation of the desired theorem. -/ |
| theorem palindrome_density_transfer (d : ℕ) {ι I : Type*} [Fintype ι] [Fintype I] |
| [Nonempty I] (e₀ : ι ↪ Card d) (hk : 0 < Fintype.card ι) |
| (v : I → EuclideanSpace ℂ (ι ↪ Card d)) (hv : Orthonormal ℂ v) |
| (μ : ℝ) (hvμ : ∀ i, μ ≤ ‖DensityTransfer.applyKernel |
| (fun e f : ι ↪ Card d => PairRouting.tupleProbability (palindromePerm d) e f) (v i)‖) |
| (z : ℝ) (hz : 0 < z) : |
| μ ≤ Real.exp (densityConstant*Fintype.card ι* |
| ((Fintype.card ι:ℝ)/(2:ℝ)^d)^(1/512:ℝ))*z^(-(1/1000:ℝ))+ |
| Real.sqrt (z/(Fintype.card I:ℝ)) := by |
| let : Nonempty (ι ↪ Card d) := ⟨e₀⟩ |
| apply DensityTransfer.multiplicity_amplification |
| (fun e f : ι ↪ Card d => PairRouting.tupleProbability (palindromePerm d) e f) |
| (fun e f => PairRouting.tupleProbability_nonneg _ e f) |
| (palindrome_kernel_symmetric d) (PairRouting.tupleProbability_row_sum _) |
| (1/1000) z _ (by norm_num) hz (Real.exp_nonneg _) _ v hv μ hvμ |
| intro e |
| exact palindrome_row_moment_bound d e hk |
|
|
| end CubeShuffle |
| namespace CubeShuffle |
|
|
| /-- A measure-preserving reversal of the actual modified coin experiment. |
| At a leaf the redundant output butterfly is kept, while its uniform seed is |
| inverted and conjugated. At higher nodes the two outer fair fields are swapped. -/ |
| noncomputable def modifiedReverseCoins (L : ℕ) : (r : ℕ) → ModifiedCoins L r → ModifiedCoins L r |
| | 0, ω => ((fun u => butterflyPerm L (decodeButterfly L ω.2.1) * (ω.1 u)⁻¹ * |
| butterflyPerm L (decodeButterfly L ω.2.1)),ω.2) |
| | r+1, ω => |
| let z := modifiedStepEquiv L r ω |
| (modifiedStepEquiv L r).symm |
| ((modifiedReverseCoins L r z.1.1,modifiedReverseCoins L r z.1.2),(z.2.2,z.2.1)) |
|
|
| lemma modifiedReverseCoins_involutive (L r : ℕ) : |
| Function.Involutive (modifiedReverseCoins L r) := by |
| induction r with |
| | zero => |
| intro ω |
| apply Prod.ext |
| · funext u |
| simp only [modifiedReverseCoins,mul_inv_rev,inv_inv] |
| simp [mul_assoc] |
| · rfl |
| | succ r ih => |
| change ∀ ω, modifiedReverseCoins L r (modifiedReverseCoins L r ω) = ω at ih |
| intro ω |
| simp only [modifiedReverseCoins,Equiv.apply_symm_apply,ih] |
| exact (modifiedStepEquiv L r).symm_apply_apply ω |
|
|
| noncomputable def modifiedReverseEquiv (L r : ℕ) : Equiv.Perm (ModifiedCoins L r) where |
| toFun := modifiedReverseCoins L r |
| invFun := modifiedReverseCoins L r |
| left_inv := modifiedReverseCoins_involutive L r |
| right_inv := modifiedReverseCoins_involutive L r |
|
|
| lemma modifiedPerm_reverse (L r : ℕ) (E : Finset (Card r)) (ω : ModifiedCoins L r) : |
| modifiedPerm L r E (modifiedReverseCoins L r ω) = (modifiedPerm L r E ω)⁻¹ := by |
| induction r with |
| | zero => |
| rw [modifiedPerm_zero,modifiedPerm_zero] |
| split_ifs |
| · simp only [inv_one] |
| · simp only [modifiedReverseCoins,mul_inv_rev,inv_inv] |
| simp |
| | succ r ih => |
| obtain ⟨z,rfl⟩ := (modifiedStepEquiv L r).symm.surjective ω |
| rcases z with ⟨⟨ω₀,ω₁⟩,⟨ξ,η⟩⟩ |
| simp only [modifiedReverseCoins,Equiv.apply_symm_apply,modifiedPerm_step, |
| mul_inv_rev,pairSwitch_inv,childLift_inv] |
| rw [mul_assoc] |
| congr 1 |
| congr 1 |
| apply congrArg childLift |
| funext b |
| cases b <;> simp only [Bool.false_eq_true,↓reduceIte,ih] |
|
|
| lemma modified_kernel_symmetric (L r : ℕ) (E : Finset (Card r)) |
| {ι : Type*} [Fintype ι] (e f : ι ↪ Card (L+r)) : |
| PairRouting.tupleProbability (modifiedPerm L r E) e f = |
| PairRouting.tupleProbability (modifiedPerm L r E) f e := |
| PairRouting.tupleProbability_symmetric _ (modifiedReverseEquiv L r) |
| (modifiedPerm_reverse L r E) e f |
|
|
| end CubeShuffle |
|
|
| end OAI |
|
|
