File size: 7,714 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 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 | import OAI.Probability.CubeShuffle.PairRouting
import OAI.RepresentationTheory.FiniteUnitary.Sampling
namespace OAI
namespace CubeShuffle.UnitaryFinite
variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [FiniteDimensional ℂ V]
lemma sampleOperator_palindrome (d : ℕ) (ρ : Representation ℂ (Equiv.Perm (Card d)) V)
(hρ : IsUnitary ρ) :
sampleOperator ρ (palindromePerm d)=
sampleOperator ρ (fun ω => butterflyPerm d (decodeButterfly d ω))*
(sampleOperator ρ (fun ω => butterflyPerm d (decodeButterfly d ω))).adjoint := by
rw [←sampleOperator_inv ρ hρ,←sampleOperator_prod]
rfl
end CubeShuffle.UnitaryFinite
namespace CubeShuffle
open scoped BigOperators Classical
def butterflyIdentity : (d : ℕ) → Butterfly d
| 0 => ()
| d+1 => (fun _ => false,fun _ => butterflyIdentity d)
lemma pairSwitch_false (d : ℕ) : pairSwitch (d := d) (fun _ => false)=1 := by
apply Equiv.ext
intro x
change switchFun (fun _ => false) x=x
simp [switchFun]
lemma childLift_one (d : ℕ) : childLift (d := d) (fun _ => 1)=1 := by
ext x i
simp [childLift]
lemma butterflyIdentity_perm (d : ℕ) : butterflyPerm d (butterflyIdentity d)=1 := by
induction d with
| zero => rfl
| succ d ih => simp only [butterflyIdentity,butterflyPerm,ih,pairSwitch_false,childLift_one,mul_one]
noncomputable def childInjection (d : ℕ) (b : Bool) : Equiv.Perm (Card d) →* Equiv.Perm (Card (d+1)) where
toFun p := childLift (fun c => if c=b then p else 1)
map_one' := by simpa only [ite_self] using childLift_one d
map_mul' p q := by
rw [childLift_mul]
congr 1
funext c
split_ifs <;> simp
lemma childInjection_swap (d : ℕ) (b : Bool) (u v : Card d) :
childInjection d b (Equiv.swap u v)=Equiv.swap (Fin.cons b u) (Fin.cons b v) := by
apply Equiv.ext
intro x
obtain ⟨c,w,rfl⟩ : ∃ c w, x=Fin.cons c w := ⟨x 0,Fin.tail x,(Fin.cons_self_tail x).symm⟩
change (Fin.cons c ((if c=b then Equiv.swap u v else 1) w) : Card (d+1))=_
by_cases hc : c=b
· subst c
simp only [↓reduceIte]
rw [Equiv.swap_apply_def]
split_ifs with h₁ h₂
· subst w; simp
· subst w; simp
· rw [Equiv.swap_apply_of_ne_of_ne]
· exact fun h => h₁ (by simpa using congrArg Fin.tail h)
· exact fun h => h₂ (by simpa using congrArg Fin.tail h)
· rw [ite_eq_right hc,Equiv.Perm.one_apply,Equiv.swap_apply_of_ne_of_ne]
· intro h; exact hc (by simpa using congrArg (fun z => z 0) h)
· intro h; exact hc (by simpa using congrArg (fun z => z 0) h)
lemma pairSwitch_single (d : ℕ) (u : Card d) :
pairSwitch (fun v => decide (v=u))=Equiv.swap (Fin.cons false u) (Fin.cons true u) := by
apply Equiv.ext
intro x
obtain ⟨c,w,rfl⟩ : ∃ c w, x=Fin.cons c w := ⟨x 0,Fin.tail x,(Fin.cons_self_tail x).symm⟩
change switchFun (fun v => decide (v=u)) (Fin.cons c w)=_
by_cases h : w=u
· subst w
cases c <;> simp [switchFun]
· have ha : (Fin.cons c w : Card (d+1))≠Fin.cons false u := fun he => h (by simpa using congrArg Fin.tail he)
have hb : (Fin.cons c w : Card (d+1))≠Fin.cons true u := fun he => h (by simpa using congrArg Fin.tail he)
simp [switchFun,h,Equiv.swap_apply_of_ne_of_ne ha hb]
/-- Every genuine butterfly outcome generates the full symmetric group. -/
theorem butterfly_generates (d : ℕ) (H : Subgroup (Equiv.Perm (Card d)))
(hH : ∀ ω : Butterfly d, butterflyPerm d ω∈H) : H=⊤ := by
induction d with
| zero =>
apply top_unique
intro p _
have hp : p=1 := Subsingleton.elim _ _
rw [hp]
exact H.one_mem
| succ d ih =>
have hchild (b : Bool) (p : Equiv.Perm (Card d)) : childInjection d b p∈H := by
have hc : H.comap (childInjection d b)=⊤ := by
apply ih
intro ω
change childLift (fun c => if c=b then butterflyPerm d ω else 1)∈H
have h := hH ((fun _ => false),fun c => if c=b then ω else butterflyIdentity d)
simpa only [butterflyPerm,pairSwitch_false,one_mul,apply_ite,butterflyIdentity_perm] using h
have hp : p∈H.comap (childInjection d b) := by rw [hc]; trivial
exact hp
have hpair (u : Card d) : Equiv.swap (Fin.cons false u) (Fin.cons true u)∈H := by
rw [←pairSwitch_single]
have h := hH ((fun v => decide (v=u)),fun _ => butterflyIdentity d)
simpa only [butterflyPerm,butterflyIdentity_perm,childLift_one,mul_one] using h
have hswap (x y : Card (d+1)) : Equiv.swap x y∈H := by
have ht (a b : Bool) (u : Card d) : Equiv.swap (Fin.cons a u) (Fin.cons b u)∈H := by
cases a <;> cases b
· rw [Equiv.swap_self]; exact H.one_mem
· exact hpair _
· rw [Equiv.swap_comm]; exact hpair _
· rw [Equiv.swap_self]; exact H.one_mem
have h₁ : Equiv.swap x (Fin.cons (y 0) (Fin.tail x))∈H := by
convert ht (x 0) (y 0) (Fin.tail x) using 1
rw [Fin.cons_self_tail]
have h₂ := hchild (y 0) (Equiv.swap (Fin.tail x) (Fin.tail y))
rw [childInjection_swap,Fin.cons_self_tail] at h₂
exact SubmonoidClass.swap_mem_trans H h₁ h₂
rw [eq_top_iff,←Equiv.Perm.closure_isSwap,Subgroup.closure_le]
rintro _ ⟨x,y,_,rfl⟩
exact hswap x y
lemma butterfly_closure (d : ℕ) : Subgroup.closure (Set.range (butterflyPerm d))=⊤ :=
butterfly_generates d _ (fun ω => Subgroup.subset_closure ⟨ω,rfl⟩)
end CubeShuffle
namespace CubeShuffle
open scoped BigOperators Classical
lemma palindrome_identity (d : ℕ) : ∃ ω,palindromePerm d ω=1 := by
refine ⟨((butterflyCoinEquiv d).symm (butterflyIdentity d),
(butterflyCoinEquiv d).symm (butterflyIdentity d)),?_⟩
exact mul_inv_cancel _
lemma palindrome_range_contains_butterfly (d : ℕ) (ω : Butterfly d) :
∃ ξ,palindromePerm d ξ=butterflyPerm d ω := by
refine ⟨((butterflyCoinEquiv d).symm ω,(butterflyCoinEquiv d).symm (butterflyIdentity d)),?_⟩
unfold palindromePerm
have h (β : Butterfly d) : decodeButterfly d ((butterflyCoinEquiv d).symm β)=β :=
(butterflyCoinEquiv d).apply_symm_apply β
rw [h,h,butterflyIdentity_perm,show (1 : Equiv.Perm (Card d)).symm=1 from rfl,mul_one]
lemma palindrome_support_generates (d : ℕ) :
Subgroup.closure {g | 0<sampleLaw (palindromePerm d) g}=⊤ := by
apply butterfly_generates
intro ω
apply Subgroup.subset_closure
exact (sampleLaw_pos_iff _ _).mpr (palindrome_range_contains_butterfly d ω)
noncomputable def palindromeMinorant (d : ℕ) :
FiniteConvolution.Minorant (sampleLaw (palindromePerm d)) :=
FiniteConvolution.minorant (sampleLaw_nonneg _) (sampleLaw_sum _)
((sampleLaw_pos_iff _ _).mpr (palindrome_identity d)) (palindrome_support_generates d)
noncomputable def blockGap (d : ℕ) : ℝ := UnitaryFinite.minorantGap (palindromeMinorant d)
lemma blockGap_pos (d : ℕ) : 0<blockGap d := UnitaryFinite.minorantGap_pos _
lemma blockGap_lt_one (d : ℕ) : blockGap d<1 := UnitaryFinite.minorantGap_lt_one _
/-- Strict fixed-size palindrome contraction is derived from its actual coins,
not assumed, and is uniform in the represented space. -/
theorem palindrome_off_invariants_gap (d : ℕ) {V : Type*}
[NormedAddCommGroup V] [InnerProductSpace ℂ V] [FiniteDimensional ℂ V]
(ρ : Representation ℂ (Equiv.Perm (Card d)) V) (hρ : UnitaryFinite.IsUnitary ρ) :
‖UnitaryFinite.weightedOperator ρ (sampleLaw (palindromePerm d))-
UnitaryFinite.uniformOperator ρ‖≤blockGap d := by
apply UnitaryFinite.norm_off_invariants_le_gap ρ hρ _ (sampleLaw_sum _)
apply sampleLaw_symmetric _ (Equiv.prodComm _ _)
intro ω
simp only [palindromePerm,mul_inv_rev]
rfl
end CubeShuffle
end OAI
|