| import Mathlib |
| import OAI.Analysis.Crouzeix.NumericalRange |
|
|
| namespace OAI |
|
|
| /-! Exact polynomial compression on spans of finitely many operator iterates. -/ |
|
|
| noncomputable section |
|
|
| open scoped TensorProduct Matrix.Norms.L2Operator InnerProductSpace |
|
|
| open Set |
|
|
| namespace CrouzeixHilbert |
|
|
| universe u |
|
|
| variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H] |
|
|
| def compression (A : Operator H) (E : Submodule ℂ H) [E.HasOrthogonalProjection] : |
| Operator E := E.orthogonalProjectionOnto.comp (A.comp E.subtypeL) |
|
|
| theorem compression_inner (A : Operator H) (E : Submodule ℂ H) |
| [E.HasOrthogonalProjection] (x : E) : |
| ⟪x, compression A E x⟫_ℂ = ⟪(x : H), A (x : H)⟫_ℂ := |
| Submodule.inner_orthogonalProjectionOnto_eq_of_mem_left x (A x) |
|
|
| theorem numericalRange_compression_subset (A : Operator H) (E : Submodule ℂ H) |
| [E.HasOrthogonalProjection] : numericalRange (compression A E) ⊆ numericalRange A := by |
| rintro z ⟨x, hx, hz⟩ |
| exact ⟨(x : H), hx, (compression_inner A E x).symm.trans hz⟩ |
|
|
| theorem coe_compression_apply (A : Operator H) (E : Submodule ℂ H) |
| [E.HasOrthogonalProjection] (x : E) (hx : A (x : H) ∈ E) : |
| (compression A E x : H) = A (x : H) := by |
| have hh := Submodule.orthogonalProjectionOnto_mem_subspace_eq_self (⟨A x, hx⟩ : E) |
| exact congrArg (fun v : E => (v : H)) hh |
|
|
| theorem coe_compression_pow (A : Operator H) (E : Submodule ℂ H) |
| [E.HasOrthogonalProjection] (x : E) (k : ℕ) |
| (hx : ∀ j : ℕ, j ≤ k → (A ^ j) (x : H) ∈ E) : |
| (((compression A E) ^ k) x : H) = (A ^ k) (x : H) := by |
| induction k with |
| | zero => simp |
| | succ k ih => |
| have hk := ih (fun j hj => hx j (hj.trans (Nat.le_succ k))) |
| have hmem : A (((compression A E) ^ k) x : H) ∈ E := by |
| rw [hk] |
| simpa only [pow_succ', mul_apply_eq_comp] using hx (k + 1) le_rfl |
| simpa only [pow_succ', mul_apply_eq_comp] using |
| (coe_compression_apply A E (((compression A E) ^ k) x) hmem).trans (congrArg A hk) |
|
|
| def iterateSpan (A : Operator H) (d : ℕ) {l : ℕ} (ξ : Fin l → H) : Submodule ℂ H := |
| Submodule.span ℂ (Set.range (fun p : Fin (d + 1) × Fin l => (A ^ (p.1 : ℕ)) (ξ p.2))) |
|
|
| instance iterateSpanFiniteDimensional (A : Operator H) (d : ℕ) {l : ℕ} (ξ : Fin l → H) : |
| FiniteDimensional ℂ (iterateSpan A d ξ) := |
| FiniteDimensional.span_of_finite ℂ (Set.finite_range _) |
|
|
| theorem iterate_mem_iterateSpan (A : Operator H) (d : ℕ) {l : ℕ} (ξ : Fin l → H) |
| (j : Fin l) (k : ℕ) (hk : k ≤ d) : (A ^ k) (ξ j) ∈ iterateSpan A d ξ := by |
| apply Submodule.subset_span |
| exact ⟨(⟨k, Nat.lt_succ_of_le hk⟩, j), rfl⟩ |
|
|
| theorem mem_iterateSpan (A : Operator H) (d : ℕ) {l : ℕ} (ξ : Fin l → H) |
| (j : Fin l) : ξ j ∈ iterateSpan A d ξ := by |
| simpa using iterate_mem_iterateSpan A d ξ j 0 (Nat.zero_le _) |
|
|
| def amplificationInclusion (E : Submodule ℂ H) (m : ℕ) : |
| Amplification E m →L[ℂ] Amplification H m := |
| (TensorProduct.mapL E.subtypeL (ContinuousLinearMap.id ℂ (EuclideanSpace ℂ (Fin m)))).completion |
|
|
| theorem norm_amplificationInclusion (E : Submodule ℂ H) (m : ℕ) |
| (x : Amplification E m) : ‖amplificationInclusion E m x‖ = ‖x‖ := by |
| refine UniformSpace.Completion.induction_on x |
| (isClosed_eq (amplificationInclusion E m).continuous.norm continuous_norm) ?_ |
| intro a |
| simp only [amplificationInclusion, ContinuousLinearMap.completion_apply_coe, |
| UniformSpace.Completion.norm_coe] |
| rw [TensorProduct.mapL_apply] |
| change ‖TensorProduct.map E.subtypeₗᵢ.toLinearMap |
| (LinearIsometry.id : EuclideanSpace ℂ (Fin m) →ₗᵢ[ℂ] EuclideanSpace ℂ (Fin m)).toLinearMap a‖ = ‖a‖ |
| exact (TensorProduct.mapIsometry E.subtypeₗᵢ (LinearIsometry.id : |
| EuclideanSpace ℂ (Fin m) →ₗᵢ[ℂ] EuclideanSpace ℂ (Fin m))).norm_map a |
|
|
| @[simp] |
| theorem amplificationInclusion_tmul (E : Submodule ℂ H) {m : ℕ} |
| (x : E) (y : EuclideanSpace ℂ (Fin m)) : |
| amplificationInclusion E m (↑(x ⊗ₜ[ℂ] y)) = |
| (↑((x : H) ⊗ₜ[ℂ] y) : Amplification H m) := by |
| simp [amplificationInclusion, ContinuousLinearMap.completion_apply_coe] |
|
|
| theorem polynomialEval_tmul (A : Operator H) {m d : ℕ} (B : Fin (d + 1) → Coeff m) |
| (x : H) (y : EuclideanSpace ℂ (Fin m)) : |
| polynomialEval A B (↑(x ⊗ₜ[ℂ] y)) = |
| ∑ k : Fin (d + 1), (↑(((A ^ (k : ℕ)) x) ⊗ₜ[ℂ] |
| (Matrix.toEuclideanCLM (𝕜 := ℂ) (n := Fin m) (B k) y)) : Amplification H m) := by |
| simp only [polynomialEval, sum_apply, tensorOperator, |
| ContinuousLinearMap.completion_apply_coe, TensorProduct.mapL_tmul] |
|
|
| theorem polynomial_compression_tmul (A : Operator H) (E : Submodule ℂ H) |
| [E.HasOrthogonalProjection] {m d : ℕ} (B : Fin (d + 1) → Coeff m) |
| (x : E) (y : EuclideanSpace ℂ (Fin m)) |
| (hx : ∀ j : ℕ, j ≤ d → (A ^ j) (x : H) ∈ E) : |
| polynomialEval A B (amplificationInclusion E m (↑(x ⊗ₜ[ℂ] y))) = |
| amplificationInclusion E m (polynomialEval (compression A E) B (↑(x ⊗ₜ[ℂ] y))) := by |
| simp only [amplificationInclusion_tmul, polynomialEval_tmul, map_sum] |
| apply Finset.sum_congr rfl |
| intro k _ |
| rw [coe_compression_pow A E x k (fun j hj => hx j (hj.trans (Nat.le_of_lt_succ k.isLt)))] |
|
|
| theorem completion_coe_finsetSum {V : Type*} [NormedAddCommGroup V] |
| {ι : Type*} (s : Finset ι) (f : ι → V) : |
| (↑(∑ i ∈ s, f i) : UniformSpace.Completion V) = |
| ∑ i ∈ s, (↑(f i) : UniformSpace.Completion V) := |
| map_sum (UniformSpace.Completion.toCompl : V →+ UniformSpace.Completion V) f s |
|
|
| theorem polynomial_bound_of_finite_compressions (A : Operator H) |
| {m d : ℕ} (B : Fin (d + 1) → Coeff m) {C : ℝ} (hC : 0 ≤ C) |
| (hfin : ∀ (E : Submodule ℂ H) [FiniteDimensional ℂ E], |
| ‖polynomialEval (compression A E) B‖ ≤ C) : |
| ‖polynomialEval A B‖ ≤ C := by |
| apply (polynomialEval A B).opNorm_le_bound hC |
| intro x |
| refine UniformSpace.Completion.induction_on x |
| (isClosed_le (polynomialEval A B).continuous.norm (continuous_const.mul continuous_norm)) ?_ |
| intro a |
| obtain ⟨l, ξ, η, ha⟩ := TensorProduct.exists_sum_tmul_eq a |
| let E := iterateSpan A d ξ |
| let xE (j : Fin l) : E := ⟨ξ j, mem_iterateSpan A d ξ j⟩ |
| let v : Amplification E m := ∑ j : Fin l, (↑(xE j ⊗ₜ[ℂ] η j) : Amplification E m) |
| have hav : (↑a : Amplification H m) = amplificationInclusion E m v := by |
| rw [ha, completion_coe_finsetSum] |
| simp only [v, map_sum, amplificationInclusion_tmul] |
| rfl |
| have hinter : polynomialEval A B (amplificationInclusion E m v) = |
| amplificationInclusion E m (polynomialEval (compression A E) B v) := by |
| simp only [v, map_sum] |
| apply Finset.sum_congr rfl |
| intro j _ |
| apply polynomial_compression_tmul |
| intro k hk |
| exact iterate_mem_iterateSpan A d ξ j k hk |
| calc |
| ‖polynomialEval A B (↑a)‖ = |
| ‖amplificationInclusion E m (polynomialEval (compression A E) B v)‖ := by |
| rw [hav, hinter] |
| _ = ‖polynomialEval (compression A E) B v‖ := norm_amplificationInclusion E m _ |
| _ ≤ ‖polynomialEval (compression A E) B‖ * ‖v‖ := |
| (polynomialEval (compression A E) B).le_opNorm v |
| _ ≤ C * ‖v‖ := mul_le_mul_of_nonneg_right (hfin E) (norm_nonneg _) |
| _ = C * ‖(↑a : Amplification H m)‖ := by rw [hav, norm_amplificationInclusion] |
|
|
| theorem polynomial_inequality_of_finite_compressions (A : Operator H) |
| {m d : ℕ} (B : Fin (d + 1) → Coeff m) |
| (hfin : ∀ (E : Submodule ℂ H) [FiniteDimensional ℂ E], |
| ‖polynomialEval (compression A E) B‖ ≤ |
| 2 * supNorm (numericalRange (compression A E)) (matrixPolynomial B)) : |
| ‖polynomialEval A B‖ ≤ 2 * supNorm (numericalRange A) (matrixPolynomial B) := by |
| have hbK := supNorm_bddAbove (isCompact_numericalClosure A) |
| (continuous_matrixPolynomial B).continuousOn |
| have hbW : BddAbove (insert 0 ((fun z => ‖matrixPolynomial B z‖) '' numericalRange A)) := |
| hbK.mono (Set.insert_subset_insert (Set.image_mono subset_closure)) |
| apply polynomial_bound_of_finite_compressions A B |
| (mul_nonneg (by norm_num : (0 : ℝ) ≤ 2) (supNorm_nonneg hbW)) |
| intro E _ |
| exact (hfin E).trans (mul_le_mul_of_nonneg_left |
| (supNorm_mono (numericalRange_compression_subset A E) hbW) (by norm_num)) |
|
|
| end CrouzeixHilbert |
| end |
|
|
| end OAI |
|
|
