| import OAI.Computability.FourierCircuit.ParameterAlgebra |
|
|
| 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) ℂ) |
|
|
| inductive Step (D : τ→Type) [∀ t,Fintype (D t)] [∀ t,DecidableEq (D t)] |
| (A : ∀ t,Matrix (D t) (D t) ℂ) (α : Type) [Fintype α] [DecidableEq α] where |
| | mono (M : Matrix α α ℂ) (hm : MonomialMatrix M) |
| | call (t : τ) (e : D t ↪ α) |
|
|
| variable {D A} {α β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] |
|
|
| def Step.matrix : Step D A α → Matrix α α ℂ |
| | .mono M _ => M |
| | .call t e => Embedded.matrix e (A t) |
|
|
| def Step.kind : Step D A α → Option τ |
| | .mono _ _ => none |
| | .call t _ => some t |
|
|
| def Step.embed (e : α ↪ β) : Step D A α → Step D A β |
| | .mono M hM => .mono (Embedded.matrix e M) (hM.embed e) |
| | .call t f => .call t (f.trans e) |
|
|
| @[simp] theorem Step.matrix_embed (e : α ↪ β) (s : Step D A α) : |
| (s.embed e).matrix=Embedded.matrix e s.matrix := by |
| cases s with |
| | mono M hM => rfl |
| | call t f => exact (Embedded.matrix_comp f e (A t)).symm |
|
|
| @[simp] theorem Step.kind_embed (e : α ↪ β) (s : Step D A α) : (s.embed e).kind=s.kind := by cases s <;> rfl |
|
|
| abbrev Word (D : τ→Type) [∀ t,Fintype (D t)] [∀ t,DecidableEq (D t)] |
| (A : ∀ t,Matrix (D t) (D t) ℂ) (α : Type) [Fintype α] [DecidableEq α] := List (Step D A α) |
|
|
| def Word.matrix (W : Word D A α) : Matrix α α ℂ := (W.map Step.matrix).prod |
|
|
| def Word.calls (W : Word D A α) : List τ := W.filterMap Step.kind |
|
|
| def Word.count [DecidableEq τ] (W : Word D A α) (t : τ) : ℕ := W.calls.count t |
|
|
| def Word.embed (e : α ↪ β) (W : Word D A α) : Word D A β := W.map (Step.embed e) |
|
|
| @[simp] theorem Word.matrix_nil : (Word.matrix ([] : Word D A α))=1 := rfl |
| @[simp] theorem Word.matrix_cons (s : Step D A α) (W : Word D A α) : |
| Word.matrix (s::W)=s.matrix*W.matrix := rfl |
| @[simp] theorem Word.matrix_append (W V : Word D A α) : (W++V).matrix=W.matrix*V.matrix := by |
| simp [Word.matrix,List.map_append,List.prod_append] |
| @[simp] theorem Word.calls_append (W V : Word D A α) : (W++V).calls=W.calls++V.calls := by |
| simp [Word.calls] |
| @[simp] theorem Word.count_append [DecidableEq τ] (W V : Word D A α) (t : τ) : |
| (W++V).count t=W.count t+V.count t := by simp [Word.count] |
|
|
| @[simp] theorem Word.matrix_embed (e : α ↪ β) (W : Word D A α) : |
| (W.embed e).matrix=Embedded.matrix e W.matrix := by |
| induction W with |
| | nil => simp [Word.embed] |
| | cons w W ih => |
| simp only [Word.embed,List.map_cons,Word.matrix_cons,Step.matrix_embed] |
| rw [← Word.embed,ih,← Embedded.matrix_mul] |
|
|
| @[simp] theorem Word.calls_embed (e : α ↪ β) (W : Word D A α) : (W.embed e).calls=W.calls := by |
| simp [Word.embed,Word.calls,List.filterMap_map] |
|
|
| @[simp] theorem Word.count_embed [DecidableEq τ] (e : α ↪ β) (W : Word D A α) (t : τ) : |
| (W.embed e).count t=W.count t := by simp [Word.count] |
|
|
| theorem Word.unit (hA : ∀ t,IsUnit (A t)) (W : Word D A α) : IsUnit W.matrix := by |
| induction W with |
| | nil => exact isUnit_one |
| | cons s W ih => |
| apply IsUnit.mul _ ih |
| cases s with |
| | mono M hm => exact hm.unit _ |
| | call t e => exact Embedded.unit e _ (hA t) |
|
|
| def monoWord (M : Matrix α α ℂ) (hm : MonomialMatrix M) : Word D A α := [.mono M hm] |
| def callWord (t : τ) (e : D t ↪ α) : Word D A α := [.call t e] |
| @[simp] theorem matrix_monoWord (M : Matrix α α ℂ) (hm : MonomialMatrix M) : |
| (monoWord (D := D) (A := A) M hm).matrix=M := by simp [monoWord,Word.matrix,Step.matrix] |
| @[simp] theorem matrix_callWord (t : τ) (e : D t ↪ α) : |
| (callWord (A := A) t e).matrix=Embedded.matrix e (A t) := by simp [callWord,Word.matrix,Step.matrix] |
| @[simp] theorem calls_monoWord (M : Matrix α α ℂ) (hm : MonomialMatrix M) : |
| (monoWord (D := D) (A := A) M hm).calls=[] := rfl |
| @[simp] theorem calls_callWord (t : τ) (e : D t ↪ α) : |
| (callWord (A := A) t e).calls=[t] := rfl |
|
|
| theorem pattern_word (t : τ) {H : Matrix (D t) (D t) ℂ} {k : ℕ} |
| (h : PositiveGeneration.Pattern (A t) k H) : |
| ∃ W : Word D A (D t),W.matrix=H ∧ W.calls=List.replicate k t := by |
| induction h with |
| | zero M hm => exact ⟨monoWord M hm,by simp,by simp⟩ |
| | @succ k H h M hm ih => |
| obtain ⟨W,hW,hcalls⟩ := ih |
| refine ⟨W++callWord t (Function.Embedding.refl _)++monoWord M hm,?_,?_⟩ |
| · rw [Word.matrix_append,Word.matrix_append,matrix_monoWord,matrix_callWord,hW] |
| have he : Embedded.matrix (Function.Embedding.refl (D t)) (A t)=A t := by |
| ext i j |
| exact Embedded.matrix_on (Function.Embedding.refl _) (A t) i j |
| rw [he] |
| · simp [hcalls,List.replicate_succ'] |
|
|
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Embedded |
| variable {π : Type} [Fintype π] [DecidableEq π] |
| {β : π→Type} [∀ i,Fintype (β i)] [∀ i,DecidableEq (β i)] |
|
|
| def sigmaIn (p : π) : β p ↪ (Σ p,β p) := ⟨Sigma.mk p,by intro a b h; exact eq_of_heq (Sigma.mk.inj_iff.mp h).2⟩ |
|
|
| theorem matrix_sigmaIn (A : ∀ p,Matrix (β p) (β p) ℂ) (p : π) : |
| matrix (sigmaIn p) (A p)=Matrix.blockDiagonal' (Function.update 1 p (A p)) := by |
| classical |
| ext ⟨i,a⟩ ⟨j,b⟩ |
| by_cases hi : i=p |
| · subst i |
| by_cases hj : j=p |
| · subst j |
| change matrix (sigmaIn p) (A p) (sigmaIn p a) (sigmaIn p b)=_ |
| rw [matrix_on] |
| simp |
| · rw [matrix_off_col] |
| · simp [Matrix.blockDiagonal'_apply,Ne.symm hj] |
| · rintro ⟨b',hb⟩; exact hj (congrArg Sigma.fst hb).symm |
| · rw [matrix_off_row] |
| · by_cases hij : i=j |
| · subst j; simp [Matrix.one_apply,hi] |
| · simp [Matrix.blockDiagonal'_apply,hij] |
| · rintro ⟨a',ha⟩; exact hi (congrArg Sigma.fst ha).symm |
|
|
| theorem list_update_prod |
| {π : Type} [Fintype π] [DecidableEq π] {R : π→Type} [∀ i,Monoid (R i)] (A : ∀ i,R i) |
| (L : List π) (hL : L.Nodup) (p : π) : |
| ((L.map (fun i=>Function.update (1 : ∀ i,R i) i (A i))).prod) p=if p∈L then A p else 1 := by |
| classical |
| induction L with |
| | nil => simp |
| | cons i L ih => |
| have hi := List.nodup_cons.mp hL |
| rw [List.map_cons,List.prod_cons,Pi.mul_apply,ih hi.2] |
| by_cases hp : p=i |
| · subst p; simp [hi.1] |
| · simp [hp] |
|
|
| theorem blockDiagonal'_product (A : ∀ p,Matrix (β p) (β p) ℂ) : |
| ((Finset.univ.toList.map (fun p=>matrix (sigmaIn p) (A p))).prod)=Matrix.blockDiagonal' A := by |
| classical |
| let φ := Matrix.blockDiagonal'RingHom (m' := β) (α := ℂ) |
| have he : (fun p=>matrix (sigmaIn p) (A p))=fun p=>φ (Function.update 1 p (A p)) := by |
| funext p; exact matrix_sigmaIn A p |
| rw [he] |
| let upd := fun p=>Function.update (1 : ∀ p,Matrix (β p) (β p) ℂ) p (A p) |
| have hmap : Finset.univ.toList.map (fun p=>φ (upd p))=(Finset.univ.toList.map upd).map φ := |
| (List.map_map ..).symm |
| change (Finset.univ.toList.map (fun p=>φ (upd p))).prod=_ |
| rw [hmap,← map_list_prod] |
| change φ ((Finset.univ.toList.map upd).prod)=φ A |
| apply congrArg φ |
| funext p |
| rw [list_update_prod A _ (Finset.nodup_toList _)] |
| simp |
|
|
| end ExactFourier.Embedded |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Embedded |
| variable {α β γ : Type} [Fintype α] [Fintype β] [Fintype γ] |
| [DecidableEq α] [DecidableEq β] [DecidableEq γ] |
|
|
| theorem card_complement |
| {α : Type} {β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] (e : β ↪ α) : |
| Fintype.card β+Fintype.card (complement e)=Fintype.card α := by |
| simpa using Fintype.card_congr (coordinates e) |
|
|
| /-- Complete a prescribed active-tuple matching with untouched spectator wires. -/ |
| theorem exists_completion (e : β ↪ α) (f : β ↪ γ) |
| (hcard : Fintype.card α≤Fintype.card γ) : |
| ∃ g : α ↪ γ,e.trans g=f := by |
| have hc : Fintype.card (complement e)≤Fintype.card (complement f) := by |
| have he := card_complement e |
| have hf := card_complement f |
| omega |
| obtain ⟨h⟩ := (Function.Embedding.nonempty_of_card_le hc) |
| let s : (β⊕complement e) ↪ (β⊕complement f) := Function.Embedding.sumMap (Function.Embedding.refl _) h |
| let g := (coordinates e).symm.toEmbedding.trans (s.trans (coordinates f).toEmbedding) |
| refine ⟨g,?_⟩ |
| ext i |
| change coordinates f (s ((coordinates e).symm (e i)))=f i |
| rw [← coordinates_inl e i,Equiv.symm_apply_apply] |
| rfl |
|
|
| theorem realize_active (e : β ↪ α) (f : β ↪ γ) (A : Matrix β β ℂ) |
| (hcard : Fintype.card α≤Fintype.card γ) : |
| ∃ g : α ↪ γ,matrix g (matrix e A)=matrix f A := by |
| obtain ⟨g,hg⟩ := exists_completion e f hcard |
| exact ⟨g,by rw [matrix_comp,hg]⟩ |
|
|
| variable {π : Type} [Fintype π] [DecidableEq π] |
| {δ ε : π→Type} [∀ p,Fintype (δ p)] [∀ p,Fintype (ε p)] |
| [∀ p,DecidableEq (δ p)] [∀ p,DecidableEq (ε p)] |
|
|
| def sigmaEmbed (e : ∀ p,δ p ↪ ε p) : (Σ p,δ p) ↪ (Σ p,ε p) where |
| toFun i := ⟨i.1,e i.1 i.2⟩ |
| inj' := by |
| rintro ⟨p,a⟩ ⟨q,b⟩ h |
| have hp := congrArg Sigma.fst h |
| dsimp at hp |
| subst q |
| have hab := eq_of_heq (Sigma.mk.inj_iff.mp h).2 |
| exact congrArg (Sigma.mk p) ((e p).injective hab) |
|
|
| theorem matrix_sigmaEmbed (e : ∀ p,δ p ↪ ε p) (A : ∀ p,Matrix (δ p) (δ p) ℂ) : |
| matrix (sigmaEmbed e) (Matrix.blockDiagonal' A)= |
| Matrix.blockDiagonal' (fun p=>matrix (e p) (A p)) := by |
| classical |
| ext ⟨p,a⟩ ⟨q,b⟩ |
| by_cases hpq : p=q |
| · subst q |
| rw [Matrix.blockDiagonal'_apply_eq] |
| by_cases ha : a∈Set.range (e p) |
| · obtain ⟨a,rfl⟩ := ha |
| by_cases hb : b∈Set.range (e p) |
| · obtain ⟨b,rfl⟩ := hb |
| change matrix (sigmaEmbed e) (Matrix.blockDiagonal' A) |
| (sigmaEmbed e ⟨p,a⟩) (sigmaEmbed e ⟨p,b⟩)=_ |
| rw [matrix_on,Matrix.blockDiagonal'_apply_eq,matrix_on] |
| · rw [matrix_off_col (e p) _ _ _ hb,matrix_off_col] |
| · simp |
| · rintro ⟨⟨q,b'⟩,h⟩ |
| have hq := congrArg Sigma.fst h |
| change q=p at hq |
| subst q |
| exact hb ⟨b',eq_of_heq (Sigma.mk.inj_iff.mp h).2⟩ |
| · rw [matrix_off_row (e p) _ _ _ ha,matrix_off_row] |
| · simp |
| · rintro ⟨⟨q,a'⟩,h⟩ |
| have hq := congrArg Sigma.fst h |
| change q=p at hq |
| subst q |
| exact ha ⟨a',eq_of_heq (Sigma.mk.inj_iff.mp h).2⟩ |
| · rw [Matrix.blockDiagonal'_apply_ne _ _ _ hpq] |
| by_cases ha : (⟨p,a⟩ : Σ p,ε p)∈Set.range (sigmaEmbed e) |
| · obtain ⟨i,hi⟩ := ha |
| by_cases hb : (⟨q,b⟩ : Σ p,ε p)∈Set.range (sigmaEmbed e) |
| · obtain ⟨j,hj⟩ := hb |
| rw [← hi,← hj,matrix_on] |
| apply Matrix.blockDiagonal'_apply_ne |
| have hi' := congrArg Sigma.fst hi |
| have hj' := congrArg Sigma.fst hj |
| change i.1=p at hi' |
| change j.1=q at hj' |
| simpa [hi',hj'] using hpq |
| · rw [matrix_off_col _ _ _ _ hb] |
| simp [hpq] |
| · rw [matrix_off_row _ _ _ _ ha] |
| simp [hpq] |
|
|
| end ExactFourier.Embedded |
|
|
| 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 Word.matrix_flatten (L : List (Word D A α)) : |
| Word.matrix L.flatten=(L.map Word.matrix).prod := by |
| induction L with |
| | nil => rfl |
| | cons W L ih => simp only [List.flatten_cons,Word.matrix_append,ih,List.map_cons,List.prod_cons] |
|
|
| theorem Word.calls_flatten (L : List (Word D A α)) : |
| Word.calls L.flatten=(L.map Word.calls).flatten := by |
| induction L with |
| | nil => rfl |
| | cons W L ih => simp only [List.flatten_cons,Word.calls_append,ih,List.map_cons] |
|
|
| def Word.reindex {β : Type} [Fintype β] [DecidableEq β] (e : α≃β) (W : Word D A α) : Word D A β := |
| W.embed e.toEmbedding |
|
|
| @[simp] theorem Word.matrix_reindex {β : Type} [Fintype β] [DecidableEq β] |
| (e : α≃β) (W : Word D A α) : (W.reindex e).matrix=Matrix.reindex e e W.matrix := by |
| rw [Word.reindex,Word.matrix_embed,Embedded.matrix_equiv] |
| @[simp] theorem Word.calls_reindex {β : Type} [Fintype β] [DecidableEq β] |
| (e : α≃β) (W : Word D A α) : (W.reindex e).calls=W.calls := by simp [Word.reindex] |
|
|
| variable {π : Type} [Fintype π] [DecidableEq π] |
| {β : π→Type} [∀ p,Fintype (β p)] [∀ p,DecidableEq (β p)] |
|
|
| def Word.blockSum (W : ∀ p,Word D A (β p)) : Word D A (Σ p,β p) := |
| (Finset.univ.toList.map (fun p=>(W p).embed (Embedded.sigmaIn p))).flatten |
|
|
| @[simp] theorem Word.matrix_blockSum (W : ∀ p,Word D A (β p)) : |
| (Word.blockSum W).matrix=Matrix.blockDiagonal' (fun p=>(W p).matrix) := by |
| rw [Word.blockSum,Word.matrix_flatten,List.map_map] |
| simp only [Function.comp_def,Word.matrix_embed] |
| exact Embedded.blockDiagonal'_product _ |
|
|
| @[simp] theorem Word.calls_blockSum (W : ∀ p,Word D A (β p)) : |
| (Word.blockSum W).calls=(Finset.univ.toList.map (fun p=>(W p).calls)).flatten := by |
| rw [Word.blockSum,Word.calls_flatten,List.map_map] |
| simp only [Function.comp_def,Word.calls_embed] |
|
|
| theorem Word.count_blockSum [DecidableEq τ] (W : ∀ p,Word D A (β p)) (t : τ) : |
| (Word.blockSum W).count t=∑ p,(W p).count t := by |
| rw [Word.count,Word.calls_blockSum,List.count_flatten] |
| simp [List.map_map,Word.count] |
|
|
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Packing |
|
|
| /-- Deleting only identity factors preserves a noncommutative product. -/ |
| theorem prod_filter_map {X M : Type*} [Monoid M] (L : List X) (p : X→Prop) |
| [DecidablePred p] (f : X→M) (hf : ∀ x∈L,¬p x → f x=1) : |
| ((L.filter p).map f).prod=(L.map f).prod := by |
| induction L with |
| | nil => rfl |
| | cons x L ih => |
| have ih' := ih (fun y hy=>hf y (List.mem_cons_of_mem _ hy)) |
| by_cases hp : p x |
| · simp [hp,ih'] |
| · simp [hp,ih',hf x (by simp) hp] |
|
|
| /-- Physical slot padding retains every local program's exact multiplication order. -/ |
| theorem ordered_padding {M : Type*} [Monoid M] {k T : ℕ} (time : Fin k→Fin T) |
| (ht : StrictMono time) (f : Fin k→M) : |
| (List.ofFn (Function.extend time f (fun _=>1))).prod=(List.ofFn f).prod := by |
| classical |
| let P : Fin T→Prop := fun t=>t∈Set.range time |
| have hs : ((List.finRange T).filter P)=((List.finRange k).map time) := by |
| have h₁ : ((List.finRange T).filter P).SortedLT := |
| ((List.sortedLT_finRange T).pairwise.filter _).sortedLT |
| have h₂ : ((List.finRange k).map time).SortedLT := by |
| apply List.Pairwise.sortedLT |
| rw [List.pairwise_map] |
| exact (List.sortedLT_finRange k).pairwise.imp (fun hab=>ht hab) |
| apply h₁.eq_of_mem_iff h₂ |
| intro x |
| simp [P,Set.mem_range,List.mem_map] |
| let g := Function.extend time f (fun _=>1) |
| rw [List.ofFn_eq_map,List.ofFn_eq_map] |
| rw [← prod_filter_map (List.finRange T) P g] |
| · rw [hs,List.map_map] |
| congr 2 |
| funext x |
| exact ht.injective.extend_apply f (fun _=>1) x |
| · intro x hx hp |
| exact Function.extend_apply' f (fun _=>1) x hp |
|
|
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| end OAI |
|
|
