| import OAI.Combinatorics.GotsmanLinial.WeightedGrading |
| import OAI.Combinatorics.GotsmanLinial.ProjectionBlocks |
| import OAI.Combinatorics.GotsmanLinial.CoordinateDegree |
|
|
| namespace OAI |
|
|
| /-! |
| # A degree shift is tridiagonal in the associated orthogonal grading |
|
|
| These lemmas retain the degree-shift premise explicitly. The cube application |
| discharges it using coordinate multiplication and the weighted Fourier flag. |
| -/ |
|
|
| noncomputable section |
|
|
| namespace LeanBlast.GotsmanLinial |
|
|
| section FiniteFlag |
|
|
| variable {𝕜 E : Type*} [RCLike 𝕜] [NormedAddCommGroup E] |
| [InnerProductSpace 𝕜 E] [FiniteDimensional 𝕜 E] |
|
|
| local instance : CompleteSpace E := FiniteDimensional.complete 𝕜 E |
|
|
| /-- An operator that raises the flag index by at most one has no blocks |
| strictly above the first off-diagonal. -/ |
| theorem flagProjection_mul_shift_eq_zero |
| (K : ℕ → Submodule 𝕜 E) (hK : Monotone K) (Z : E →L[𝕜] E) |
| (hshift : ∀ k x, x ∈ K k → Z x ∈ K (k + 1)) |
| {r s : ℕ} (hrs : r + 1 < s) : |
| flagProjection K s * Z * flagProjection K r = 0 := by |
| ext x |
| change flagProjection K s (Z (flagProjection K r x)) = 0 |
| apply flagProjection_apply_eq_zero_of_mem_prev |
| exact hK (by omega : r + 1 + 1 ≤ s) |
| (hshift (r + 1) (flagProjection K r x) (flagProjection_apply_mem_next K r x)) |
|
|
| /-- Self-adjointness gives the other half of the band by taking adjoints. -/ |
| theorem flagProjection_tridiagonal |
| (K : ℕ → Submodule 𝕜 E) (hK : Monotone K) (Z : E →L[𝕜] E) |
| (hZ : IsSelfAdjoint Z) |
| (hshift : ∀ k x, x ∈ K k → Z x ∈ K (k + 1)) |
| {r s : ℕ} (hrs : r + 1 < s ∨ s + 1 < r) : |
| flagProjection K s * Z * flagProjection K r = 0 := by |
| rcases hrs with hrs | hsr |
| · exact flagProjection_mul_shift_eq_zero K hK Z hshift hrs |
| · have h := congrArg star (flagProjection_mul_shift_eq_zero K hK Z hshift hsr) |
| simpa only [star_mul, star_zero, (flagProjection_isSelfAdjoint K r).star_eq, |
| (flagProjection_isSelfAdjoint K s).star_eq, hZ.star_eq, mul_assoc] using h |
|
|
| /-- The band property is preserved by taking matrices or any other ring |
| representation of the operator algebra. -/ |
| theorem map_flagProjection_tridiagonal |
| {A : Type*} [Ring A] (F : (E →L[𝕜] E) →+* A) |
| (K : ℕ → Submodule 𝕜 E) (hK : Monotone K) (Z : E →L[𝕜] E) |
| (hZ : IsSelfAdjoint Z) |
| (hshift : ∀ k x, x ∈ K k → Z x ∈ K (k + 1)) |
| {r s : ℕ} (hrs : r + 1 < s ∨ s + 1 < r) : |
| F (flagProjection K s) * F Z * F (flagProjection K r) = 0 := by |
| rw [← map_mul, ← map_mul, flagProjection_tridiagonal K hK Z hZ hshift hrs, map_zero] |
|
|
| omit [FiniteDimensional 𝕜 E] in |
| /-- Commutation transports a degree-shift statement through a weight map. -/ |
| theorem shift_mem_map_of_commute |
| (V : ℕ → Submodule 𝕜 E) (D Z : E →ₗ[𝕜] E) |
| (hcommute : ∀ x, Z (D x) = D (Z x)) |
| (hshift : ∀ k x, x ∈ V k → Z x ∈ V (k + 1)) |
| (k : ℕ) {x : E} (hx : x ∈ (V k).map D) : |
| Z x ∈ (V (k + 1)).map D := by |
| rcases hx with ⟨y, hy, rfl⟩ |
| exact ⟨Z y, hshift k y hy, (hcommute y).symm⟩ |
|
|
| end FiniteFlag |
|
|
| section MatrixFlag |
|
|
| variable {E ι : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E] |
| [FiniteDimensional ℂ E] [Fintype ι] [DecidableEq ι] |
|
|
| local instance : CompleteSpace E := FiniteDimensional.complete ℂ E |
|
|
| /-- The concrete matrix form consumed by the commutator estimate. -/ |
| theorem operatorMatrix_flagProjection_tridiagonal |
| (b : OrthonormalBasis ι ℂ E) |
| (K : ℕ → Submodule ℂ E) (hK : Monotone K) (Z : E →L[ℂ] E) |
| (hZ : IsSelfAdjoint Z) |
| (hshift : ∀ k x, x ∈ K k → Z x ∈ K (k + 1)) |
| (n : ℕ) (r s : Fin (n + 1)) |
| (hrs : r.val + 1 < s.val ∨ s.val + 1 < r.val) : |
| operatorMatrix b (flagProjection K s.val) * operatorMatrix b Z * |
| operatorMatrix b (flagProjection K r.val) = 0 := by |
| exact map_flagProjection_tridiagonal (operatorMatrixEquiv b).toRingHom |
| K hK Z hZ hshift hrs |
|
|
| end MatrixFlag |
|
|
| section WeightedCube |
|
|
| variable {n : ℕ} |
|
|
| /-- Coordinate signs commute with the actual positive square-root weight. -/ |
| theorem coordinateMultiplier_sqrtWeight_commute |
| (w : Cube n → ℝ) (hw : ∀ x, 0 < w x) (i : Fin n) |
| (a : EuclideanSpace ℂ (Cube n)) : |
| coordinateMultiplier i (sqrtWeightEquiv w hw a) = |
| sqrtWeightEquiv w hw (coordinateMultiplier i a) := by |
| ext x |
| simp only [coordinateMultiplier_apply, sqrtWeightEquiv_apply] |
| exact mul_left_comm _ _ _ |
|
|
| /-- The actual weighted Fourier flag retains the one-step coordinate shift. -/ |
| theorem coordinateMultiplier_weightedFlag_shift |
| (w : Cube n → ℝ) (hw : ∀ x, 0 < w x) (i : Fin n) : |
| ∀ k (a : EuclideanSpace ℂ (Cube n)), |
| a ∈ transportFlag (sqrtWeightEquiv w hw) (fourierFlag n) k → |
| coordinateMultiplier i a ∈ |
| transportFlag (sqrtWeightEquiv w hw) (fourierFlag n) (k + 1) := by |
| intro k a ha |
| exact shift_mem_map_of_commute (fourierFlag n) (sqrtWeightEquiv w hw).toLinearMap |
| (coordinateMultiplier i).toLinearMap |
| (coordinateMultiplier_sqrtWeight_commute w hw i) |
| (coordinateMultiplier_fourierFlag_shift i) k ha |
|
|
| /-- Tridiagonality for the actually constructed weighted Fourier projections, |
| expressed in an arbitrary orthonormal coordinate system. -/ |
| theorem weightedFlag_operatorMatrix_tridiagonal |
| (w : Cube n → ℝ) (hw : ∀ x, 0 < w x) |
| (b : OrthonormalBasis (Cube n) ℂ (EuclideanSpace ℂ (Cube n))) |
| (i : Fin n) (r s : Fin (n + 1)) |
| (hrs : r.val + 1 < s.val ∨ s.val + 1 < r.val) : |
| flagProjectionMatrix b (transportFlag (sqrtWeightEquiv w hw) (fourierFlag n)) s.val * |
| operatorMatrix b (coordinateMultiplier i) * |
| flagProjectionMatrix b (transportFlag (sqrtWeightEquiv w hw) (fourierFlag n)) r.val = 0 := by |
| exact operatorMatrix_flagProjection_tridiagonal b |
| (transportFlag (sqrtWeightEquiv w hw) (fourierFlag n)) |
| (transportFlag_monotone _ _ (fourierFlag_mono n)) |
| (coordinateMultiplier i) (coordinateMultiplier_isSelfAdjoint i) |
| (coordinateMultiplier_weightedFlag_shift w hw i) n r s hrs |
|
|
| /-- The raw coordinate-sign matrices are tridiagonal for the actual weighted |
| Fourier projection family. There is no remaining degree-shift hypothesis. -/ |
| theorem weightedProjectionMatrix_tridiagonal |
| (w : Cube n → ℝ) (hw : ∀ x, 0 < w x) |
| (i : Fin n) (r s : Fin (n + 1)) |
| (hrs : r.val + 1 < s.val ∨ s.val + 1 < r.val) : |
| weightedProjectionMatrix w hw s * coordinateSignMatrix i * |
| weightedProjectionMatrix w hw r = 0 := by |
| simpa only [weightedProjectionMatrix, weightedFourierFlag, coordinateMultiplier, |
| signMultiplier, operatorMatrix_toEuclideanCLM, coordinateSignMatrix] using |
| weightedFlag_operatorMatrix_tridiagonal w hw |
| (EuclideanSpace.basisFun (Cube n) ℂ) i r s hrs |
|
|
| end WeightedCube |
|
|
| end LeanBlast.GotsmanLinial |
|
|
| end |
|
|
| end OAI |
|
|
