| import Mathlib |
|
|
| namespace OAI |
|
|
| /-! The Choi–Lam form, determinant polynomial, root-defined cone, and quadratic deformation. -/ |
|
|
| noncomputable section |
|
|
| open scoped Matrix.Norms.L2Operator |
|
|
| universe u |
|
|
| namespace Paper256 |
|
|
| abbrev Mat (n : ℕ) (R : Type u) := Matrix (Fin n) (Fin n) R |
|
|
| abbrev Sym (n : ℕ) := selfAdjoint (Mat n ℝ) |
| |
| instance instFiniteDimensionalSym (n : ℕ) : FiniteDimensional ℝ (Sym n) := |
| FiniteDimensional.finiteDimensional_submodule (selfAdjoint.submodule ℝ (Mat n ℝ)) |
| |
| abbrev Ambient := (Sym 4 × Sym 4) × (Fin 3 → ℝ) |
| |
| abbrev SymIndex := {ij : Fin 4 × Fin 4 // ij.1 ≤ ij.2} |
| |
| abbrev Coord := (SymIndex ⊕ SymIndex) ⊕ Fin 3 |
| |
| def qMatrix {R : Type u} [CommRing R] (y : Fin 3 → R) : Mat 3 R := |
| fun i j => if i = j then y i ^ 2 + y (i + 1) ^ 2 else -(y i * y j) |
| |
| def phi {R : Type u} [CommRing R] (y : Fin 3 → R) (X : Mat 4 R) : Mat 4 R := |
| fun i j => Fin.cases |
| (Fin.cases |
| (Matrix.trace (qMatrix y * X.submatrix Fin.succ Fin.succ)) |
| (fun j => -(∑ k, X 0 k.succ * qMatrix y k j)) j) |
| (fun i => Fin.cases |
| (-(∑ k, qMatrix y i k * X k.succ 0)) |
| (fun j => X 0 0 * qMatrix y i j) j) i |
| |
| def matrixValue {R : Type u} [CommRing R] |
| (X Z : Mat 4 R) (y : Fin 3 → R) : R := |
| Matrix.det ((Matrix.det X) • Z - phi y (Matrix.adjugate X)) |
| |
| def symmetricCoordinates {R : Type u} (v : SymIndex → R) : Mat 4 R := |
| fun i j => if h : i ≤ j then v ⟨(i, j), h⟩ |
| else v ⟨(j, i), le_of_lt (lt_of_not_ge h)⟩ |
| |
| def polynomial : MvPolynomial Coord ℝ := |
| matrixValue |
| (symmetricCoordinates fun ij => MvPolynomial.X (Sum.inl (Sum.inl ij))) |
| (symmetricCoordinates fun ij => MvPolynomial.X (Sum.inl (Sum.inr ij))) |
| (fun i => MvPolynomial.X (Sum.inr i)) |
| |
| def coordinates (x : Ambient) : Coord → ℝ := |
| Sum.elim (Sum.elim |
| (fun ij => (x.1.1 : Mat 4 ℝ) ij.val.1 ij.val.2) |
| (fun ij => (x.1.2 : Mat 4 ℝ) ij.val.1 ij.val.2)) x.2 |
| |
| def basePoint : Ambient := ((1, 1), 0) |
| |
| def linePolynomial (x : Ambient) : Polynomial ℝ := |
| MvPolynomial.eval₂ Polynomial.C |
| (fun i => Polynomial.C (coordinates basePoint i) * Polynomial.X - |
| Polynomial.C (coordinates x i)) polynomial |
| |
| def cone : Set Ambient := |
| {x | ∀ t : ℂ, (linePolynomial x).aeval t = 0 → t.im = 0 ∧ 0 ≤ t.re} |
| |
| def choiLam {R : Type u} [CommRing R] (z y : Fin 3 → R) : R := |
| (∑ i, z i ^ 2 * y i ^ 2) - |
| 2 * (z 0 * y 0 * z 1 * y 1 + z 0 * y 0 * z 2 * y 2 + |
| z 1 * y 1 * z 2 * y 2) + |
| (∑ i, z i ^ 2 * y (i + 1) ^ 2) |
| |
| def zMatrix {R : Type u} [CommRing R] (z : Fin 3 → R) : Mat 3 R := |
| fun i j => if i = j then z i ^ 2 + z (i + 2) ^ 2 else -(z i * z j) |
| |
| def intervalPolynomial (a b : ℝ) : Polynomial ℝ := |
| (1 - Polynomial.C a⁻¹ * Polynomial.X) * (1 + Polynomial.C b⁻¹ * Polynomial.X) |
| |
| def timeScale (η t : ℝ) : ℝ := 1 + η * Real.sin (Real.pi * t) ^ 2 |
| |
| def deformedPolynomial (a b η t : ℝ) : Polynomial ℝ := |
| (intervalPolynomial a b).comp (Polynomial.C (timeScale η t) * Polynomial.X) |
| |
| def rigidlyConvexSet (p : Polynomial ℝ) : Set ℝ := |
| closure (connectedComponentIn {x : ℝ | p.eval x ≠ 0} 0) |
| |
| open scoped BigOperators RealInnerProductSpace |
| open Set Filter Matrix |
| |
| abbrev Vec (n : ℕ) := EuclideanSpace ℝ (Fin n) |
| |
| def outer {n : ℕ} (v : Vec n) : Mat n ℝ := fun i j => v i * v j |
| |
| def outerSym {n : ℕ} (v : Vec n) : Sym n := |
| ⟨outer v, by |
| change (outer v)ᴴ = outer v |
| ext i j |
| simp [outer, Matrix.conjTranspose_apply, mul_comm]⟩ |
| |
| def operatorNorm {m n : ℕ} (A : Matrix (Fin m) (Fin n) ℝ) : ℝ := |
| ‖A.toEuclideanLin.toContinuousLinearMap‖ |
| |
| def kernelProjection {n : ℕ} (A : Mat n ℝ) : Mat n ℝ := |
| Matrix.toEuclideanLin.symm (A.toEuclideanLin.ker.starProjection.toLinearMap) |
| |
| def inverseSquareRoot {n : ℕ} (A : Sym n) : Mat n ℝ := |
| let hA : (A : Mat n ℝ).IsHermitian := A.property |
| let U : Mat n ℝ := hA.eigenvectorUnitary |
| U * Matrix.diagonal (fun i => (Real.sqrt (hA.eigenvalues i))⁻¹) * Uᴴ |
| |
| / |
| def wedgeCoordinates (v u : Vec 4) : Fin 3 → ℝ := |
| fun i => v 0 * u i.succ - u 0 * v i.succ |
| |
| def tangentCurve (v h : Vec 4) (s : ℝ) : Vec 4 := |
| (Real.sqrt (1 + s ^ 2 * ‖h‖ ^ 2))⁻¹ • (v + s • h) |
| |
| def tangentSpace (v : Vec 4) : Submodule ℝ (Vec 4) := (innerSL ℝ v).ker |
| |
| / |
| structure NormalizedPencil where |
| a : ℕ |
| c : ℕ |
| a_pos : 0 < a |
| c_pos : 0 < c |
| D : Sym 4 →ₗ[ℝ] Sym a |
| E : Sym 4 →ₗ[ℝ] Sym c |
| B : (Fin 3 → ℝ) →ₗ[ℝ] Matrix (Fin a) (Fin c) ℝ |
| D_positive : ∀ X : Sym 4, (X : Mat 4 ℝ).PosSemidef → (D X : Mat a ℝ).PosSemidef |
| E_positive : ∀ X : Sym 4, (X : Mat 4 ℝ).PosSemidef → (E X : Mat c ℝ).PosSemidef |
| D_unital : D 1 = 1 |
| E_unital : E 1 = 1 |
| schur_equivalence : ∀ (X Z : Sym 4) (y : Fin 3 → ℝ) (_hX : (X : Mat 4 ℝ).PosDef), |
| ((Z : Mat 4 ℝ) - phi y (X : Mat 4 ℝ)⁻¹).PosSemidef ↔ |
| ((E Z : Mat c ℝ) - (B y)ᵀ * (D X : Mat a ℝ)⁻¹ * B y).PosSemidef |
|
|
| def NormalizedPencil.leftProjection (P : NormalizedPencil) (v : Vec 4) : Mat P.a ℝ := |
| kernelProjection (P.D (1 - outerSym v) : Mat P.a ℝ) |
|
|
| def NormalizedPencil.rightProjection (P : NormalizedPencil) (v : Vec 4) : Mat P.c ℝ := |
| kernelProjection (P.E (1 - outerSym v) : Mat P.c ℝ) |
|
|
| def deformedPencil (a b η t x : ℝ) : Mat 2 ℝ := |
| Matrix.diagonal ![1 - timeScale η t * x / a, 1 + timeScale η t * x / b] |
|
|
| def deformedCoefficients (a b η t : ℝ) : Fin 3 → ℝ := |
| fun i => (deformedPolynomial a b η t).coeff i.val |
|
|
|
|
| end Paper256 |
|
|
| end |
|
|
| end OAI |
|
|
