| import OAI.Computability.FourierCircuit.TensorTools |
|
|
| namespace OAI |
|
|
| section |
| /-! Sparse whole-block cancellations in triangular monotonicity. -/ |
| namespace ExactFourier |
| open scoped BigOperators |
|
|
| namespace MatrixPrice |
| variable (p : MatrixPrice) |
| variable {ι κ : Type} [Fintype ι] [Fintype κ] [DecidableEq ι] [DecidableEq κ] |
|
|
| theorem rectangularShear_add_le (G H : Matrix ι κ ℂ) : |
| p.value (rectangularShear (G+H)) ≤ |
| p.value (rectangularShear G) + p.value (rectangularShear H) := by |
| rw [← rectangularShear_mul] |
| exact p.mul_le _ _ (rectangularShear_unit G) (rectangularShear_unit H) |
|
|
| theorem rectangularShear_single |
| {ι : Type} {κ : Type} [Fintype ι] [Fintype κ] [DecidableEq ι] [DecidableEq κ] (i : ι) (j : κ) (c : ℂ) : |
| rectangularShear (Matrix.single i j c) = |
| Matrix.transvection (Sum.inl i) (Sum.inr j) c := by |
| ext a b |
| cases a <;> cases b <;> |
| simp [rectangularShear, Matrix.transvection, Matrix.single, Matrix.one_apply] |
|
|
| theorem rectangularShear_sum_le {α : Type*} (s : Finset α) (G : α → Matrix ι κ ℂ) : |
| p.value (rectangularShear (∑ i ∈ s, G i)) ≤ |
| ∑ i ∈ s, p.value (rectangularShear (G i)) := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => simp [rectangularShear] |
| | @insert a s ha ih => |
| rw [Finset.sum_insert ha, Finset.sum_insert ha] |
| exact (p.rectangularShear_add_le (G a) (∑ i ∈ s, G i)).trans (add_le_add le_rfl ih) |
|
|
| /-- A rectangular shear costs at most one per nonzero matrix entry. -/ |
| theorem rectangularShear_sparse (G : Matrix ι κ ℂ) : |
| p.value (rectangularShear G) ≤ |
| ((Finset.univ.filter fun ij : ι × κ => G ij.1 ij.2 ≠ 0).card : ℝ) := by |
| classical |
| let S := Finset.univ.filter fun ij : ι × κ => G ij.1 ij.2 ≠ 0 |
| have hsum : (∑ ij ∈ S, Matrix.single ij.1 ij.2 (G ij.1 ij.2)) = G := by |
| ext i j |
| simp only [Matrix.sum_apply, Matrix.single_apply] |
| rw [Finset.sum_eq_single (i,j)] |
| · simp |
| · intro b hb hne |
| by_cases hi : i=b.1 |
| · have hj : j≠b.2 := by intro hj; exact hne (Prod.ext hi.symm hj.symm) |
| simp [hj, eq_comm] |
| · simp [hi, eq_comm] |
| · intro hn |
| have hz : G i j = 0 := by simpa [S] using hn |
| simp [hz] |
| calc |
| p.value (rectangularShear G) = p.value (rectangularShear (∑ ij ∈ S, Matrix.single ij.1 ij.2 (G ij.1 ij.2))) := by rw [hsum] |
| _ ≤ ∑ ij ∈ S, p.value (rectangularShear (Matrix.single ij.1 ij.2 (G ij.1 ij.2))) := |
| p.rectangularShear_sum_le S _ |
| _ ≤ ∑ _ij ∈ S, (1 : ℝ) := by |
| apply Finset.sum_le_sum |
| intro ij hij |
| rw [rectangularShear_single] |
| exact p.transvection_le_one _ _ (by simp) _ |
| _ = _ := by simp [S] |
|
|
| end MatrixPrice |
| end ExactFourier |
|
|
| end |
|
|
| section |
| /-! Normalized whole-row-block tensor recursion and its sparse generators. |
| The change of basis acts only on the call index, as in corner:eq:actual-row-block. -/ |
| namespace ExactFourier.Triangular |
| open scoped Kronecker BigOperators |
| open TensorTools |
| variable {α β σ κ : Type} [Fintype α] [Fintype β] [Fintype σ] [Fintype κ] |
| [DecidableEq α] [DecidableEq β] [DecidableEq σ] [DecidableEq κ] |
|
|
| def flat (E : Matrix (σ × α) κ ℂ) : Matrix σ (α × κ) ℂ := fun s j => E (s,j.1) j.2 |
|
|
| def liftRows (R : Matrix σ (α × κ) ℂ) (H : Matrix β β ℂ) : |
| Matrix (σ × β) (α × (κ × β)) ℂ := fun i j => R i.1 (j.1,j.2.1) * H i.2 j.2.2 |
|
|
| def freshRows (T : Matrix α β ℂ) : Matrix κ (α × (κ × β)) ℂ := |
| fun i j => (1 : Matrix κ κ ℂ) i j.2.1 * T j.1 j.2.2 |
|
|
| def nextRows (R : Matrix σ (α × κ) ℂ) (T : Matrix α β ℂ) (H : Matrix β β ℂ) : |
| Matrix ((σ × β) ⊕ κ) (α × (κ × β)) ℂ := |
| Matrix.fromRows (liftRows R H) (freshRows T) |
|
|
| theorem liftRows_mul |
| {α : Type} {β : Type} {σ : Type} {κ : Type} [Fintype α] [Fintype β] [Fintype σ] [Fintype κ] [DecidableEq α] [DecidableEq β] [DecidableEq σ] [DecidableEq κ] (V : Matrix σ σ ℂ) (B : Matrix β β ℂ) |
| (R : Matrix σ (α × κ) ℂ) (H : Matrix β β ℂ) : |
| (V ⊗ₖ B) * liftRows R H = liftRows (V * R) (B * H) := by |
| ext i j |
| change (∑ x : σ × β, (V i.1 x.1 * B i.2 x.2) * |
| (R x.1 (j.1,j.2.1) * H x.2 j.2.2)) = |
| (∑ s, V i.1 s * R s (j.1,j.2.1)) * (∑ b, B i.2 b * H b j.2.2) |
| rw [Fintype.sum_prod_type, Finset.sum_mul] |
| apply Finset.sum_congr rfl |
| intro s hs |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro b hb |
| ring |
|
|
| theorem nextRows_change (V : Matrix σ σ ℂ) (D : Matrix β β ℂ) |
| (R : Matrix σ (α × κ) ℂ) (T : Matrix α β ℂ) (hD : IsUnit D) : |
| Matrix.fromBlocks (V ⊗ₖ D) 0 0 (1 : Matrix κ κ ℂ) * nextRows R T D⁻¹ = |
| nextRows (V * R) T 1 := by |
| simp only [nextRows, Matrix.fromBlocks_mul_fromRows, Matrix.zero_mul, Matrix.one_mul, |
| add_zero, zero_add, liftRows_mul, |
| Matrix.mul_nonsing_inv _ ((Matrix.isUnit_iff_isUnit_det D).mp hD)] |
|
|
| theorem flat_next_normalized |
| {α : Type} {β : Type} {σ : Type} {κ : Type} [Fintype α] [Fintype β] [Fintype σ] [Fintype κ] [DecidableEq α] [DecidableEq β] [DecidableEq σ] [DecidableEq κ] (E : Matrix (σ × α) κ ℂ) (Y : Matrix κ κ ℂ) |
| (C : Matrix α β ℂ) (D : Matrix β β ℂ) (hY : IsUnit Y) : |
| flat (nextE E Y C * (Y ⊗ₖ D)⁻¹) = |
| nextRows (flat (E * Y⁻¹)) (C * D⁻¹) D⁻¹ := by |
| rw [Matrix.inv_kronecker] |
| ext i j |
| rcases i with ⟨s,b⟩|i |
| · change (∑ x : κ × β, (E (s,j.1) x.1 * (1 : Matrix β β ℂ) b x.2) * |
| (Y⁻¹ x.1 j.2.1 * D⁻¹ x.2 j.2.2)) = |
| (∑ x : κ, E (s,j.1) x * Y⁻¹ x j.2.1) * D⁻¹ b j.2.2 |
| simp [Fintype.sum_prod_type, Matrix.one_apply, ← mul_assoc, Finset.sum_mul] |
| · change ∑ x : κ × β, (Y i x.1 * C j.1 x.2) * (Y⁻¹ x.1 j.2.1 * D⁻¹ x.2 j.2.2) = _ |
| have hh : (Y ⊗ₖ C) * (Y⁻¹ ⊗ₖ D⁻¹) = (1 : Matrix κ κ ℂ) ⊗ₖ (C * D⁻¹) := by |
| rw [← Matrix.mul_kronecker_mul, Matrix.mul_nonsing_inv _ ((Matrix.isUnit_iff_isUnit_det Y).mp hY)] |
| exact congrFun (congrFun hh (i,j.1)) j.2 |
|
|
| /-- Ordinary matrix row spaces are unchanged by an invertible row multiplier. -/ |
| theorem span_rows_unit_mul {δ : Type} (V : Matrix σ σ ℂ) (R : Matrix σ δ ℂ) |
| (hV : IsUnit V) : |
| Submodule.span ℂ (Set.range (V * R)) = Submodule.span ℂ (Set.range R) := by |
| have le_mul (W : Matrix σ σ ℂ) (S : Matrix σ δ ℂ) : |
| Submodule.span ℂ (Set.range (W * S)) ≤ Submodule.span ℂ (Set.range S) := by |
| apply Submodule.span_le.mpr |
| rintro _ ⟨i,rfl⟩ |
| have hh : (W * S) i = ∑ j, W i j • S j := by ext j; simp [Matrix.mul_apply] |
| rw [hh] |
| exact Submodule.sum_mem _ fun j _ => Submodule.smul_mem _ _ (Submodule.subset_span ⟨j,rfl⟩) |
| apply le_antisymm (le_mul V R) |
| have hh := le_mul V⁻¹ (V * R) |
| rwa [← Matrix.mul_assoc, Matrix.nonsing_inv_mul _ ((Matrix.isUnit_iff_isUnit_det V).mp hV), |
| Matrix.one_mul] at hh |
|
|
| /-- Number of supported scalar positions. -/ |
| noncomputable def nnz {δ : Type} [Fintype δ] (v : δ → ℂ) : ℕ := |
| (Finset.univ.filter fun i => v i ≠ 0).card |
|
|
| theorem nnz_lift_one |
| {α : Type} {β : Type} {σ : Type} {κ : Type} [Fintype α] [Fintype β] [Fintype σ] [Fintype κ] [DecidableEq α] [DecidableEq β] [DecidableEq σ] [DecidableEq κ] (Q : Matrix σ (α × κ) ℂ) (s : σ) (b : β) : |
| nnz (liftRows Q (1 : Matrix β β ℂ) (s,b)) ≤ nnz (Q s) := by |
| classical |
| apply Finset.card_le_card_of_injOn (fun j : α × (κ × β) => (j.1,j.2.1)) |
| · intro j hj |
| simp only [Finset.mem_coe, Finset.mem_filter, Finset.mem_univ, true_and] at hj ⊢ |
| exact (mul_ne_zero_iff.mp hj).1 |
| · intro j hj l hl h |
| simp only [Finset.mem_coe, Finset.mem_filter, Finset.mem_univ, true_and] at hj hl |
| have hjb : j.2.2 = b := by |
| have hn : (1 : Matrix β β ℂ) b j.2.2 ≠ 0 := (mul_ne_zero_iff.mp hj).2 |
| simpa [Matrix.one_apply, eq_comm] using hn |
| have hlb : l.2.2 = b := by |
| have hn : (1 : Matrix β β ℂ) b l.2.2 ≠ 0 := (mul_ne_zero_iff.mp hl).2 |
| simpa [Matrix.one_apply, eq_comm] using hn |
| exact Prod.ext (congrArg (fun z : α × κ => z.1) h) (Prod.ext (congrArg (fun z : α × κ => z.2) h) (hjb.trans hlb.symm)) |
|
|
| theorem nnz_fresh |
| {α : Type} {β : Type} {κ : Type} [Fintype α] [Fintype β] [Fintype κ] [DecidableEq α] [DecidableEq β] [DecidableEq κ] (T : Matrix α β ℂ) (i : κ) : |
| nnz (freshRows T i) ≤ Fintype.card α * Fintype.card β := by |
| classical |
| rw [← Fintype.card_prod] |
| apply Finset.card_le_card_of_injOn (t := Finset.univ) (fun j : α × (κ × β) => (j.1,j.2.2)) |
| · intro j hj; exact Finset.mem_univ _ |
| · intro j hj l hl h |
| simp only [Finset.mem_coe, Finset.mem_filter, Finset.mem_univ, true_and] at hj hl |
| have hji : j.2.1 = i := by |
| have hn : (1 : Matrix κ κ ℂ) i j.2.1 ≠ 0 := (mul_ne_zero_iff.mp hj).1 |
| simpa [Matrix.one_apply, eq_comm] using hn |
| have hli : l.2.1 = i := by |
| have hn : (1 : Matrix κ κ ℂ) i l.2.1 ≠ 0 := (mul_ne_zero_iff.mp hl).1 |
| simpa [Matrix.one_apply, eq_comm] using hn |
| exact Prod.ext (congrArg (fun z : α × β => z.1) h) (Prod.ext (hji.trans hli.symm) (congrArg (fun z : α × β => z.2) h)) |
|
|
| theorem nnz_nextRows (Q : Matrix σ (α × κ) ℂ) (T : Matrix α β ℂ) |
| (hQ : ∀ s, nnz (Q s) ≤ Fintype.card α * Fintype.card β) : |
| ∀ s, nnz (nextRows Q T (1 : Matrix β β ℂ) s) ≤ Fintype.card α * Fintype.card β := by |
| rintro (⟨s,b⟩|i) |
| · exact (nnz_lift_one Q s b).trans (hQ s) |
| · exact nnz_fresh T i |
|
|
| end ExactFourier.Triangular |
|
|
| end |
|
|
| section |
| namespace ExactFourier.Triangular |
| open scoped Kronecker BigOperators |
| open TensorTools |
|
|
| /-- Recursive axis/fiber indexing; no extra workspace is introduced. -/ |
| abbrev Bottom (β : Type) : ℕ → Type |
| | 0 => PUnit |
| | k+1 => Bottom β k × β |
|
|
| abbrev Calls (β : Type) : ℕ → Type |
| | 0 => PEmpty |
| | k+1 => (Calls β k × β) ⊕ Bottom β k |
|
|
| @[reducible] noncomputable instance bottomFintype (β : Type) [Fintype β] : (k : ℕ) → Fintype (Bottom β k) |
| | 0 => inferInstanceAs (Fintype PUnit) |
| | k+1 => letI := bottomFintype β k; inferInstanceAs (Fintype (Bottom β k × β)) |
| @[reducible] noncomputable instance callsFintype (β : Type) [Fintype β] : (k : ℕ) → Fintype (Calls β k) |
| | 0 => inferInstanceAs (Fintype PEmpty) |
| | k+1 => letI := callsFintype β k; inferInstanceAs (Fintype ((Calls β k × β) ⊕ Bottom β k)) |
| @[reducible] instance bottomDecidableEq (β : Type) [DecidableEq β] : (k : ℕ) → DecidableEq (Bottom β k) |
| | 0 => inferInstanceAs (DecidableEq PUnit) |
| | k+1 => letI := bottomDecidableEq β k; inferInstanceAs (DecidableEq (Bottom β k × β)) |
| @[reducible] instance callsDecidableEq (β : Type) [DecidableEq β] : (k : ℕ) → DecidableEq (Calls β k) |
| | 0 => inferInstanceAs (DecidableEq PEmpty) |
| | k+1 => letI := callsDecidableEq β k; inferInstanceAs (DecidableEq ((Calls β k × β) ⊕ Bottom β k)) |
|
|
| variable {α β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] |
|
|
| @[simp] theorem bottom_card_zero |
| {β : Type} [Fintype β] [DecidableEq β] : Fintype.card (Bottom β 0) = 1 := by simp [Bottom] |
| @[simp] theorem calls_card_zero |
| {β : Type} [Fintype β] [DecidableEq β] : Fintype.card (Calls β 0) = 0 := by simp [Calls] |
| @[simp] theorem bottom_card_succ |
| {β : Type} [Fintype β] [DecidableEq β] (k : ℕ) : |
| Fintype.card (Bottom β (k+1)) = Fintype.card (Bottom β k) * Fintype.card β := by |
| simp only [Bottom, Fintype.card_prod] |
| @[simp] theorem calls_card_succ |
| {β : Type} [Fintype β] [DecidableEq β] (k : ℕ) : |
| Fintype.card (Calls β (k+1)) = Fintype.card (Calls β k) * Fintype.card β + Fintype.card (Bottom β k) := by |
| simp only [Calls, Fintype.card_sum, Fintype.card_prod] |
|
|
| theorem calls_card_relation (k : ℕ) : |
| Fintype.card (Calls β k) * Fintype.card β = k * Fintype.card (Bottom β k) := by |
| induction k with |
| | zero => simp |
| | succ k ih => rw [calls_card_succ, bottom_card_succ]; nlinarith |
|
|
| theorem bottom_card_pos (hβ : 0 < Fintype.card β) (k : ℕ) : 0 < Fintype.card (Bottom β k) := by |
| induction k with |
| | zero => simp |
| | succ k ih => rw [bottom_card_succ]; exact Nat.mul_pos ih hβ |
|
|
| noncomputable def tensorPower (D : Matrix β β ℂ) : (k : ℕ) → Matrix (Bottom β k) (Bottom β k) ℂ |
| | 0 => 1 |
| | k+1 => tensorPower D k ⊗ₖ D |
| noncomputable def contamination (C : Matrix α β ℂ) (D : Matrix β β ℂ) : |
| (k : ℕ) → Matrix (Calls β k × α) (Bottom β k) ℂ |
| | 0 => 0 |
| | k+1 => nextE (contamination C D k) (tensorPower D k) C |
| noncomputable def generators (C : Matrix α β ℂ) (D : Matrix β β ℂ) : |
| (k : ℕ) → Matrix (Calls β k) (α × Bottom β k) ℂ |
| | 0 => 0 |
| | k+1 => nextRows (generators C D k) (C * D⁻¹) 1 |
| noncomputable def rowBasis (D : Matrix β β ℂ) : (k : ℕ) → Matrix (Calls β k) (Calls β k) ℂ |
| | 0 => 1 |
| | k+1 => Matrix.fromBlocks (rowBasis D k ⊗ₖ D) 0 0 1 |
|
|
| theorem tensorPower_unit (D : Matrix β β ℂ) (hD : IsUnit D) (k : ℕ) : |
| IsUnit (tensorPower D k) := by |
| induction k with |
| | zero => exact isUnit_one |
| | succ k ih => exact unit_tensor _ _ ih hD |
|
|
| theorem rowBasis_unit (D : Matrix β β ℂ) (hD : IsUnit D) (k : ℕ) : |
| IsUnit (rowBasis D k) := by |
| induction k with |
| | zero => exact isUnit_one |
| | succ k ih => exact Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨unit_tensor _ _ ih hD,isUnit_one⟩ |
|
|
| theorem rowBasis_normalizes (C : Matrix α β ℂ) (D : Matrix β β ℂ) |
| (hD : IsUnit D) (k : ℕ) : |
| rowBasis D k * flat (contamination C D k * (tensorPower D k)⁻¹) = generators C D k := by |
| induction k with |
| | zero => ext i j; exact PEmpty.elim i |
| | succ k ih => |
| change Matrix.fromBlocks (rowBasis D k ⊗ₖ D) 0 0 1 * |
| flat (nextE (contamination C D k) (tensorPower D k) C * (tensorPower D k ⊗ₖ D)⁻¹) = _ |
| rw [flat_next_normalized _ _ _ _ (tensorPower_unit D hD k), nextRows_change _ _ _ _ hD, ih] |
| rfl |
|
|
| theorem generators_sparse (C : Matrix α β ℂ) (D : Matrix β β ℂ) (k : ℕ) : |
| ∀ i, nnz (generators C D k i) ≤ Fintype.card α * Fintype.card β := by |
| induction k with |
| | zero => intro i; exact PEmpty.elim i |
| | succ k ih => exact nnz_nextRows _ _ ih |
|
|
| theorem tensorPower_price (p : MatrixPrice) (D : Matrix β β ℂ) (hD : IsUnit D) (k : ℕ) : |
| p.value (tensorPower D k) = Fintype.card (Calls β k) * p.value D := by |
| induction k with |
| | zero => simp [tensorPower] |
| | succ k ih => |
| rw [tensorPower, p.tensor _ _ (tensorPower_unit D hD k) hD, ih, calls_card_succ] |
| push_cast |
| ring |
|
|
| theorem experiment_price (p : MatrixPrice) (M : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (D : Matrix β β ℂ) (hM : IsUnit M) (hD : IsUnit D) (k : ℕ) : |
| p.value (Matrix.fromBlocks ((1 : Matrix (Calls β k) (Calls β k) ℂ) ⊗ₖ M) |
| (contamination C D k) 0 (tensorPower D k)) ≤ |
| Fintype.card (Calls β k) * p.value (Matrix.fromBlocks M C 0 D) := by |
| induction k with |
| | zero => |
| have h : ((1 : Matrix (Calls β 0) (Calls β 0) ℂ) ⊗ₖ M) = 1 := by |
| ext i j; exact PEmpty.elim i.1 |
| simp only [contamination, tensorPower, h] |
| rw [p.directSum _ _ isUnit_one isUnit_one, p.one, p.one] |
| norm_num |
| | succ k ih => |
| calc |
| _ ≤ Fintype.card β * p.value (Matrix.fromBlocks ((1 : Matrix (Calls β k) (Calls β k) ℂ) ⊗ₖ M) |
| (contamination C D k) 0 (tensorPower D k)) + |
| Fintype.card (Bottom β k) * p.value (Matrix.fromBlocks M C 0 D) := |
| next_price p M C D _ _ hM hD (tensorPower_unit D hD k) |
| _ ≤ Fintype.card β * (Fintype.card (Calls β k) * p.value (Matrix.fromBlocks M C 0 D)) + |
| Fintype.card (Bottom β k) * p.value (Matrix.fromBlocks M C 0 D) := |
| add_le_add (mul_le_mul_of_nonneg_left ih (Nat.cast_nonneg _)) le_rfl |
| _ = _ := by rw [calls_card_succ]; push_cast; ring |
|
|
| end ExactFourier.Triangular |
|
|
| end |
|
|
| section |
| namespace ExactFourier.Triangular |
| open scoped Kronecker BigOperators |
| open TensorTools |
| variable {α σ κ : Type} [Fintype α] [Fintype σ] [Fintype κ] |
| [DecidableEq α] [DecidableEq σ] [DecidableEq κ] |
|
|
| theorem flat_left |
| {α : Type} {σ : Type} {κ : Type} [Fintype α] [Fintype σ] [Fintype κ] [DecidableEq α] [DecidableEq σ] [DecidableEq κ] (V : Matrix σ σ ℂ) (E : Matrix (σ × α) κ ℂ) : |
| flat ((V ⊗ₖ (1 : Matrix α α ℂ)) * E) = V * flat E := by |
| ext s j |
| simp [flat, Matrix.mul_apply, Matrix.kroneckerMap_apply, Fintype.sum_prod_type, Matrix.one_apply] |
|
|
| theorem nnz_flat |
| {α : Type} {σ : Type} {κ : Type} [Fintype α] [Fintype σ] [Fintype κ] [DecidableEq α] [DecidableEq σ] [DecidableEq κ] (E : Matrix (σ × α) κ ℂ) : |
| nnz (fun ij : (σ × α) × κ => E ij.1 ij.2) = ∑ s, nnz (flat E s) := by |
| change nnz (fun ij : (σ × α) × κ => E ij.1 ij.2) = |
| ∑ s, nnz (fun j : α × κ => E (s,j.1) j.2) |
| change (σ × α) → κ → ℂ at E |
| simp only [nnz, Finset.card_eq_sum_ones, Finset.sum_filter, Fintype.sum_prod_type] |
|
|
| theorem nnz_selected_le |
| {σ : Type} [Fintype σ] [DecidableEq σ] {δ : Type} [Fintype δ] (R : Matrix σ δ ℂ) |
| (I : Finset σ) (B : ℕ) (hzero : ∀ i, i ∉ I → R i = 0) |
| (hB : ∀ i ∈ I, nnz (R i) ≤ B) : |
| ∑ i, nnz (R i) ≤ I.card * B := by |
| classical |
| calc |
| _ = ∑ i ∈ I, nnz (R i) := by |
| symm |
| apply Finset.sum_subset (Finset.subset_univ I) |
| intro i hi hn |
| simp [hzero i hn, nnz] |
| _ ≤ ∑ _i ∈ I, B := Finset.sum_le_sum hB |
| _ = _ := by simp |
|
|
| theorem cancellation_identity (M : Matrix α α ℂ) (E : Matrix (σ × α) κ ℂ) |
| (Y : Matrix κ κ ℂ) (V : Matrix σ σ ℂ) (hY : IsUnit Y) : |
| rectangularShear (-((V ⊗ₖ (1 : Matrix α α ℂ)) * (E * Y⁻¹))) * |
| Matrix.fromBlocks (V ⊗ₖ (1 : Matrix α α ℂ)) 0 0 (1 : Matrix κ κ ℂ) * |
| Matrix.fromBlocks ((1 : Matrix σ σ ℂ) ⊗ₖ M) E 0 Y = |
| Matrix.fromBlocks (V ⊗ₖ M) 0 0 Y := by |
| simp only [rectangularShear, Matrix.fromBlocks_multiply, Matrix.one_mul, Matrix.mul_one, |
| Matrix.mul_zero, Matrix.zero_mul, add_zero, zero_add] |
| rw [← Matrix.mul_kronecker_mul, Matrix.mul_one, Matrix.one_mul] |
| congr 1 |
| rw [Matrix.neg_mul, Matrix.mul_assoc, Matrix.mul_assoc, |
| Matrix.nonsing_inv_mul _ ((Matrix.isUnit_iff_isUnit_det Y).mp hY), Matrix.mul_one] |
| exact add_neg_cancel _ |
|
|
| theorem compressed_price (p : MatrixPrice) (M : Matrix α α ℂ) |
| (E : Matrix (σ × α) κ ℂ) (Y : Matrix κ κ ℂ) |
| (hM : IsUnit M) (hY : IsUnit Y) {γ : Type} (Q : γ → α × κ → ℂ) |
| (hspan : Submodule.span ℂ (Set.range (flat (E * Y⁻¹))) = Submodule.span ℂ (Set.range Q)) |
| (B : ℕ) (hQ : ∀ g, nnz (Q g) ≤ B) : |
| Fintype.card σ * p.value M + p.value Y ≤ |
| p.value (Matrix.fromBlocks ((1 : Matrix σ σ ℂ) ⊗ₖ M) E 0 Y) + |
| (Fintype.card α * Fintype.card κ : ℝ) * B := by |
| obtain ⟨V,hV,I,hI,hzero,hbasis⟩ := RowCompression.sparse_row_compression |
| (flat (E * Y⁻¹)) Q hspan |
| let G := (V ⊗ₖ (1 : Matrix α α ℂ)) * (E * Y⁻¹) |
| have hGn : nnz (fun ij : (σ × α) × κ => G ij.1 ij.2) ≤ I.card * B := by |
| rw [nnz_flat, flat_left] |
| apply nnz_selected_le _ I B hzero |
| intro i hi |
| obtain ⟨g,hg⟩ := hbasis i hi |
| rw [hg] |
| exact hQ g |
| have hG : p.value (rectangularShear G) ≤ |
| (Fintype.card α * Fintype.card κ : ℝ) * B := by |
| have hh := p.rectangularShear_sparse G |
| change p.value (rectangularShear G) ≤ (nnz (fun ij : (σ × α) × κ => G ij.1 ij.2) : ℝ) at hh |
| have hc : nnz (fun ij : (σ × α) × κ => G ij.1 ij.2) ≤ |
| (Fintype.card α * Fintype.card κ) * B := |
| hGn.trans (Nat.mul_le_mul_right B (by simpa using hI)) |
| exact hh.trans (by exact_mod_cast hc) |
| have hL : IsUnit (Matrix.fromBlocks (V ⊗ₖ (1 : Matrix α α ℂ)) 0 0 (1 : Matrix κ κ ℂ)) := |
| Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨unit_tensor _ _ hV isUnit_one,isUnit_one⟩ |
| have hT : IsUnit (Matrix.fromBlocks ((1 : Matrix σ σ ℂ) ⊗ₖ M) E 0 Y) := |
| Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨unit_tensor _ _ isUnit_one hM,hY⟩ |
| have hh := p.mul_le |
| (rectangularShear (-G) * Matrix.fromBlocks (V ⊗ₖ (1 : Matrix α α ℂ)) 0 0 (1 : Matrix κ κ ℂ)) |
| (Matrix.fromBlocks ((1 : Matrix σ σ ℂ) ⊗ₖ M) E 0 Y) |
| ((rectangularShear_unit _).mul hL) hT |
| have hl := p.mul_le (rectangularShear (-G)) |
| (Matrix.fromBlocks (V ⊗ₖ (1 : Matrix α α ℂ)) 0 0 (1 : Matrix κ κ ℂ)) |
| (rectangularShear_unit _) hL |
| rw [show rectangularShear (-G) * |
| Matrix.fromBlocks (V ⊗ₖ (1 : Matrix α α ℂ)) 0 0 (1 : Matrix κ κ ℂ) * |
| Matrix.fromBlocks ((1 : Matrix σ σ ℂ) ⊗ₖ M) E 0 Y = |
| Matrix.fromBlocks (V ⊗ₖ M) 0 0 Y from cancellation_identity M E Y V hY, |
| p.directSum _ _ (unit_tensor _ _ hV hM) hY, p.tensor _ _ hV hM] at hh |
| rw [p.identity_pad _ (unit_tensor _ _ hV isUnit_one), p.tensor _ _ hV isUnit_one, |
| p.one, mul_zero, add_zero, p.rectangularShear_neg] at hl |
| linarith |
|
|
| end ExactFourier.Triangular |
|
|
| end |
|
|
| end OAI |
|
|
