| import OAI.Computability.FourierCircuit.WordScheduling |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.PiTensor |
| variable {ι : Type} [Fintype ι] [DecidableEq ι] |
| {D : ι→Type} [∀ i,Fintype (D i)] [∀ i,DecidableEq (D i)] |
|
|
| def matrix (A : ∀ i,Matrix (D i) (D i) ℂ) : Matrix (∀ i,D i) (∀ i,D i) ℂ := |
| fun x y=>∏ i,A i (x i) (y i) |
|
|
| @[simp] theorem one |
| {ι : Type} [Fintype ι] [DecidableEq ι] {D : ι → Type} [(i : ι) → Fintype (D i)] [(i : ι) → DecidableEq (D i)] : matrix (1 : ∀ i,Matrix (D i) (D i) ℂ)=1 := by |
| classical |
| ext x y |
| by_cases h : x=y |
| · subst y; simp [matrix] |
| · rw [Matrix.one_apply,ite_eq_right h] |
| obtain ⟨i,hi⟩ := Function.ne_iff.mp h |
| exact Finset.prod_eq_zero (Finset.mem_univ i) (by simp [hi]) |
|
|
| theorem mul |
| {ι : Type} [Fintype ι] [DecidableEq ι] {D : ι → Type} [(i : ι) → Fintype (D i)] [(i : ι) → DecidableEq (D i)] (A B : ∀ i,Matrix (D i) (D i) ℂ) : matrix (A*B)=matrix A*matrix B := by |
| classical |
| ext x y |
| simp only [matrix,Pi.mul_apply,Matrix.mul_apply] |
| simp_rw [← Finset.prod_mul_distrib] |
| exact Fintype.prod_sum fun i j=>A i (x i) j*B i j (y i) |
|
|
| def hom : (∀ i,Matrix (D i) (D i) ℂ) →* Matrix (∀ i,D i) (∀ i,D i) ℂ where |
| toFun := matrix |
| map_one' := one |
| map_mul' := mul |
|
|
| theorem unit (A : ∀ i,Matrix (D i) (D i) ℂ) (hA : ∀ i,IsUnit (A i)) : IsUnit (matrix A) := |
| by |
| choose U hU using hA |
| have he : A=fun i=>(U i : Matrix (D i) (D i) ℂ) := by funext i; exact (hU i).symm |
| rw [he] |
| exact (Units.isUnit (show (∀ i,Matrix (D i) (D i) ℂ)ˣ from |
| ⟨fun i=>U i,fun i=>(U i)⁻¹,by ext i; simp,by ext i; simp⟩)).map hom |
|
|
| def axisCoordinates (i : ι) : (Σ _ : ∀ j : {j // j≠i},D j,D i) ≃ (∀ j,D j) := |
| (Equiv.sigmaEquivProd _ _).trans ((Equiv.prodComm _ _).trans (Equiv.piSplitAt i D).symm) |
|
|
| @[simp] theorem axisCoordinates_symm |
| {ι : Type} [Fintype ι] [DecidableEq ι] {D : ι → Type} [(i : ι) → Fintype (D i)] [(i : ι) → DecidableEq (D i)] (i : ι) (x : ∀ j,D j) : |
| (axisCoordinates i).symm x=⟨fun j=>x j,x i⟩ := rfl |
|
|
| theorem axis_matrix |
| {ι : Type} [Fintype ι] [DecidableEq ι] {D : ι → Type} [(i : ι) → Fintype (D i)] [(i : ι) → DecidableEq (D i)] (i : ι) (A : Matrix (D i) (D i) ℂ) : |
| matrix (Function.update (1 : ∀ j,Matrix (D j) (D j) ℂ) i A)= |
| Matrix.reindex (axisCoordinates i) (axisCoordinates i) (Matrix.blockDiagonal' (fun _=>A)) := by |
| classical |
| ext x y |
| simp only [Matrix.reindex_apply,Matrix.submatrix_apply,axisCoordinates_symm] |
| change (∏ j,(Function.update (1 : ∀ j,Matrix (D j) (D j) ℂ) i A) j (x j) (y j))=_ |
| rw [Fintype.prod_eq_mul_prod_compl i] |
| simp only [Finset.compl_eq_univ_sdiff] |
| simp only [Function.update_self] |
| by_cases h : (fun j : {j // j≠i}=>x j)=(fun j : {j // j≠i}=>y j) |
| · have hp : (∏ j ∈ Finset.univ \ {i}, |
| Function.update (1 : ∀ j,Matrix (D j) (D j) ℂ) i A j (x j) (y j))=1 := by |
| apply Finset.prod_eq_one |
| intro j hj |
| have hj' : j≠i := by simpa using (Finset.mem_sdiff.mp hj).2 |
| have he := congrFun h ⟨j,hj'⟩ |
| simp [Function.update_of_ne hj',he] |
| rw [hp,mul_one] |
| simp [Matrix.blockDiagonal'_apply,h] |
| · have hp : (∏ j ∈ Finset.univ \ {i}, |
| Function.update (1 : ∀ j,Matrix (D j) (D j) ℂ) i A j (x j) (y j))=0 := by |
| obtain ⟨j,hj⟩ := Function.ne_iff.mp h |
| apply Finset.prod_eq_zero (i := j.val) |
| · simp [j.property] |
| · simp [Function.update_of_ne j.property,hj] |
| rw [hp,mul_zero] |
| simp [Matrix.blockDiagonal'_apply,h] |
|
|
| end ExactFourier.PiTensor |
|
|
| 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 ι] |
| {E : ι→Type} [∀ i,Fintype (E i)] [∀ i,DecidableEq (E i)] |
|
|
| def Word.axis (i : ι) (W : Word D A (E i)) : Word D A (∀ i,E i) := |
| (Word.blockSum (fun _ : ∀ j : {j // j≠i},E j=>W)).reindex (PiTensor.axisCoordinates i) |
|
|
| @[simp] theorem Word.matrix_axis (i : ι) (W : Word D A (E i)) : |
| (W.axis i).matrix=PiTensor.matrix (Function.update (1 : ∀ j,Matrix (E j) (E j) ℂ) i W.matrix) := by |
| rw [Word.axis,Word.matrix_reindex,Word.matrix_blockSum,PiTensor.axis_matrix] |
|
|
| theorem Word.count_axis [DecidableEq τ] (i : ι) (W : Word D A (E i)) (t : τ) : |
| (W.axis i).count t=Fintype.card (∀ j : {j // j≠i},E j)*W.count t := by |
| rw [Word.axis,Word.count,Word.calls_reindex,← Word.count,Word.count_blockSum] |
| simp |
|
|
| def Word.tensor (W : ∀ i,Word D A (E i)) : Word D A (∀ i,E i) := |
| (Finset.univ.toList.map (fun i=>(W i).axis i)).flatten |
|
|
| @[simp] theorem Word.matrix_tensor (W : ∀ i,Word D A (E i)) : |
| (Word.tensor W).matrix=PiTensor.matrix (fun i=>(W i).matrix) := by |
| rw [Word.tensor,Word.matrix_flatten,List.map_map] |
| simp only [Function.comp_def,Word.matrix_axis] |
| let upd := fun i=>Function.update (1 : ∀ i,Matrix (E i) (E i) ℂ) i (W i).matrix |
| change (Finset.univ.toList.map (fun i=>PiTensor.hom (upd i))).prod=_ |
| have hm : Finset.univ.toList.map (fun i=>PiTensor.hom (upd i))= |
| (Finset.univ.toList.map upd).map PiTensor.hom := (List.map_map ..).symm |
| rw [hm,← map_list_prod] |
| change PiTensor.matrix ((Finset.univ.toList.map upd).prod)=_ |
| congr 1 |
| funext i |
| rw [Embedded.list_update_prod _ _ (Finset.nodup_toList _)] |
| simp |
|
|
| theorem Word.count_tensor [DecidableEq τ] (W : ∀ i,Word D A (E i)) (t : τ) : |
| (Word.tensor W).count t=∑ i,Fintype.card (∀ j : {j // j≠i},E j)*(W i).count t := by |
| rw [Word.tensor,Word.count,Word.calls_flatten,List.count_flatten] |
| simp only [List.map_map,Function.comp_def] |
| change (Finset.univ.toList.map (fun i=>((W i).axis i).count t)).sum=_ |
| simp [Word.count_axis] |
|
|
| 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) ℂ} |
| {α β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] |
|
|
| def Word.leftTensor (W : Word D A α) : Word D A (α×β) := |
| (Word.blockSum (fun _ : β=>W)).reindex ((Equiv.sigmaEquivProd β α).trans (Equiv.prodComm β α)) |
| def Word.rightTensor (V : Word D A β) : Word D A (α×β) := |
| (Word.blockSum (fun _ : α=>V)).reindex (Equiv.sigmaEquivProd α β) |
|
|
| theorem Word.matrix_leftTensor (W : Word D A α) : |
| (W.leftTensor (β := β)).matrix=Matrix.kronecker W.matrix (1 : Matrix β β ℂ) := by |
| rw [Word.leftTensor,Word.matrix_reindex,Word.matrix_blockSum] |
| ext ⟨a,b⟩ ⟨c,d⟩ |
| by_cases h : b=d |
| · subst d; simp [Matrix.reindex_apply] |
| · simp [Matrix.reindex_apply,Matrix.blockDiagonal'_apply,h] |
|
|
| theorem Word.matrix_rightTensor (V : Word D A β) : |
| (V.rightTensor (α := α)).matrix=Matrix.kronecker (1 : Matrix α α ℂ) V.matrix := by |
| rw [Word.rightTensor,Word.matrix_reindex,Word.matrix_blockSum] |
| ext ⟨a,b⟩ ⟨c,d⟩ |
| by_cases h : a=c |
| · subst c; simp [Matrix.reindex_apply] |
| · simp [Matrix.reindex_apply,Matrix.blockDiagonal'_apply,h] |
|
|
| theorem Word.count_leftTensor [DecidableEq τ] (W : Word D A α) (t : τ) : |
| (W.leftTensor (β := β)).count t=Fintype.card β*W.count t := by |
| rw [Word.leftTensor,Word.count,Word.calls_reindex,← Word.count,Word.count_blockSum] |
| simp |
|
|
| theorem Word.count_rightTensor [DecidableEq τ] (V : Word D A β) (t : τ) : |
| (V.rightTensor (α := α)).count t=Fintype.card α*V.count t := by |
| rw [Word.rightTensor,Word.count,Word.calls_reindex,← Word.count,Word.count_blockSum] |
| simp |
|
|
| def Word.kronecker (W : Word D A α) (V : Word D A β) : Word D A (α×β) := |
| W.leftTensor++V.rightTensor |
|
|
| @[simp] theorem Word.matrix_kronecker (W : Word D A α) (V : Word D A β) : |
| (W.kronecker V).matrix=Matrix.kronecker W.matrix V.matrix := by |
| rw [Word.kronecker,Word.matrix_append,Word.matrix_leftTensor,Word.matrix_rightTensor] |
| simpa using (Matrix.mul_kronecker_mul W.matrix (1 : Matrix α α ℂ) |
| (1 : Matrix β β ℂ) V.matrix).symm |
|
|
| theorem Word.count_kronecker [DecidableEq τ] (W : Word D A α) (V : Word D A β) (t : τ) : |
| (W.kronecker V).count t=Fintype.card β*W.count t+Fintype.card α*V.count t := by |
| rw [Word.kronecker,Word.count_append,Word.count_leftTensor,Word.count_rightTensor] |
|
|
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Packing |
| variable {σ : Type} [Fintype σ] [DecidableEq σ] |
| {E : σ→Type} [∀ s,Fintype (E s)] [∀ s,DecidableEq (E s)] |
|
|
| /-- The two tensor axes choose block-copy labels independently, even for repeated species. -/ |
| def sectorCoordinates (k : σ→ℕ) : |
| (Σ p : σ×σ,(Fin (k p.1)×Fin (k p.2))×(E p.1×E p.2)) ≃ |
| ((Σ s,Fin (k s)×E s)×(Σ s,Fin (k s)×E s)) where |
| toFun x := (⟨x.1.1,x.2.1.1,x.2.2.1⟩,⟨x.1.2,x.2.1.2,x.2.2.2⟩) |
| invFun x := ⟨(x.1.1,x.2.1),(x.1.2.1,x.2.2.1),(x.1.2.2,x.2.2.2)⟩ |
| left_inv := by rintro ⟨⟨s,t⟩,⟨i,j⟩,a,b⟩; rfl |
| right_inv := by rintro ⟨⟨s,i,a⟩,⟨t,j,b⟩⟩; rfl |
|
|
| def speciesInventory (k : σ→ℕ) (B : ∀ s,Matrix (E s) (E s) ℂ) : |
| Matrix (Σ s,Fin (k s)×E s) (Σ s,Fin (k s)×E s) ℂ := |
| Matrix.blockDiagonal' fun s=>Matrix.kronecker (1 : Matrix (Fin (k s)) (Fin (k s)) ℂ) (B s) |
|
|
| def sectorMatrix (k : σ→ℕ) (B : ∀ s,Matrix (E s) (E s) ℂ) : |
| Matrix (Σ p : σ×σ,(Fin (k p.1)×Fin (k p.2))×(E p.1×E p.2)) |
| (Σ p : σ×σ,(Fin (k p.1)×Fin (k p.2))×(E p.1×E p.2)) ℂ := |
| Matrix.blockDiagonal' fun p=>Matrix.kronecker (1 : Matrix (Fin (k p.1)×Fin (k p.2)) _ ℂ) |
| (Matrix.kronecker (B p.1) (B p.2)) |
|
|
| theorem inventory_tensor_sectors |
| {σ : Type} [Fintype σ] [DecidableEq σ] {E : σ → Type} [(s : σ) → Fintype (E s)] [(s : σ) → DecidableEq (E s)] (k : σ→ℕ) (B : ∀ s,Matrix (E s) (E s) ℂ) : |
| Matrix.kronecker (speciesInventory k B) (speciesInventory k B)= |
| Matrix.reindex (sectorCoordinates k) (sectorCoordinates k) (sectorMatrix k B) := by |
| classical |
| ext ⟨⟨s,i,a⟩,⟨t,j,b⟩⟩ ⟨⟨s',i',a'⟩,⟨t',j',b'⟩⟩ |
| by_cases hs : s=s' |
| · subst s' |
| by_cases ht : t=t' |
| · subst t' |
| by_cases hi : i=i' |
| · subst i'; by_cases hj : j=j' |
| · subst j'; simp [speciesInventory,sectorMatrix,Matrix.reindex_apply,sectorCoordinates] |
| · simp [speciesInventory,sectorMatrix,Matrix.reindex_apply,sectorCoordinates,hj] |
| · simp [speciesInventory,sectorMatrix,Matrix.reindex_apply,sectorCoordinates,hi] |
| · simp [speciesInventory,sectorMatrix,Matrix.reindex_apply,sectorCoordinates, |
| Matrix.blockDiagonal'_apply,ht] |
| · simp [speciesInventory,sectorMatrix,Matrix.reindex_apply,sectorCoordinates, |
| Matrix.blockDiagonal'_apply,hs] |
|
|
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Packing |
| variable {τ π ρ : Type} [Fintype π] [Fintype ρ] [DecidableEq π] [DecidableEq ρ] |
| {D : τ→Type} [∀ t,Fintype (D t)] [∀ t,DecidableEq (D t)] |
| {A : ∀ t,Matrix (D t) (D t) ℂ} |
|
|
| def colorEquiv (u : π→τ) (v : ρ→τ) (e : π≃ρ) (he : ∀ p,u p=v (e p)) : |
| (Σ p,D (u p))≃(Σ r,D (v r)) := |
| Equiv.sigmaCongr e (fun p=>Equiv.cast (congrArg D (he p))) |
|
|
| @[simp] theorem colorEquiv_fst |
| {τ : Type} {π : Type} {ρ : Type} [Fintype π] [Fintype ρ] [DecidableEq π] [DecidableEq ρ] {D : τ → Type} [(t : τ) → Fintype (D t)] [(t : τ) → DecidableEq (D t)] (u : π→τ) (v : ρ→τ) (e : π≃ρ) (he : ∀ p,u p=v (e p)) |
| (x : Σ p,D (u p)) : (colorEquiv u v e he x).1=e x.1 := rfl |
|
|
| theorem color_cast_apply |
| {τ : Type} {D : τ → Type} [(t : τ) → Fintype (D t)] [(t : τ) → DecidableEq (D t)] {A : (t : τ) → Matrix (D t) (D t) ℂ} {i j : τ} (h : i=j) (a b : D i) : |
| A j (cast (congrArg D h) a) (cast (congrArg D h) b)=A i a b := by cases h; rfl |
|
|
| theorem coloredBlock_on |
| {τ : Type} {π : Type} {ρ : Type} [Fintype π] [Fintype ρ] [DecidableEq π] [DecidableEq ρ] {D : τ → Type} [(t : τ) → Fintype (D t)] [(t : τ) → DecidableEq (D t)] {A : (t : τ) → Matrix (D t) (D t) ℂ} (u : π→τ) (v : ρ→τ) (e : π≃ρ) (he : ∀ p,u p=v (e p)) |
| (x y : Σ p,D (u p)) : |
| Matrix.blockDiagonal' (fun r=>A (v r)) (colorEquiv u v e he x) (colorEquiv u v e he y)= |
| Matrix.blockDiagonal' (fun p=>A (u p)) x y := by |
| rcases x with ⟨p,a⟩; rcases y with ⟨q,b⟩ |
| by_cases h : p=q |
| · subst q |
| change Matrix.blockDiagonal' (fun r=>A (v r)) |
| ⟨e p,cast (congrArg D (he p)) a⟩ ⟨e p,cast (congrArg D (he p)) b⟩=_ |
| rw [Matrix.blockDiagonal'_apply_eq,Matrix.blockDiagonal'_apply_eq] |
| exact color_cast_apply (he p) a b |
| · rw [Matrix.blockDiagonal'_apply_ne _ _ _ h] |
| apply Matrix.blockDiagonal'_apply_ne |
| exact fun hp=>h (e.injective hp) |
|
|
| theorem coloredBlock_reindex (u : π→τ) (v : ρ→τ) (e : π≃ρ) (he : ∀ p,u p=v (e p)) : |
| Matrix.reindex (colorEquiv u v e he) (colorEquiv u v e he) |
| (Matrix.blockDiagonal' (fun p=>A (u p)))=Matrix.blockDiagonal' (fun r=>A (v r)) := by |
| ext x y |
| obtain ⟨x,rfl⟩ := (colorEquiv u v e he).surjective x |
| obtain ⟨y,rfl⟩ := (colorEquiv u v e he).surjective y |
| simp only [Matrix.reindex_apply,Matrix.submatrix_apply,Equiv.symm_apply_apply] |
| exact (coloredBlock_on u v e he x y).symm |
|
|
| /-- Equal multiplicities give an exact color-preserving matching of call blocks. -/ |
| theorem exists_colorEquiv |
| {τ : Type} {π : Type} {ρ : Type} [Fintype π] [Fintype ρ] [DecidableEq π] [DecidableEq ρ] [Fintype τ] [DecidableEq τ] (u : π→τ) (v : ρ→τ) |
| (h : ∀ t,Fintype.card {p // u p=t}=Fintype.card {r // v r=t}) : |
| ∃ e : π≃ρ,∀ p,u p=v (e p) := by |
| let f := fun t=>Fintype.equivOfCardEq (h t) |
| let e := (Equiv.sigmaFiberEquiv u).symm.trans |
| ((Equiv.sigmaCongrRight f).trans (Equiv.sigmaFiberEquiv v)) |
| refine ⟨e,?_⟩ |
| intro p |
| exact (f (u p) ⟨p,rfl⟩).property.symm |
|
|
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Packing |
| variable {τ : Type} [Fintype τ] [DecidableEq τ] {D : τ→Type} [∀ t,Fintype (D t)] [∀ t,DecidableEq (D t)] |
| {A : ∀ t,Matrix (D t) (D t) ℂ} |
|
|
| abbrev optionalDomain (D : τ→Type) : Option τ→Type |
| | none => Empty |
| | some t => D t |
| instance optionalDomain_fintype (t : Option τ) : Fintype (optionalDomain D t) := by |
| cases t <;> dsimp [optionalDomain] <;> infer_instance |
| instance optionalDomain_decEq (t : Option τ) : DecidableEq (optionalDomain D t) := by |
| cases t <;> dsimp [optionalDomain] <;> infer_instance |
|
|
| def optionalMatrix (A : ∀ t,Matrix (D t) (D t) ℂ) : ∀ t,Matrix (optionalDomain D t) (optionalDomain D t) ℂ |
| | none => 1 |
| | some t => A t |
|
|
| variable {α : Type} [Fintype α] [DecidableEq α] |
|
|
| def Step.activeTuple : (s : Step D A α) → optionalDomain D s.kind ↪ α |
| | .mono _ _ => ⟨Empty.elim,by intro a; exact a.elim⟩ |
| | .call _ e => e |
|
|
| def Step.monoPart : Step D A α→Matrix α α ℂ |
| | .mono M _ => M |
| | .call _ _ => 1 |
|
|
| theorem Step.monoPart_monomial |
| {τ : Type} [Fintype τ] [DecidableEq τ] {D : τ → Type} [(t : τ) → Fintype (D t)] [(t : τ) → DecidableEq (D t)] {A : (t : τ) → Matrix (D t) (D t) ℂ} {α : Type} [Fintype α] [DecidableEq α] (s : Step D A α) : MonomialMatrix s.monoPart := by |
| cases s with |
| | mono M h => exact h |
| | call t e => exact MonomialMatrix.one |
|
|
| theorem Step.decompose |
| {τ : Type} [Fintype τ] [DecidableEq τ] {D : τ → Type} [(t : τ) → Fintype (D t)] [(t : τ) → DecidableEq (D t)] {A : (t : τ) → Matrix (D t) (D t) ℂ} {α : Type} [Fintype α] [DecidableEq α] (s : Step D A α) : |
| s.matrix=s.monoPart*Embedded.matrix s.activeTuple (optionalMatrix A s.kind) := by |
| cases s with |
| | mono M hm => |
| let e : Empty ↪ α := ⟨Empty.elim,by intro a; exact a.elim⟩ |
| change M=M*Embedded.matrix e (1 : Matrix Empty Empty ℂ) |
| rw [Embedded.matrix_one,mul_one] |
| | call t e => |
| change Embedded.matrix e (A t)=1*Embedded.matrix e (A t) |
| rw [one_mul] |
|
|
| variable {π : Type} [Fintype π] [DecidableEq π] |
|
|
| abbrev CallIndex (u : π→Option τ) := Σ t,{p // u p=some t} |
|
|
| def callSite (u : π→Option τ) : CallIndex u ↪ π where |
| toFun c := c.2.1 |
| inj' := by |
| rintro ⟨i,⟨p,hp⟩⟩ ⟨j,⟨q,hq⟩⟩ h |
| change p=q at h; subst q |
| have hij : i=j := Option.some.inj (hp.symm.trans hq) |
| subst j; rfl |
|
|
| def activeTo (u : π→Option τ) (x : Σ c : CallIndex u,D c.1) : Σ p,optionalDomain D (u p) := |
| ⟨x.1.2.1,cast (congrArg (optionalDomain D) x.1.2.2.symm) x.2⟩ |
|
|
| theorem activeTo_injective |
| {τ : Type} [Fintype τ] [DecidableEq τ] {D : τ → Type} [(t : τ) → Fintype (D t)] [(t : τ) → DecidableEq (D t)] {π : Type} [Fintype π] [DecidableEq π] (u : π→Option τ) : Function.Injective (activeTo (D := D) u) := by |
| rintro ⟨⟨i,p,hp⟩,a⟩ ⟨⟨j,q,hq⟩,b⟩ h |
| have hpq := congrArg Sigma.fst h |
| change p=q at hpq |
| subst q |
| have hij : i=j := Option.some.inj (hp.symm.trans hq) |
| subst j |
| have hab := eq_of_heq (Sigma.mk.inj_iff.mp h).2 |
| have ha : a=b := (Equiv.cast (congrArg (optionalDomain D) hp.symm)).injective hab |
| subst b |
| rfl |
|
|
| theorem activeTo_surjective |
| {τ : Type} [Fintype τ] [DecidableEq τ] {D : τ → Type} [(t : τ) → Fintype (D t)] [(t : τ) → DecidableEq (D t)] {π : Type} [Fintype π] [DecidableEq π] (u : π→Option τ) : Function.Surjective (activeTo (D := D) u) := by |
| rintro ⟨p,a⟩ |
| have hh : ∃ t,u p=some t := by |
| cases h : u p with |
| | none => exact (cast (congrArg (optionalDomain D) h) a : Empty).elim |
| | some t => exact ⟨t,rfl⟩ |
| obtain ⟨t,hp⟩ := hh |
| refine ⟨⟨⟨t,p,hp⟩,cast (congrArg (optionalDomain D) hp) a⟩,?_⟩ |
| simp [activeTo] |
|
|
| def activeEquiv (u : π→Option τ) : |
| (Σ c : CallIndex u,D c.1)≃(Σ p,optionalDomain D (u p)) := |
| Equiv.ofBijective (activeTo u) ⟨activeTo_injective u,activeTo_surjective u⟩ |
|
|
| @[simp] theorem activeEquiv_fst (u : π→Option τ) (x : Σ c : CallIndex u,D c.1) : |
| (activeEquiv u x).1=x.1.2.1 := rfl |
|
|
| theorem activeEquiv_on (u : π→Option τ) (x y : Σ c : CallIndex u,D c.1) : |
| Matrix.blockDiagonal' (fun p=>optionalMatrix A (u p)) (activeEquiv u x) (activeEquiv u y)= |
| Matrix.blockDiagonal' (fun c : CallIndex u=>A c.1) x y := by |
| rcases x with ⟨⟨i,p,hp⟩,a⟩; rcases y with ⟨⟨j,q,hq⟩,b⟩ |
| by_cases hpq : p=q |
| · subst q |
| have hij : i=j := Option.some.inj (hp.symm.trans hq) |
| subst j |
| change Matrix.blockDiagonal' _ ⟨p,_⟩ ⟨p,_⟩=_ |
| rw [Matrix.blockDiagonal'_apply_eq,Matrix.blockDiagonal'_apply_eq] |
| exact color_cast_apply (A := optionalMatrix A) hp.symm a b |
| · rw [Matrix.blockDiagonal'_apply_ne _ _ _ (show (⟨i,p,hp⟩ : CallIndex u)≠⟨j,q,hq⟩ from |
| fun h=>hpq (congrArg (fun c : CallIndex u=>c.2.1) h))] |
| exact Matrix.blockDiagonal'_apply_ne _ _ _ hpq |
|
|
| theorem activeEquiv_reindex (u : π→Option τ) : |
| Matrix.reindex (activeEquiv (D := D) u) (activeEquiv u) |
| (Matrix.blockDiagonal' (fun c : CallIndex u=>A c.1))= |
| Matrix.blockDiagonal' (fun p=>optionalMatrix A (u p)) := by |
| ext x y |
| obtain ⟨x,rfl⟩ := (activeEquiv (D := D) u).surjective x |
| obtain ⟨y,rfl⟩ := (activeEquiv (D := D) u).surjective y |
| simp only [Matrix.reindex_apply,Matrix.submatrix_apply,Equiv.symm_apply_apply] |
| exact (activeEquiv_on u x y).symm |
|
|
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| end OAI |
|
|
