| import OAI.Computability.FourierCircuit.MultiWord |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Packing |
| variable {τ : Type} {D : τ→Type} [∀ t,Fintype (D t)] [∀ t,DecidableEq (D t)] |
| {A : ∀ t,Matrix (D t) (D t) ℂ} |
| {α : Type} [Fintype α] [DecidableEq α] |
|
|
| def scheduledStep (W : Word D A α) {T : ℕ} (time : Fin W.length→Fin T) : Fin T→Step D A α := |
| Function.extend time W.get (fun _=>.mono 1 MonomialMatrix.one) |
|
|
| theorem scheduledStep_matrix (W : Word D A α) {T : ℕ} (time : Fin W.length→Fin T) |
| (hinj : Function.Injective time) (t : Fin T) : |
| (scheduledStep W time t).matrix=Function.extend time (fun i=>(W.get i).matrix) (fun _=>1) t := by |
| classical |
| by_cases h : ∃ i,time i=t |
| · obtain ⟨i,rfl⟩ := h |
| simp only [scheduledStep,hinj.extend_apply] |
| · simp [scheduledStep,Function.extend_apply' _ _ _ h,Step.matrix] |
|
|
| theorem scheduledStep_product (W : Word D A α) {T : ℕ} (time : Fin W.length→Fin T) |
| (ht : StrictMono time) : |
| (List.ofFn (fun t=>(scheduledStep W time t).matrix)).prod=W.matrix := by |
| simp_rw [scheduledStep_matrix W time ht.injective] |
| rw [ordered_padding time ht] |
| change (List.ofFn (Step.matrix∘W.get)).prod=(W.map Step.matrix).prod |
| rw [← List.map_ofFn] |
| simp |
|
|
| variable {π : Type} [Fintype π] [DecidableEq π] |
| {β : π→Type} [∀ p,Fintype (β p)] [∀ p,DecidableEq (β p)] |
|
|
| def scheduledLayer (W : ∀ p,Word D A (β p)) {T : ℕ} |
| (time : ∀ p,Fin (W p).length→Fin T) (t : Fin T) : Matrix (Σ p,β p) (Σ p,β p) ℂ := |
| Matrix.blockDiagonal' (fun p=>(scheduledStep (W p) (time p) t).matrix) |
|
|
| /-- Schedule correctness on fixed, disjoint physical supports, including every monomial. -/ |
| theorem scheduledLayer_product (W : ∀ p,Word D A (β p)) {T : ℕ} |
| (time : ∀ p,Fin (W p).length→Fin T) (ht : ∀ p,StrictMono (time p)) : |
| (List.ofFn (scheduledLayer W time)).prod=Matrix.blockDiagonal' (fun p=>(W p).matrix) := by |
| let φ := Matrix.blockDiagonal'RingHom (m' := β) (α := ℂ) |
| let f := fun t p=>(scheduledStep (W p) (time p) t).matrix |
| change (List.ofFn (φ∘f)).prod=φ (fun p=>(W p).matrix) |
| rw [← List.map_ofFn,← map_list_prod] |
| congr 1 |
| funext p |
| have he := map_list_prod (Pi.evalMonoidHom (fun p=>Matrix (β p) (β p) ℂ) p) (List.ofFn f) |
| rw [List.map_ofFn] at he |
| change (List.ofFn f).prod p=(List.ofFn (fun t=>f t p)).prod at he |
| rw [he] |
| exact scheduledStep_product (W p) (time p) (ht p) |
|
|
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Packing |
| variable {τ σ : Type} |
| {D : τ→Type} [∀ t,Fintype (D t)] [∀ t,DecidableEq (D t)] |
| {A : ∀ t,Matrix (D t) (D t) ℂ} |
| {E : σ→Type} [∀ t,Fintype (E t)] [∀ t,DecidableEq (E t)] |
| {B : ∀ t,Matrix (E t) (E t) ℂ} |
| {α : Type} [Fintype α] [DecidableEq α] |
|
|
| def Word.substitute (V : ∀ t,Word E B (D t)) : Word D A α→Word E B α |
| | [] => [] |
| | .mono M h::W => .mono M h::Word.substitute V W |
| | .call t e::W => (V t).embed e++Word.substitute V W |
|
|
| @[simp] theorem Word.matrix_substitute (V : ∀ t,Word E B (D t)) |
| (hV : ∀ t,(V t).matrix=A t) (W : Word D A α) : (W.substitute V).matrix=W.matrix := by |
| induction W with |
| | nil => rfl |
| | cons s W ih => |
| cases s with |
| | mono M h => simp only [Word.substitute,Word.matrix_cons,ih,Step.matrix] |
| | call t e => simp only [Word.substitute,Word.matrix_append,Word.matrix_embed,hV,ih,Word.matrix_cons,Step.matrix] |
|
|
| def Word.weight (p : τ→ℝ) (W : Word D A α) : ℝ := (W.calls.map p).sum |
|
|
| @[simp] theorem Word.weight_nil (p : τ→ℝ) : Word.weight p ([] : Word D A α)=0 := rfl |
| @[simp] theorem Word.weight_cons_mono (p : τ→ℝ) (M : Matrix α α ℂ) (h : MonomialMatrix M) (W : Word D A α) : |
| Word.weight p (.mono M h::W)=W.weight p := rfl |
| @[simp] theorem Word.weight_cons_call (p : τ→ℝ) (t : τ) (e : D t ↪ α) (W : Word D A α) : |
| Word.weight p (.call t e::W)=p t+W.weight p := rfl |
| @[simp] theorem Word.weight_append (p : τ→ℝ) (W V : Word D A α) : |
| (W++V).weight p=W.weight p+V.weight p := by simp [Word.weight] |
| @[simp] theorem Word.weight_embed {β : Type} [Fintype β] [DecidableEq β] |
| (p : τ→ℝ) (e : α ↪ β) (W : Word D A α) : (W.embed e).weight p=W.weight p := by simp [Word.weight] |
| @[simp] theorem Word.weight_reindex {β : Type} [Fintype β] [DecidableEq β] |
| (p : τ→ℝ) (e : α≃β) (W : Word D A α) : (W.reindex e).weight p=W.weight p := by |
| simp [Word.weight,Word.reindex] |
|
|
| @[simp] theorem Word.weight_substitute (V : ∀ t,Word E B (D t)) (p : σ→ℝ) (W : Word D A α) : |
| (W.substitute V).weight p=W.weight (fun t=>(V t).weight p) := by |
| induction W with |
| | nil => rfl |
| | cons s W ih => |
| cases s with |
| | mono M h => simpa only [Word.substitute,Word.weight_cons_mono] using ih |
| | call t e => simp only [Word.substitute,Word.weight_append,Word.weight_embed,ih,Word.weight_cons_call] |
|
|
| theorem Word.weight_count [Fintype τ] [DecidableEq τ] (p : τ→ℝ) (W : Word D A α) : |
| W.weight p=∑ t,(W.count t : ℝ)*p t := by |
| induction W with |
| | nil => simp [Word.weight,Word.count,Word.calls] |
| | cons s W ih => |
| cases s with |
| | mono M h => |
| change Word.weight p W=∑ t : τ,(Word.count W t : ℝ)*p t |
| exact ih |
| | call t e => |
| rw [Word.weight_cons_call,ih] |
| simp only [Word.count,Word.calls,List.filterMap_cons,Step.kind,List.count_eq_countP, |
| List.countP_cons,Nat.cast_add,Nat.cast_ite,Nat.cast_one,Nat.cast_zero,add_mul,Finset.sum_add_distrib] |
| simp [mul_comm,add_comm] |
|
|
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.MonomialMatrix |
| variable {α : Type} [Fintype α] [DecidableEq α] |
|
|
| theorem inverse {A : Matrix α α ℂ} (hA : MonomialMatrix A) : MonomialMatrix A⁻¹ := by |
| obtain ⟨s,d,hd,hs⟩ := hA |
| let B : Matrix α α ℂ := fun i j=>if i=s.symm j then (d (s.symm j))⁻¹ else 0 |
| have hB : MonomialMatrix B := ⟨s.symm,fun j=>(d (s.symm j))⁻¹,fun j=>inv_ne_zero (hd _),fun _ _=>rfl⟩ |
| have he : A*B=1 := by |
| ext i j |
| rw [Matrix.mul_apply] |
| simp only [B,mul_ite,mul_zero,Finset.sum_ite_eq',Finset.mem_univ,ite_true,hs,s.apply_symm_apply] |
| by_cases h : i=j |
| · subst j; simp [hd] |
| · simp [h] |
| rw [Matrix.inv_eq_right_inv he] |
| exact hB |
|
|
| /-- A unit square submatrix of a monomial matrix is monomial. -/ |
| theorem submatrix_unit {β : Type} [Fintype β] [DecidableEq β] |
| {B : Matrix β β ℂ} (hB : MonomialMatrix B) (e f : α ↪ β) |
| (hA : IsUnit (B.submatrix e f)) : MonomialMatrix (B.submatrix e f) := by |
| let A := B.submatrix e f |
| have hi := Matrix.nonsing_inv_mul A ((Matrix.isUnit_iff_isUnit_det A).mp hA) |
| have hc : ∀ k,∃ i,A⁻¹ k i*A i k≠0 := by |
| intro k |
| have he := congrArg (fun M : Matrix α α ℂ=>M k k) hi |
| simp only [Matrix.mul_apply,Matrix.one_apply,ite_true] at he |
| by_contra hn |
| push Not at hn |
| rw [Finset.sum_eq_zero (fun i _=>hn i)] at he |
| exact zero_ne_one he |
| choose σ hσ using hc |
| have hc₁ : ∀ k,A⁻¹ k (σ k)≠0 := fun k=>(mul_ne_zero_iff.mp (hσ k)).1 |
| have hc₂ : ∀ k,A (σ k) k≠0 := fun k=>(mul_ne_zero_iff.mp (hσ k)).2 |
| obtain ⟨s,d,hd,hs⟩ := hB |
| have hz : ∀ k i,i≠σ k → A i k=0 := by |
| intro k i hik |
| have he : e (σ k)=s (f k) := by |
| by_contra h |
| exact hc₂ k (by simp [A,Matrix.submatrix_apply,hs,h]) |
| have hn : e i≠s (f k) := by intro hh; exact hik (e.injective (hh.trans he.symm)) |
| simp [A,Matrix.submatrix_apply,hs,hn] |
| have hinj : Function.Injective σ := by |
| intro k l hkl |
| by_contra hne |
| have hh := congrArg (fun M : Matrix α α ℂ=>M k l) hi |
| simp only [Matrix.mul_apply,Matrix.one_apply,ite_eq_right hne] at hh |
| have hsum : (∑ i,A⁻¹ k i*A i l)=A⁻¹ k (σ l)*A (σ l) l := by |
| apply Finset.sum_eq_single (σ l) |
| · intro i _ hne; rw [hz l i hne,mul_zero] |
| · simp |
| rw [hsum] at hh |
| apply mul_ne_zero (hc₁ k) (hc₂ l) |
| simpa only [hkl] using hh |
| let g : Equiv.Perm α := Equiv.ofBijective σ ⟨hinj,Finite.surjective_of_injective hinj⟩ |
| refine ⟨g,fun k=>A (σ k) k,hc₂,?_⟩ |
| intro i k |
| change A i k=if i=σ k then A (σ k) k else 0 |
| split_ifs with h |
| · subst i; rfl |
| · exact hz k i h |
|
|
| end ExactFourier.MonomialMatrix |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Packing |
| variable {τ : Type} |
| {D : τ→Type} [∀ t,Fintype (D t)] [∀ t,DecidableEq (D t)] |
| {A : ∀ t,Matrix (D t) (D t) ℂ} |
| {α : Type} [Fintype α] [DecidableEq α] |
|
|
| theorem pattern_from_word (V : Word D A α) {H : Matrix α α ℂ} {h : ℕ} |
| (hp : PositiveGeneration.Pattern V.matrix h H) : |
| ∃ W : Word D A α,W.matrix=H ∧ ∀ p : τ→ℝ,W.weight p=(h : ℝ)*V.weight p := by |
| induction hp with |
| | zero M hm => exact ⟨monoWord M hm,by simp,fun p=>by simp [Word.weight]⟩ |
| | @succ h H hp M hm ih => |
| obtain ⟨W,hW,hp⟩ := ih |
| refine ⟨W++V++monoWord M hm,by simp [hW,mul_assoc],?_⟩ |
| intro p |
| rw [Word.weight_append,Word.weight_append,hp] |
| change (h : ℝ)*V.weight p+V.weight p+0=_ |
| push_cast |
| ring |
|
|
| theorem word_generates (V : Word D A α) (hu : IsUnit V.matrix) (hn : ¬MonomialMatrix V.matrix) |
| (H : Matrix α α ℂ) (hH : IsUnit H) : |
| ∃ h : ℕ,0<h ∧ ∃ W : Word D A α,W.matrix=H ∧ ∀ p : τ→ℝ,W.weight p=(h : ℝ)*V.weight p := by |
| obtain ⟨h,hh,hg⟩ := PositiveGeneration.positive_generation V.matrix hu hn |
| exact ⟨h,hh,pattern_from_word V (hg H hH)⟩ |
|
|
| theorem monomial_of_subsingleton [Subsingleton α] (H : Matrix α α ℂ) (hH : IsUnit H) : MonomialMatrix H := by |
| have he : H=Matrix.diagonal (fun i=>H i i) := by |
| ext i j |
| have h : i=j := Subsingleton.elim _ _ |
| subst j |
| simp |
| have hu : ∀ i,H i i≠0 := by |
| rw [he] at hH |
| have hh := Pi.isUnit_iff.mp (Matrix.isUnit_diagonal.mp hH) |
| intro i |
| exact isUnit_iff_ne_zero.mp (hh i) |
| rw [he] |
| exact MonomialMatrix.diagonal _ hu |
|
|
| def shearU : Matrix (Fin 2) (Fin 2) ℂ := Matrix.transvection 1 0 1 |
|
|
| theorem shearU_unit : IsUnit shearU := MatrixPrice.transvection_isUnit 1 0 (by decide) 1 |
|
|
| theorem shearU_not_monomial : ¬MonomialMatrix shearU := by |
| rintro ⟨s,d,hd,hs⟩ |
| have h0 : (0 : Fin 2)=s 0 := by |
| by_contra h |
| have hh := hs 0 0 |
| simp [shearU,Matrix.transvection,h] at hh |
| have h1 : (1 : Fin 2)=s 0 := by |
| by_contra h |
| have hh := hs 1 0 |
| simp [shearU,Matrix.transvection,h] at hh |
| have hh : (0 : Fin 2)=1 := h0.trans h1.symm |
| exact (by decide : (0 : Fin 2)≠1) hh |
|
|
| theorem shear_word_exists (u : τ) (eu : D u≃Fin 2) |
| (hAu : Matrix.reindex eu eu (A u)=shearU) |
| (H : Matrix α α ℂ) (hH : IsUnit H) : |
| ∃ C : ℕ,∃ W : Word D A α,W.matrix=H ∧ ∀ p : τ→ℝ,W.weight p=(C : ℝ)*p u := by |
| classical |
| by_cases hc : 2≤Fintype.card α |
| · let e : D u ↪ α := eu.toEmbedding.trans |
| ((Fin.castLEEmb hc).trans (Fintype.equivFin α).symm.toEmbedding) |
| let V : Word D A α := callWord u e |
| have hu : IsUnit (A u) := by |
| have hh := TensorTools.unit_reindex eu.symm _ shearU_unit |
| rw [← hAu] at hh |
| convert hh using 1 |
| ext i j |
| simp [Matrix.reindex_apply] |
| have hn : ¬MonomialMatrix (A u) := by |
| intro hh; exact shearU_not_monomial (hAu ▸ hh.reindex eu) |
| have hV : V.matrix=Embedded.matrix e (A u) := matrix_callWord u e |
| have hVm : ¬MonomialMatrix V.matrix := by |
| intro hh |
| rw [hV] at hh |
| have he : (Embedded.matrix e (A u)).submatrix e e=A u := by |
| ext i j; exact Embedded.matrix_on e _ i j |
| apply hn |
| rw [← he] |
| exact hh.submatrix_unit e e (he.symm ▸ hu) |
| obtain ⟨h,hh,W,hm,hp⟩ := word_generates V (hV.symm ▸ Embedded.unit e _ hu) hVm H hH |
| exact ⟨h,W,hm,fun p=>by simpa [V,Word.weight] using hp p⟩ |
| · have hcard : Fintype.card α≤1 := by omega |
| let : Subsingleton α := Fintype.card_le_one_iff_subsingleton.mp hcard |
| have hm := monomial_of_subsingleton H hH |
| exact ⟨0,monoWord H hm,by simp,fun p=>by simp [Word.weight]⟩ |
|
|
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| section |
| namespace ExactFourier |
| variable {α β γ δ : Type} [Fintype α] [Fintype β] [Fintype γ] [Fintype δ] |
| [DecidableEq α] [DecidableEq β] [DecidableEq γ] [DecidableEq δ] |
|
|
| theorem reindex_comp |
| {α : Type} {β : Type} {γ : Type} [Fintype α] [Fintype β] [Fintype γ] [DecidableEq α] [DecidableEq β] [DecidableEq γ] (e : α≃β) (f : β≃γ) (M : Matrix α α ℂ) : |
| Matrix.reindex f f (Matrix.reindex e e M)=Matrix.reindex (e.trans f) (e.trans f) M := rfl |
|
|
| theorem reindex_sum |
| {α : Type} {β : Type} {γ : Type} {δ : Type} [Fintype α] [Fintype β] [Fintype γ] [Fintype δ] [DecidableEq α] [DecidableEq β] [DecidableEq γ] [DecidableEq δ] (e : α≃β) (f : γ≃δ) (M : Matrix α α ℂ) (N : Matrix γ γ ℂ) : |
| Matrix.reindex (e.sumCongr f) (e.sumCongr f) (Matrix.fromBlocks M 0 0 N)= |
| Matrix.fromBlocks (Matrix.reindex e e M) 0 0 (Matrix.reindex f f N) := by |
| ext x y |
| cases x <;> cases y <;> rfl |
|
|
| theorem reindex_tensor |
| {α : Type} {β : Type} {γ : Type} {δ : Type} [Fintype α] [Fintype β] [Fintype γ] [Fintype δ] [DecidableEq α] [DecidableEq β] [DecidableEq γ] [DecidableEq δ] (e : α≃β) (f : γ≃δ) (M : Matrix α α ℂ) (N : Matrix γ γ ℂ) : |
| Matrix.reindex (e.prodCongr f) (e.prodCongr f) (Matrix.kronecker M N)= |
| Matrix.kronecker (Matrix.reindex e e M) (Matrix.reindex f f N) := by |
| ext x y |
| rfl |
|
|
| theorem reindex_inverse |
| {α : Type} {β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] (e : α≃β) (M : Matrix α α ℂ) : |
| Matrix.reindex e.symm e.symm (Matrix.reindex e e M)=M := by |
| ext i j; simp [Matrix.reindex_apply] |
| end ExactFourier |
|
|
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier |
| namespace Embedded |
| variable {α β γ : Type} [Fintype α] [Fintype β] [Fintype γ] |
| [DecidableEq α] [DecidableEq β] [DecidableEq γ] |
| theorem matrix_domain (e : α≃β) (f : α ↪ γ) (M : Matrix α α ℂ) : |
| matrix (e.symm.toEmbedding.trans f) (Matrix.reindex e e M)=matrix f M := by |
| classical |
| ext i j |
| by_cases hi : ∃ a,f a=i |
| · obtain ⟨a,rfl⟩ := hi |
| by_cases hj : ∃ b,f b=j |
| · obtain ⟨b,rfl⟩ := hj |
| have ha : (e.symm.toEmbedding.trans f) (e a)=f a := by simp |
| have hb : (e.symm.toEmbedding.trans f) (e b)=f b := by simp |
| rw [← ha,← hb,matrix_on] |
| simp only [ha,hb,matrix_on,Matrix.reindex_apply,Matrix.submatrix_apply,Equiv.symm_apply_apply] |
| · have hj' : ¬∃ b,(e.symm.toEmbedding.trans f) b=j := by |
| rintro ⟨b,hb⟩; exact hj ⟨e.symm b,hb⟩ |
| rw [matrix_off_col _ _ _ _ hj',matrix_off_col _ _ _ _ hj] |
| · have hi' : ¬∃ a,(e.symm.toEmbedding.trans f) a=i := by |
| rintro ⟨a,ha⟩; exact hi ⟨e.symm a,ha⟩ |
| rw [matrix_off_row _ _ _ _ hi',matrix_off_row _ _ _ _ hi] |
| end Embedded |
| namespace Packing |
| variable {τ σ : Type} |
| {D : τ→Type} [∀ t,Fintype (D t)] [∀ t,DecidableEq (D t)] |
| {A : ∀ t,Matrix (D t) (D t) ℂ} |
| {E : σ→Type} [∀ t,Fintype (E t)] [∀ t,DecidableEq (E t)] |
| {B : ∀ t,Matrix (E t) (E t) ℂ} |
| {α : Type} [Fintype α] [DecidableEq α] |
|
|
| def Step.rename (f : τ→σ) (e : ∀ t,D t≃E (f t)) : Step D A α→Step E B α |
| | .mono M h => .mono M h |
| | .call t a => .call (f t) ((e t).symm.toEmbedding.trans a) |
| def Word.rename (f : τ→σ) (e : ∀ t,D t≃E (f t)) (W : Word D A α) : Word E B α := |
| W.map (Step.rename f e) |
| theorem Word.matrix_rename (f : τ→σ) (e : ∀ t,D t≃E (f t)) |
| (he : ∀ t,Matrix.reindex (e t) (e t) (A t)=B (f t)) (W : Word D A α) : |
| (W.rename (B := B) f e).matrix=W.matrix := by |
| induction W with |
| | nil => rfl |
| | cons s W ih => |
| simp only [Word.rename,List.map_cons,Word.matrix_cons] |
| rw [← Word.rename,ih] |
| congr 1 |
| cases s with |
| | mono M h => rfl |
| | call t a => |
| change Embedded.matrix _ (B (f t))=Embedded.matrix a (A t) |
| rw [← he t,Embedded.matrix_domain] |
| @[simp] theorem Word.weight_rename (f : τ→σ) (e : ∀ t,D t≃E (f t)) |
| (p : σ→ℝ) (W : Word D A α) : (W.rename (B := B) f e).weight p=W.weight (p∘f) := by |
| induction W with |
| | nil => rfl |
| | cons s W ih => |
| cases s with |
| | mono M h => simpa only [Word.rename,List.map_cons,Step.rename,Word.weight_cons_mono] using ih |
| | call t a => simpa only [Word.rename,List.map_cons,Step.rename,Word.weight_cons_call,Function.comp_apply] using congrArg (fun x=>p (f t)+x) ih |
| end Packing |
| end ExactFourier |
|
|
| end |
| end |
|
|
| end OAI |
|
|
