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