File size: 6,132 Bytes
9b6e014 | 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 | import Mathlib
import OAI.Probability.BinarySweep.Representations.FiniteUnitaryAverage
namespace OAI
noncomputable section
section
open scoped BigOperators Classical
namespace BinaryCoordinateSweeps
lemma independent_reverse_product {R : Type*} [Semiring R] {n : ℕ}
{X : Fin n → Type*} [∀j, Fintype (X j)] (A : (j : Fin n) → X j → R) :
(List.ofFn (fun j => ∑a, A j a)).reverse.prod=
∑f : ∀j, X j, (List.ofFn (fun j => A j (f j))).reverse.prod := by
induction n with
| zero => simp
| succ n ih =>
rw [List.ofFn_succ,List.reverse_cons,List.prod_append,List.prod_singleton,ih]
rw [←Equiv.sum_comp (Fin.consEquiv X),Fintype.sum_prod_type]
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro a _
rw [Finset.sum_mul]
apply Finset.sum_congr rfl
intro f _
simp only [Fin.consEquiv,Equiv.coe_fn_mk,List.ofFn_succ,List.reverse_cons,
List.prod_append,List.prod_singleton,Fin.cons_zero,Fin.cons_succ]
lemma weighted_reverse_product {R : Type*} [Semiring R] [Algebra ℂ R] {n : ℕ}
(w : Fin n → ℂ) (A : Fin n → R) :
(List.ofFn (fun j => w j • A j)).reverse.prod=
(∏j,w j) • (List.ofFn A).reverse.prod := by
induction n with
| zero => simp
| succ n ih =>
simp only [List.ofFn_succ,List.reverse_cons,List.prod_append,List.prod_singleton,
Fin.prod_univ_succ]
rw [ih,smul_mul_smul_comm,mul_comm (∏j : Fin n, w j.succ) (w 0)]
lemma independent_average_product {R : Type*} [Semiring R] [Algebra ℂ R] {n : ℕ}
{X : Fin n → Type*} [∀j, Fintype (X j)]
(w : (j : Fin n) → X j → ℂ) (A : (j : Fin n) → X j → R) :
(∑f : ∀j, X j, (∏j,w j (f j)) •
(List.ofFn (fun j => A j (f j))).reverse.prod)=
(List.ofFn (fun j => ∑a, w j a • A j a)).reverse.prod := by
rw [independent_reverse_product]
exact Finset.sum_congr rfl (fun f _ => (weighted_reverse_product _ _).symm)
lemma reverse_product_norm_le_one {R : Type*} [NormedRing R] [NormOneClass R]
{n : ℕ} (A : Fin n → R) (hA : ∀j, ‖A j‖≤1) :
‖(List.ofFn A).reverse.prod‖≤1 := by
induction n with
| zero => simp
| succ n ih =>
simp only [List.ofFn_succ,List.reverse_cons,List.prod_append,List.prod_singleton]
exact (norm_mul_le _ _).trans ((mul_le_of_le_one_left (norm_nonneg _)
(ih _ (fun index => hA index.succ))).trans (hA 0))
end BinaryCoordinateSweeps
end
open scoped BigOperators Classical
namespace BinaryCoordinateSweeps
lemma pi_single_reverse {I G : Type*} [Fintype I] [DecidableEq I] [Group G]
(f : I → G) (e : Fin (Fintype.card I) ≃ I) :
(List.ofFn (fun j => Pi.mulSingle (e j) (f (e j)))).reverse.prod=f := by
funext i
have hh := List.prod_map_eq_pow_single (e.symm i)
(fun j => (Pi.mulSingle (e j) (f (e j)) : I → G) i)
(l := (List.ofFn (fun j : Fin (Fintype.card I) => j)).reverse) (by
intro j hj _
have hne : i ≠ e j := by
intro he
apply hj
exact e.injective (he.symm.trans (e.apply_symm_apply i).symm)
simp [Pi.mulSingle,hne])
have hc : ((List.ofFn (fun j : Fin (Fintype.card I) => j)).reverse).count (e.symm i)=1 := by
apply List.count_eq_one_of_mem
· exact List.nodup_reverse.mpr (List.nodup_ofFn.mpr Function.injective_id)
· simp
rw [hc,pow_one,e.apply_symm_apply,Pi.mulSingle_eq_same] at hh
simp only [List.map_reverse,List.map_ofFn,Function.comp_def] at hh
change (Pi.evalMonoidHom (fun _ : I => G) i)
((List.ofFn (fun j => Pi.mulSingle (e j) (f (e j)))).reverse.prod)=f i
rw [map_list_prod,List.map_reverse,List.map_ofFn]
exact hh
variable {G V : Type*} [Group G] [Fintype G]
[NormedAddCommGroup V] [InnerProductSpace ℂ V] [FiniteDimensional ℂ V]
def continuousRep (ρ : Representation ℂ G V) : G →* (V →L[ℂ] V) where
toFun g := (ρ g).toContinuousLinearMap
map_one' := by ext v; simp
map_mul' g h := by ext v; simp
lemma complexAverage_sum (ρ : Representation ℂ G V) (p : G → ℂ) :
complexAverage ρ p=∑g,p g • continuousRep ρ g := by
ext v
simp [complexAverage_apply,continuousRep]
theorem pi_average_norm_le_one {I : Type*} [Fintype I] [DecidableEq I] [DecidableEq G] [Nontrivial V]
(ρ : Representation ℂ (I → G) V) (p : I → G → ℂ)
(h : ∀i, ‖complexAverage (ρ.comp (MonoidHom.mulSingle (fun _ : I => G) i)) (p i)‖≤1) :
‖complexAverage ρ (fun f => ∏i,p i (f i))‖≤1 := by
let e : Fin (Fintype.card I) ≃ I := (Fintype.equivFin I).symm
let E : (Fin (Fintype.card I) → G) ≃ (I → G) := Equiv.piCongrLeft (fun _ => G) e
have he (f : Fin (Fintype.card I) → G) : ∀j, E f (e j)=f j := by
intro j; simp [E,Equiv.piCongrLeft]
have hf : complexAverage ρ (fun f => ∏i,p i (f i))=
(List.ofFn (fun j => complexAverage
(ρ.comp (MonoidHom.mulSingle (fun _ : I => G) (e j))) (p (e j)))).reverse.prod := by
rw [complexAverage_sum,←Equiv.sum_comp E]
simp_rw [←e.prod_comp (fun i => p i (E _ i))]
have ht (f : Fin (Fintype.card I) → G) : continuousRep ρ (E f)=
(List.ofFn (fun j => continuousRep ρ (Pi.mulSingle (e j) (f j)))).reverse.prod := by
rw [←pi_single_reverse (E f) e,map_list_prod,List.map_reverse,List.map_ofFn]
simp only [Function.comp_def,he]
simp_rw [ht,he]
rw [independent_average_product (X := fun _ => G)
(fun j a => p (e j) a) (fun j a => continuousRep ρ (Pi.mulSingle (e j) a))]
congr 3
funext j
rw [complexAverage_sum]
rfl
rw [hf]
exact reverse_product_norm_le_one _ (fun j => h (e j))
lemma pi_comp_average_norm_le_one {I H : Type*} [Fintype I] [DecidableEq I] [DecidableEq G] [Group H] [Fintype H]
[Nontrivial V] (ρ : Representation ℂ H V) (φ : (I → G) →* H)
(p : G → ℂ) (hρ : ∀g v, ‖ρ g v‖=‖v‖)
(hp : ∀σ : Representation ℂ G V, (∀g v, ‖σ g v‖=‖v‖) →
‖complexAverage σ p‖≤1) :
‖complexAverage (ρ.comp φ) (fun f => ∏i,p (f i))‖≤1 := by
apply pi_average_norm_le_one
intro i
apply hp
exact fun g v => hρ _ v
end BinaryCoordinateSweeps
end
end OAI
|