| import OAI.Combinatorics.Crossing.NodeMoments |
| import Mathlib.Algebra.MvPolynomial.Degrees |
| import Mathlib.Algebra.MvPolynomial.Rename |
| import Mathlib.Algebra.Polynomial.Derivative |
| import Mathlib.Data.Fin.VecNotation |
| import Mathlib.Basic.Real.Basic |
| import Mathlib.LinearAlgebra.Matrix.BilinearForm |
|
|
| namespace OAI |
|
|
| /-! Polynomial spaces, interpolation weights, crossing tensors, and support evaluation. -/ |
|
|
| section |
|
|
| /-! Polynomial spaces and crossing tensors for complete graphs. |
|
|
| These definitions contain no mathematical theorem assumptions. -/ |
|
|
| open scoped BigOperators Classical |
|
|
| noncomputable section |
|
|
| namespace Paper170 |
|
|
| abbrev Poly2 := MvPolynomial (Fin 2) ℝ |
| abbrev Poly4 := MvPolynomial (Fin 4) ℝ |
|
|
| def nodeWeight {ι : Type*} [Fintype ι] (node : ι → ℝ) (i : ι) : ℝ := |
| (Zarankiewicz.derivativeAtNode node i)⁻¹ |
|
|
| def omittedNodePolynomial {ι : Type*} [Fintype ι] [DecidableEq ι] |
| (node : ι → ℝ) (i : ι) : Polynomial ℝ := |
| ∏ j ∈ Finset.univ.erase i, (Polynomial.X - Polynomial.C (node j)) |
|
|
| def rectangle (a b : ℕ) : Submodule ℝ Poly2 := |
| MvPolynomial.degreesLE ℝ (Fin 2) |
| (Multiset.replicate a 0 + Multiset.replicate b 1) |
|
|
| def box4 (d : ℕ) : Submodule ℝ Poly4 := |
| MvPolynomial.degreesLE ℝ (Fin 4) (d • (Finset.univ : Finset (Fin 4)).val) |
|
|
| def swapFirstPair : Poly4 →ₗ[ℝ] Poly4 := |
| (MvPolynomial.rename (Equiv.swap (0 : Fin 4) 1)).toLinearMap |
|
|
| def swapSecondPair : Poly4 →ₗ[ℝ] Poly4 := |
| (MvPolynomial.rename (Equiv.swap (2 : Fin 4) 3)).toLinearMap |
|
|
| def endpointSymmetricSpace (s : ℕ) : Submodule ℝ Poly4 := |
| box4 (s - 2) ⊓ LinearMap.ker (swapFirstPair - LinearMap.id) ⊓ |
| LinearMap.ker (swapSecondPair - LinearMap.id) |
|
|
| def evalTwo (u v : ℝ) : Poly2 →ₗ[ℝ] ℝ := |
| (MvPolynomial.aeval ![u, v]).toLinearMap |
|
|
| def evalFour (x u y v : ℝ) : Poly4 →ₗ[ℝ] ℝ := |
| (MvPolynomial.aeval ![x, u, y, v]).toLinearMap |
|
|
| /-- The manuscript's one-based L_s, translated to zero-based Fin indices. -/ |
| def evenTriangle (s : ℕ) : Finset (Fin (2 * s) × Fin (2 * s)) := |
| Finset.univ.filter fun pq => |
| (pq.1.val < s ∧ pq.2 < pq.1) ∨ (s ≤ pq.1.val ∧ pq.1 < pq.2) |
|
|
| abbrev EvenTriangleCoord (s : ℕ) := ↥(evenTriangle s) |
|
|
| def triangleEvaluation (s a b : ℕ) (node : Fin (2 * s) → ℝ) : |
| rectangle a b →ₗ[ℝ] (EvenTriangleCoord s → ℝ) := |
| LinearMap.pi fun pq => |
| (evalTwo (node pq.val.1) (node pq.val.2)).comp (rectangle a b).subtype |
|
|
| def halfOrder {ι : Type*} (order : LinearOrder ι) (p q : ι) : ℝ := |
| letI := order |
| if p < q then 1 / 2 else if q < p then -(1 / 2) else 0 |
|
|
| def weightedPairing {ι : Type*} [Fintype ι] |
| (node : ι → ℝ) (K : ι → ι → ℝ) (A B : Poly2) : ℝ := |
| ∑ p, ∑ q, K p q * (node p - node q) / |
| (Zarankiewicz.derivativeAtNode node p * Zarankiewicz.derivativeAtNode node q) * |
| evalTwo (node p) (node q) A * evalTwo (node p) (node q) B |
|
|
| def orderPairing {ι : Type*} [Fintype ι] |
| (node : ι → ℝ) (order : LinearOrder ι) (A B : Poly2) : ℝ := |
| weightedPairing node (halfOrder order) A B |
|
|
| abbrev CrossingTensor (n : ℕ) := Fin n → Fin n → Fin n → Fin n → ℝ |
|
|
| def chainBoundary {n : ℕ} (z : Fin n → Fin n → ℝ) (v : Fin n) : ℝ := |
| (∑ i, z i v) - ∑ p, z v p |
|
|
| def chainPairing {n : ℕ} (J : CrossingTensor n) |
| (z z' : Fin n → Fin n → ℝ) : ℝ := |
| ∑ i, ∑ p, ∑ k, ∑ q, J i p k q * z i p * z' k q |
|
|
| def polynomialTest {n : ℕ} (node : Fin n → ℝ) (J : CrossingTensor n) |
| (H : Poly4) : ℝ := |
| ∑ i, ∑ p, ∑ k, ∑ q, J i p k q * nodeWeight node i * nodeWeight node p * |
| nodeWeight node k * nodeWeight node q * evalFour (node i) (node p) (node k) (node q) H |
|
|
| /-- Canonical orientation within each edge; the two edges remain ordered. -/ |
| def supportedPairs {n : ℕ} (J : CrossingTensor n) : |
| Finset ((Fin n × Fin n) × (Fin n × Fin n)) := |
| Finset.univ.filter fun a => |
| a.1.1 < a.1.2 ∧ a.2.1 < a.2.2 ∧ |
| a.1.1 ≠ a.2.1 ∧ a.1.1 ≠ a.2.2 ∧ |
| a.1.2 ≠ a.2.1 ∧ a.1.2 ≠ a.2.2 ∧ |
| J a.1.1 a.1.2 a.2.1 a.2.2 ≠ 0 |
|
|
| abbrev SupportCoord {n : ℕ} (J : CrossingTensor n) := ↥(supportedPairs J) |
|
|
| def supportEvaluation {n : ℕ} (s : ℕ) (node : Fin n → ℝ) (J : CrossingTensor n) : |
| endpointSymmetricSpace s →ₗ[ℝ] (SupportCoord J → ℝ) := |
| LinearMap.pi fun a => (evalFour (node a.val.1.1) (node a.val.1.2) |
| (node a.val.2.1) (node a.val.2.2)).comp (endpointSymmetricSpace s).subtype |
|
|
| /-- C=(x-y)(x-v)(u-y)(u-v), with coordinates x,u,y,v. -/ |
| def collisionFactor : Poly4 := |
| (MvPolynomial.X 0 - MvPolynomial.X 2) * |
| (MvPolynomial.X 0 - MvPolynomial.X 3) * |
| (MvPolynomial.X 1 - MvPolynomial.X 2) * |
| (MvPolynomial.X 1 - MvPolynomial.X 3) |
|
|
| /-- The complete six-difference product in the source's stated order. -/ |
| def fullDifference : Poly4 := |
| (MvPolynomial.X 0 - MvPolynomial.X 1) * |
| (MvPolynomial.X 2 - MvPolynomial.X 3) * collisionFactor |
|
|
| /-- Substitute x=y=t, leaving u,v as the two variables. -/ |
| def vertexSpecialization (t : ℝ) : Poly4 →ₐ[ℝ] Poly2 := |
| MvPolynomial.aeval ![MvPolynomial.C t, MvPolynomial.X 0, |
| MvPolynomial.C t, MvPolynomial.X 1] |
|
|
| /-- Substitute y=x, leaving x,u,v as three variables. -/ |
| def diagonalSpecialization : Poly4 →ₐ[ℝ] MvPolynomial (Fin 3) ℝ := |
| MvPolynomial.aeval ![MvPolynomial.X 0, MvPolynomial.X 1, |
| MvPolynomial.X 0, MvPolynomial.X 2] |
|
|
| def supportDiagonal {n : ℕ} (node : Fin n → ℝ) (J : CrossingTensor n) |
| (a : SupportCoord J) : ℝ := |
| J a.val.1.1 a.val.1.2 a.val.2.1 a.val.2.2 * |
| nodeWeight node a.val.1.1 * nodeWeight node a.val.1.2 * |
| nodeWeight node a.val.2.1 * nodeWeight node a.val.2.2 * |
| evalFour (node a.val.1.1) (node a.val.1.2) (node a.val.2.1) (node a.val.2.2) |
| fullDifference |
|
|
| def supportBilinear {n : ℕ} (node : Fin n → ℝ) (J : CrossingTensor n) : |
| LinearMap.BilinForm ℝ (SupportCoord J → ℝ) := |
| Matrix.toBilin' (Matrix.diagonal (supportDiagonal node J)) |
|
|
| def weightedChain {n : ℕ} (node : Fin n → ℝ) (a b : ℕ) (i p : Fin n) : ℝ := |
| nodeWeight node i * nodeWeight node p * node i ^ a * node p ^ b |
|
|
| def collisionFactors : Fin 4 → Poly4 := |
| ![MvPolynomial.X 0 - MvPolynomial.X 2, |
| MvPolynomial.X 0 - MvPolynomial.X 3, |
| MvPolynomial.X 1 - MvPolynomial.X 2, |
| MvPolynomial.X 1 - MvPolynomial.X 3] |
|
|
| def liftUnivariate (i : Fin 4) (U : Polynomial ℝ) : Poly4 := |
| Polynomial.aeval (MvPolynomial.X i) U |
|
|
| def liftBivariate (i j : Fin 4) (B : Poly2) : Poly4 := |
| MvPolynomial.aeval ![MvPolynomial.X i, MvPolynomial.X j] B |
|
|
| def localTestPolynomial (P : Poly4) (U V : Polynomial ℝ) (B : Poly2) : Poly4 := |
| P * (MvPolynomial.X 1 - MvPolynomial.X 3) * |
| (MvPolynomial.X 1 - MvPolynomial.X 2) * (MvPolynomial.X 3 - MvPolynomial.X 0) * |
| liftUnivariate 0 U * liftUnivariate 2 V * liftBivariate 1 3 B |
|
|
| end Paper170 |
|
|
| end |
| end |
|
|
| end OAI |
|
|
