File size: 6,500 Bytes
f205175 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 | 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
|