Download data/lean/OAI/Combinatorics/GotsmanLinial/GradingShift.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 6.79 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/GotsmanLinial/GradingShift.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/GotsmanLinial/GradingShift.lean
-
curl -L -o GradingShift.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/GotsmanLinial/GradingShift.lean
6.79 kB
| 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 | |