Formalization: Generic Separation of Axis-Normalized Latent-Source Representations by Higher-Order Cumulants
The complete Lean development behind this paper — every definition, lemma, and theorem of its module, including helpers the paper text never cites. Identifiers link within this page, into the Causalean library, or out to the official Mathlib docs.
Basic.Cumulants 10 declarations The truncated-cumulant construction
The truncated-cumulant construction
def truncatedCumulant
Stacked joint-cumulant truncation T_L(P), coordinate (r, a) equal to κ_{r,a}(P) = Cum_P(X^{r-a}, Y^a) for 2 ≤ r ≤ L, 0 ≤ a ≤ r, and 0 outside the retained range. @realizes T_L(P),t(coordinatewise κ_{r,a}) @realizes kappa_{r,a}(P)(κ_{r,a} = Cum_P(X^{r-a}, Y^a))
Definition (Lean source)
-- @node: def:truncated-cumulant
noncomputable def truncatedCumulant (μ : Measure Ω) (X Y : Ω → ℝ) (L : ℕ) : CumVec ℝ :=
fun r a => if 2 ≤ r ∧ r ≤ L ∧ a ≤ r then jointCumulant μ X Y (r - a) a else 0
def forwardCumulantMap
Forward simultaneous binary-form map Φ^right_{m,L}, coordinate (r, a): Σ_j c_{jr} u_{j1}^{r-a} u_{j2}^a on the retained range, 0 outside. @realizes Phi^right_{m,L},Phi^left_{m,L}(forward binary-form map)
Definition (Lean source)
-- @node: def:forward-cumulant-map
def forwardCumulantMap {R : Type*} [CommRing R] (m L : ℕ) (θ : ParamSpace R m) : CumVec R :=
fun r a =>
if 2 ≤ r ∧ r ≤ L ∧ a ≤ r then
∑ j : Fin (m + 2),
θ.2.2 j r * (forwardLoading m θ.1 θ.2.1 j).1 ^ (r - a)
* (forwardLoading m θ.1 θ.2.1 j).2 ^ a
else 0
def reverseCumulantMap
Reverse simultaneous binary-form map Φ^left_{m,L}, coordinate (r, a): Σ_j d_{jr} v_{j1}^{r-a} v_{j2}^a on the retained range, 0 outside. @realizes Phi^right_{m,L},Phi^left_{m,L}(reverse binary-form map)
Definition (Lean source)
-- @node: def:reverse-cumulant-map
def reverseCumulantMap {R : Type*} [CommRing R] (m L : ℕ) (η : ParamSpace R m) : CumVec R :=
fun r a =>
if 2 ≤ r ∧ r ≤ L ∧ a ≤ r then
∑ j : Fin (m + 2),
η.2.2 j r * (reverseLoading m η.1 η.2.1 j).1 ^ (r - a)
* (reverseLoading m η.1 η.2.1 j).2 ^ a
else 0
The paper's finite retained-coordinate parameter space, represented inside the function-valued ParamSpace by pinning every off-band source weight to zero.
Definition (Lean source)
def bandSupportedParams {R : Type*} [Zero R] (m L : ℕ) : Set (ParamSpace R m) :=
{ θ | ∀ (j : Fin (m + 2)) (r : ℕ), (r < 2 ∨ L < r) → θ.2.2 j r = 0 }
def genericParameterLocus
Generic retained-cumulant locus Θ^{b,∘}_{m,L}: the direct slope, all pairwise loading-slope differences, and all retained weights are nonzero inside the finite retained-band ambient Θ^b_{m,L}. The same predicate serves both arrows (forward (γ, ρ, c) and reverse (δ, σ, d)). @realizes Theta^{right,circ}_{m,L},Theta^{left,circ}_{m,L}(finite-band ambient and nonvanishing generic product)
Definition (Lean source)
-- @node: def:generic-parameter-loci
def genericParameterLocus {R : Type*} [CommRing R] (m L : ℕ) :
Set (ParamSpace R m) :=
bandSupportedParams m L ∩ { θ |
θ.1 * (∏ i : Fin m, (θ.1 - θ.2.1 i))
* (∏ i : Fin m, ∏ i' : Fin m, if i < i' then θ.2.1 i - θ.2.1 i' else 1)
* (∏ j : Fin (m + 2), ∏ r ∈ Icc 2 L, θ.2.2 j r) ≠ 0 }
theorem genericParameterLocus_bandSupported
A generic parameter lies in the paper's finite retained-band ambient: its source-weight coordinates vanish outside orders two through L.
Formal statement
hypotheses
conclusion
θ ∈ bandSupportedParams m L
Proof (Lean source)
lemma genericParameterLocus_bandSupported {R : Type*} [CommRing R] {m L : ℕ}
{θ : ParamSpace R m} (hθ : θ ∈ genericParameterLocus m L) :
θ ∈ bandSupportedParams m L := hθ.1
theorem genericParameterLocus_prod_ne_zero
At a generic parameter the defining product — direct slope, direct-to-latent slope gaps, pairwise latent slope gaps, and all retained source weights — is nonzero.
Formal statement
hypotheses
Proof (Lean source)
lemma genericParameterLocus_prod_ne_zero {R : Type*} [CommRing R] {m L : ℕ}
{θ : ParamSpace R m} (hθ : θ ∈ genericParameterLocus m L) :
θ.1 * (∏ i : Fin m, (θ.1 - θ.2.1 i))
* (∏ i : Fin m, ∏ i' : Fin m, if i < i' then θ.2.1 i - θ.2.1 i' else 1)
* (∏ j : Fin (m + 2), ∏ r ∈ Icc 2 L, θ.2.2 j r) ≠ 0 := hθ.2
def bandSupportedCumulants
The paper's finite cumulant coordinate space ℂ^{q_L}, represented inside the ℕ-indexed CumVec by pinning every coordinate outside the retained range 2 ≤ r ≤ L, a ≤ r to zero.
Definition (Lean source)
def bandSupportedCumulants {R : Type*} [Zero R] (L : ℕ) : Set (CumVec R) :=
{ t | ∀ r a : ℕ, ¬ (2 ≤ r ∧ r ≤ L ∧ a ≤ r) → t r a = 0 }
def fiberCorrespondence
Full complex fiber R^b_{m,L}(t) = { θ ∈ Θ^b_{m,L} : Φ^b_{m,L}(θ) = t }, parameterized by the arrow map Φ, restricted to the paper's finite retained-coordinate parameter space Θ^b_{m,L} and compared against t on the paper's retained cumulant coordinates 2 ≤ r ≤ L, a ≤ r (i.e. in ℂ^{q_L}).
Definition (Lean source)
-- @node: def:fiber-correspondences
def fiberCorrespondence {R : Type*} [Zero R] (L : ℕ)
(Φ : ParamSpace R m → CumVec R) (t : CumVec R) : Set (ParamSpace R m) :=
bandSupportedParams m L ∩
{ θ | ∀ r a : ℕ, 2 ≤ r → r ≤ L → a ≤ r → Φ θ r a = t r a }
def realFeasibleRegion
Real moment-feasible region F^b_{m,L}: real loading-and-cumulant lists with nonzero direct slope, pairwise-distinct slopes, and every weight family c_{j·} (resp. d_{j·}) realized by a centered non-Gaussian real source law with finite L-th moment. The same predicate serves both arrows.
Definition (Lean source)
-- @node: def:real-feasible-regions
def realFeasibleRegion (m L : ℕ) : Set (ParamSpace ℝ m) :=
{ p |
p.1 ≠ 0 ∧
Injective (Fin.cons p.1 p.2.1 : Fin (m + 1) → ℝ) ∧
-- finite-dimensional cumulant coordinates: every weight coordinate outside
-- the retained band `2 ≤ r ≤ L` is pinned to `0`, so the region lives in
-- `ℝ^{m+1} × ℝ^{n(L-1)}` exactly (retains only the paper's coordinates).
(∀ j : Fin (m + 2), ∀ r : ℕ, (r < 2 ∨ L < r) → p.2.2 j r = 0) ∧
∀ j : Fin (m + 2), ∃ ν : Measure ℝ,
IsProbabilityMeasure ν ∧
(∫ x, x ∂ν = 0) ∧
¬ IsGaussianLaw ν ∧
MemLp (id : ℝ → ℝ) (L : ℝ≥0∞) ν ∧
∀ r, 2 ≤ r → r ≤ L → sourceCumulant ν id r = p.2.2 j r }
Basic.Swaps 7 declarations Admissible source swaps (the G_m action)
Admissible source swaps (the G_m action)
def permMiddle
Relabel the middle block {1, …, m} of source indices by π, fixing 0 and m + 1.
def admissibleSourceSwap
Admissible source swap: π ∈ G_m = Equiv.Perm (Fin m) acts by relabeling the latent slopes ρ_i (resp. σ_i) and their weights c_{ir} (resp. d_{ir}) simultaneously, while fixing indices 0 and m + 1. The same map realizes both arrow actions. @realizes G_m,pi,b(π-relabeling of the middle source block)
Definition (Lean source)
-- @node: def:admissible-source-swaps
def admissibleSourceSwap {R : Type*} (m : ℕ) (π : Perm (Fin m))
(θ : ParamSpace R m) : ParamSpace R m :=
(θ.1, fun i => θ.2.1 (π i), fun j r => θ.2.2 (permMiddle m π j) r)
inductive Arrow
Arrow index b ∈ {right, left}: the two-element type indexing the arrow parameterization on which the G_m action acts (right = forward, left = reverse). @realizes G_m,pi,b(arrow index b ∈ {right, left})
Definition (Lean source)
instance instDecidableEqArrow
Provides a procedure that decides whether two arrow indices are equal, that is, whether two tags both name the forward orientation, both name the reverse one, or differ.
Definition (Lean source)
deriving DecidableEq
def admissibleSourceSwapArrow
Arrow-tagged admissible source swap: the G_m action on arrow b. The same middle-block relabeling formula realizes both the forward (right) action on (ρ_i, c_{ir}) and the reverse (left) action on (σ_i, d_{ir}), so b is a tag; indices 0 and m + 1 are fixed in both cases. @realizes G_m,pi,b(π-relabeling tagged by arrow b; same formula for both)
Definition (Lean source)
def admissibleSourceSwapArrow {R : Type*} (m : ℕ) (_b : Arrow) (π : Perm (Fin m))
(θ : ParamSpace R m) : ParamSpace R m :=
admissibleSourceSwap m π θ
def admissibleSourceSwapTagged
The G_m action on the tagged space Arrow × ParamSpace: relabel the middle source block and preserve the arrow tag b. The swap fixes indices 0, m + 1, so it never converts a forward (right) axis pattern into a reverse (left) one; the tag component is carried unchanged. @realizes G_m,pi,b(tag-preserving G_m action on Arrow × ParamSpace)
Definition (Lean source)
def admissibleSourceSwapTagged {R : Type*} (m : ℕ) (π : Perm (Fin m)) :
Arrow × ParamSpace R m → Arrow × ParamSpace R m :=
fun p => (p.1, admissibleSourceSwap m π p.2)
def arrowTaggedOrbit
Arrow-tagged G_m-orbit of (b, θ): its images under all admissible swaps, every member carrying the same tag b. Right-tagged and left-tagged orbits are therefore disjoint.
Definition (Lean source)
def arrowTaggedOrbit {R : Type*} (m : ℕ) (b : Arrow) (θ : ParamSpace R m) :
Set (Arrow × ParamSpace R m) :=
{ p | ∃ π : Perm (Fin m), p = admissibleSourceSwapTagged m π (b, θ) }
Basic.World 24 declarations The Gaussian-law predicate and the joint / univariate cumulants are general moment-problem objects; they were promoted to Causalean.Stat.MomentProblems and are re-exported here under the run's namespace so the run's stat
Cumulant coordinates (re-imported from Causalean)
The Gaussian-law predicate and the joint / univariate cumulants are general moment-problem
objects; they were promoted to Causalean.Stat.MomentProblems and are re-exported here under the
run's namespace so the run's statements read unchanged.
def numSources
Number of independent sources n = m + 2. @realizes n(n = m+2 sources)
Definition (Lean source)
def numSources (m : ℕ) : ℕ := m + 2
def candidateOrder
Candidate sufficient truncation order K = 2m + 2. @realizes K(K = 2m+2)
Definition (Lean source)
def candidateOrder (m : ℕ) : ℕ := 2 * m + 2
def lowerOrder
One-order-lower truncation K₋ = 2m + 1. @realizes K_-(K₋ = 2m+1)
Definition (Lean source)
def lowerOrder (m : ℕ) : ℕ := 2 * m + 1
def qDim
Observable cumulant-coordinate dimension q_L = L(L+3)/2 - 2. @realizes q_L,p_L(q_L = L(L+3)/2 - 2)
Definition (Lean source)
def qDim (L : ℕ) : ℕ := L * (L + 3) / 2 - 2
def pDim
Structural-parameter dimension p_L = (m+2)L - 1. @realizes q_L,p_L(p_L = (m+2)L - 1)
Definition (Lean source)
def pDim (m L : ℕ) : ℕ := (m + 2) * L - 1
def ValidComplexity
Space of the structural-complexity index m ∈ {1, 2, …}: at least one latent confounder. Every statement in this development is stated for m with this well-formedness clause. @realizes m(m ≥ 1, i.e. m ∈ {1,2,…})
Definition (Lean source)
def ValidComplexity (m : ℕ) : Prop := 1 ≤ m
def ValidOrder
Space of the truncation endpoint L ∈ {2, …, K} with K = 2m + 2: the order variable ranges over the retained cumulant orders. @realizes L(2 ≤ L ≤ 2m + 2)
Definition (Lean source)
def ValidOrder (m L : ℕ) : Prop := 2 ≤ L ∧ L ≤ 2 * m + 2
Structural parameter space Θ^b_{m,L} = R^{m+1} × R^{n(L-1)}. The three components are the direct slope, the m latent-loading slopes, and the source-cumulant weight family (j, r) ↦ c_{jr}. @realizes Theta^right_{m,L},Theta^left_{m,L},theta,eta(coordinates (γ/δ, ρ/σ, c/d)) @realizes gamma(component .1) @realizes rho_i(component .2.1) @realizes delta(component .1) @realizes sigma_i(component .2.1) @realizes c_{jr},d_{jr}(component .2.2 j r)
Definition (Lean source)
Observable truncated-cumulant coordinate vector t ∈ R^{q_L}, indexed by (r, a) with 2 ≤ r ≤ L, 0 ≤ a ≤ r. @realizes T_L(P),t(coordinate family (r,a) ↦ t_{r,a}) @realizes kappa_{r,a}(P)(coordinate (r,a))
Definition (Lean source)
abbrev CumVec (R : Type*) : Type _ := ℕ → ℕ → R
Forward source direction family u_j ∈ R²: u₀ = (1, γ), u_j = (1, ρ_j) for 1 ≤ j ≤ m, u_{m+1} = (0, 1). @realizes u_j(u₀=(1,γ), u_j=(1,ρ_j), u_{m+1}=(0,1))
Definition (Lean source)
def forwardLoading {R : Type*} [CommRing R] (m : ℕ) (γ : R) (ρ : Fin m → R) :
Fin (m + 2) → R × R :=
fun j =>
if _ : j.val = 0 then (1, γ)
else if _ : j.val = m + 1 then (0, 1)
else (1, ρ ⟨j.val - 1, by have := j.isLt; omega⟩)
Reverse source direction family v_j ∈ R²: v₀ = (1, 0), v_j = (σ_j, 1) for 1 ≤ j ≤ m, v_{m+1} = (δ, 1). @realizes v_j(v₀=(1,0), v_j=(σ_j,1), v_{m+1}=(δ,1))
Definition (Lean source)
def reverseLoading {R : Type*} [CommRing R] (m : ℕ) (δ : R) (σ : Fin m → R) :
Fin (m + 2) → R × R :=
fun j =>
if _ : j.val = 0 then (1, 0)
else if _ : j.val = m + 1 then (δ, 1)
else (σ ⟨j.val - 1, by have := j.isLt; omega⟩, 1)
Mutual independence of the m + 2 sources. @realizes S_j(source family S : Fin (m+2) → Ω → ℝ)
Definition (Lean source)
-- @node: ass:independent-sources
def IndependentSources (μ : Measure Ω) {m : ℕ} (S : Fin (m + 2) → Ω → ℝ) : Prop :=
iIndepFun S μ
Finite K-th absolute moment E|S_j|^K < ∞ for every source.
Definition (Lean source)
-- @node: ass:finite-cumulants
def FiniteCumulants (μ : Measure Ω) {m : ℕ} (S : Fin (m + 2) → Ω → ℝ) (K : ℕ) : Prop :=
∀ j, MemLp (S j) (K : ℝ≥0∞) μ
Every source law is non-Gaussian.
Definition (Lean source)
-- @node: ass:source-nongaussianity
def SourceNonGaussian (μ : Measure Ω) {m : ℕ} (S : Fin (m + 2) → Ω → ℝ) : Prop :=
∀ j, ¬ IsGaussianLaw (μ.map (S j))
Forward linear source-mixing structural equation (X, Y)ᵀ = Σ_j u_j S_j. @realizes X(X = Σ_j u_{j1} S_j) @realizes Y(Y = Σ_j u_{j2} S_j)
Definition (Lean source)
-- @node: ass:forward-axis-model
def ForwardAxisModel (X Y : Ω → ℝ) {m : ℕ} (S : Fin (m + 2) → Ω → ℝ)
(γ : ℝ) (ρ : Fin m → ℝ) : Prop :=
(∀ ω, X ω = ∑ j, (forwardLoading m γ ρ j).1 * S j ω) ∧
(∀ ω, Y ω = ∑ j, (forwardLoading m γ ρ j).2 * S j ω)
Reverse linear source-mixing structural equation (X, Y)ᵀ = Σ_j v_j S_j.
Definition (Lean source)
-- @node: ass:reverse-axis-model
def ReverseAxisModel (X Y : Ω → ℝ) {m : ℕ} (S : Fin (m + 2) → Ω → ℝ)
(δ : ℝ) (σ : Fin m → ℝ) : Prop :=
(∀ ω, X ω = ∑ j, (reverseLoading m δ σ j).1 * S j ω) ∧
(∀ ω, Y ω = ∑ j, (reverseLoading m δ σ j).2 * S j ω)
Distinct forward loading directions |{γ, ρ_i}| = m + 1.
Definition (Lean source)
-- @node: ass:forward-noncollinearity
def ForwardNonCollinear {m : ℕ} (γ : ℝ) (ρ : Fin m → ℝ) : Prop :=
Injective (Fin.cons γ ρ : Fin (m + 1) → ℝ)
Distinct reverse loading directions |{δ, σ_i}| = m + 1.
Definition (Lean source)
-- @node: ass:reverse-noncollinearity
def ReverseNonCollinear {m : ℕ} (δ : ℝ) (σ : Fin m → ℝ) : Prop :=
Injective (Fin.cons δ σ : Fin (m + 1) → ℝ)
Nonzero forward direct edge γ ≠ 0. @realizes gamma(γ ≠ 0)
Definition (Lean source)
-- @node: ass:forward-nonzero-edge
def ForwardNonzeroEdge (γ : ℝ) : Prop := γ ≠ 0
Nonzero reverse direct edge δ ≠ 0. @realizes delta(δ ≠ 0)
Definition (Lean source)
Forward bivariate LvLiNGAM class membership of an observational law P ∈ Laws(ℝ²): there exist a probability space (Ω, μ), centered independent non-Gaussian sources S with finite moments through K = 2m + 2, an observed pair (X, Y), and forward loadings (γ, ρ) realizing all six forward modeling assumptions, such that P is the pushforward law of (X, Y) under μ. This is the existential class of laws (not a witness bundle for fixed data): the witnesses are quantified, the sources are centered, and P is pinned as the pushforward law.
Definition (Lean source)
-- @node: def:forward-lvlingam-class
def ForwardLvLiNGAM (P : Measure (ℝ × ℝ)) (m : ℕ) : Prop :=
∃ (Ω : Type) (_ : MeasurableSpace Ω) (μ : Measure Ω)
(S : Fin (m + 2) → Ω → ℝ) (X Y : Ω → ℝ) (γ : ℝ) (ρ : Fin m → ℝ),
IsProbabilityMeasure μ ∧
IndependentSources μ S ∧
FiniteCumulants μ S (2 * m + 2) ∧
SourceNonGaussian μ S ∧
(∀ j, ∫ ω, S j ω ∂μ = 0) ∧
ForwardAxisModel X Y S γ ρ ∧
ForwardNonCollinear γ ρ ∧
ForwardNonzeroEdge γ ∧
P = μ.map (fun ω => (X ω, Y ω))
def ReverseLvLiNGAM
Reverse bivariate LvLiNGAM class membership of an observational law P ∈ Laws(ℝ²), reverse-parameterized: existential centered independent non-Gaussian sources and reverse loadings (δ, σ) whose pushforward law is P.
Definition (Lean source)
-- @node: def:reverse-lvlingam-class
def ReverseLvLiNGAM (P : Measure (ℝ × ℝ)) (m : ℕ) : Prop :=
∃ (Ω : Type) (_ : MeasurableSpace Ω) (μ : Measure Ω)
(S : Fin (m + 2) → Ω → ℝ) (X Y : Ω → ℝ) (δ : ℝ) (σ : Fin m → ℝ),
IsProbabilityMeasure μ ∧
IndependentSources μ S ∧
FiniteCumulants μ S (2 * m + 2) ∧
SourceNonGaussian μ S ∧
(∀ j, ∫ ω, S j ω ∂μ = 0) ∧
ReverseAxisModel X Y S δ σ ∧
ReverseNonCollinear δ σ ∧
ReverseNonzeroEdge δ ∧
P = μ.map (fun ω => (X ω, Y ω))
def ForwardLvLiNGAMRep
A forward LvLiNGAM representation of an observational law by a specified parameter consists of centered independent non-Gaussian sources whose stated loadings and cumulants generate that law.
Definition (Lean source)
def ForwardLvLiNGAMRep (P : Measure (ℝ × ℝ)) (m K : ℕ) (θ : ParamSpace ℝ m) : Prop :=
∃ (Ω : Type) (_ : MeasurableSpace Ω) (μ : Measure Ω)
(S : Fin (m + 2) → Ω → ℝ) (X Y : Ω → ℝ),
IsProbabilityMeasure μ ∧
IndependentSources μ S ∧
FiniteCumulants μ S (2 * m + 2) ∧
SourceNonGaussian μ S ∧
(∀ j, ∫ ω, S j ω ∂μ = 0) ∧
ForwardAxisModel X Y S θ.1 θ.2.1 ∧
ForwardNonCollinear θ.1 θ.2.1 ∧
ForwardNonzeroEdge θ.1 ∧
(∀ (j : Fin (m + 2)) (r : ℕ), 2 ≤ r → r ≤ K →
sourceCumulant μ (S j) r = θ.2.2 j r) ∧
P = μ.map (fun ω => (X ω, Y ω))
def ReverseLvLiNGAMRep
A reverse LvLiNGAM representation of an observational law by a specified parameter consists of centered independent non-Gaussian sources whose stated loadings and cumulants generate that law.
Definition (Lean source)
def ReverseLvLiNGAMRep (P : Measure (ℝ × ℝ)) (m K : ℕ) (η : ParamSpace ℝ m) : Prop :=
∃ (Ω : Type) (_ : MeasurableSpace Ω) (μ : Measure Ω)
(S : Fin (m + 2) → Ω → ℝ) (X Y : Ω → ℝ),
IsProbabilityMeasure μ ∧
IndependentSources μ S ∧
FiniteCumulants μ S (2 * m + 2) ∧
SourceNonGaussian μ S ∧
(∀ j, ∫ ω, S j ω ∂μ = 0) ∧
ReverseAxisModel X Y S η.1 η.2.1 ∧
ReverseNonCollinear η.1 η.2.1 ∧
ReverseNonzeroEdge η.1 ∧
(∀ (j : Fin (m + 2)) (r : ℕ), 2 ≤ r → r ≤ K →
sourceCumulant μ (S j) r = η.2.2 j r) ∧
P = μ.map (fun ω => (X ω, Y ω))
Handles 150 declarations
instance instEncodableDirection
Each causal direction has an effective numerical encoding and decoding.
theorem atlasGaussianRationalIrreducible
Provides the stated computational structure for this data type.
Formal statement
Fact (∀ (q : ℚ), q ^ 2 ≠ -1 + 0 * q)
def atlasGaussianRationalEncodable
Provides an effective numerical encoding for this finite data type.
Definition (Lean source)
noncomputable local instance atlasGaussianRationalEncodable :
Encodable GaussianRational :=
Encodable.ofEquiv (ℚ × ℚ) (QuadraticAlgebra.equivProd (-1) 0)
def workedCompatibilityInstances
Worked compatibility incidence systems A_m — the explicit complex full-fiber incidence equations at the two worked cases m = 1 (K = 4, the 12-equation system A_1) and m = 2 (K = 6, the 25-equation system A_2). A pair (θ, η) of complex loading-and-cumulant lists is in the system iff its forward and reverse simultaneous binary-form decompositions agree at every retained coordinate (r, a) through order K = 2m + 2 — the 12 scalar equations t_{r,a} = c_{0r}γ^a + c_{1r}ρ^a + c_{2r}1{a=r} = d_{0r}1{a=0} + d_{1r}σ^{r-a} + d_{2r}δ^{r-a} for m = 1, and the analogous 25 for m = 2 — and at least one of the two generic-locus inequations holds (θ ∈ Θ^{right,∘} or η ∈ Θ^{left,∘}), matching the paper's generic-locus disjunction. These are the explicit complex incidence equations the note requests (not a real-image complexification). The stated common-axis subfamily is workedCompatibilityCommonAxis below, which is a subset of this system (recorded in oeq:generic-exceptional-locus).
Definition (Lean source)
def workedCompatibilityInstances (m : ℕ) : Set (ParamSpace ℂ m × ParamSpace ℂ m) :=
{ p | (m = 1 ∨ m = 2) ∧
p.1 ∈ bandSupportedParams m (2 * m + 2) ∧
p.2 ∈ bandSupportedParams m (2 * m + 2) ∧
forwardCumulantMap m (2 * m + 2) p.1 = reverseCumulantMap m (2 * m + 2) p.2 ∧
(p.1 ∈ genericParameterLocus m (2 * m + 2) ∨
p.2 ∈ genericParameterLocus m (2 * m + 2)) }
def workedCompatibilityCommonAxis
Common-axis subfamily of the worked incidence systems A_m (m ∈ {1, 2}). Shared across both worked cases: the first latent slope vanishes on both arrows (ρ_1 = 0, σ_1 = 0, read off the loading families at the first middle index), the direct edges are reciprocal (δγ = 1), and the weight relations d_{0r} = c_{1r}, d_{1r} = c_{m+1,r}, d_{m+1,r} = c_{0r}γ^r hold on the retained band (for m = 1 these are d_{1r} = c_{2r}, for m = 2 d_{1r} = c_{3r}; the m = 2-only relations σ₂ρ₂ = 1, d_{2r} = c_{2r}ρ₂^r specialise the same pattern).
Definition (Lean source)
-- Stated over `ℂ` so that it is a subfamily of the complex worked incidence
-- system `workedCompatibilityInstances`.
def workedCompatibilityCommonAxis (m : ℕ) : Set (ParamSpace ℂ m × ParamSpace ℂ m) :=
{ p | (m = 1 ∨ m = 2) ∧
-- the common-axis subfamily lives in the SAME finite ambient
-- `Θ^{right}_{m,K} × Θ^{left}_{m,K}` as `A_m` itself (see
-- `workedCompatibilityInstances`), so both members are band-pinned.
p.1 ∈ bandSupportedParams m (2 * m + 2) ∧
p.2 ∈ bandSupportedParams m (2 * m + 2) ∧
(forwardLoading m p.1.1 p.1.2.1 ⟨1, by omega⟩).2 = 0 ∧
(reverseLoading m p.2.1 p.2.2.1 ⟨1, by omega⟩).1 = 0 ∧
p.2.1 * p.1.1 = 1 ∧
(∀ r, 2 ≤ r → r ≤ 2 * m + 2 →
p.2.2.2 ⟨0, by omega⟩ r = p.1.2.2 ⟨1, by omega⟩ r) ∧
(∀ r, 2 ≤ r → r ≤ 2 * m + 2 →
p.2.2.2 ⟨1, by omega⟩ r = p.1.2.2 ⟨m + 1, by omega⟩ r) ∧
(∀ r, 2 ≤ r → r ≤ 2 * m + 2 →
p.2.2.2 ⟨m + 1, by omega⟩ r = p.1.2.2 ⟨0, by omega⟩ r * p.1.1 ^ r) ∧
-- `m = 2`-only reciprocal second-axis and its weight relation:
-- `σ₂ρ₂ = 1` and `d_{2r} = c_{2r} ρ₂^r`.
(∀ h : m = 2, p.1.2.1 ⟨1, by omega⟩ * p.2.2.1 ⟨1, by omega⟩ = 1) ∧
(∀ h : m = 2, ∀ r, 2 ≤ r → r ≤ 2 * m + 2 →
p.2.2.2 ⟨2, by omega⟩ r = p.1.2.2 ⟨2, by omega⟩ r * (p.1.2.1 ⟨1, by omega⟩) ^ r) }
def workedCompatibilitySystems
Worked compatibility systems A_m (m ∈ {1, 2}) — the full object the paper's def:worked-compatibility-instances defines, bundled so the extracted definition carries both the explicit incidence system and its common-axis subfamily with all its explicit parameter relations (not only the incidence equations):
Definition (Lean source)
-- @node: def:worked-compatibility-instances
def workedCompatibilitySystems (m : ℕ) :
Set (ParamSpace ℂ m × ParamSpace ℂ m) × Set (ParamSpace ℂ m × ParamSpace ℂ m) :=
(workedCompatibilityInstances m,
workedCompatibilityCommonAxis m ∩ workedCompatibilityInstances m)
def compactlySupportedFeasibleRegion
Compactly-supported real feasible region: like realFeasibleRegion but each source law is additionally required to be compactly supported (supported in a bounded set). This is strictly stronger than realFeasibleRegion, which allows arbitrary realizing non-Gaussian laws.
Definition (Lean source)
def compactlySupportedFeasibleRegion (m L : ℕ) : Set (ParamSpace ℝ m) :=
{ p |
p.1 ≠ 0 ∧
Injective (Fin.cons p.1 p.2.1 : Fin (m + 1) → ℝ) ∧
(∀ j : Fin (m + 2), ∀ r : ℕ, (r < 2 ∨ L < r) → p.2.2 j r = 0) ∧
∀ j : Fin (m + 2), ∃ ν : Measure ℝ,
IsProbabilityMeasure ν ∧
(∫ x, x ∂ν = 0) ∧
¬ IsGaussianLaw ν ∧
(∃ B : ℝ, 0 ≤ B ∧ ν {x : ℝ | B < |x|} = 0) ∧
MemLp (id : ℝ → ℝ) (L : ℝ≥0∞) ν ∧
∀ r, 2 ≤ r → r ≤ L → sourceCumulant ν id r = p.2.2 j r }
Real lower-order twin construction handle: existence of forward and reverse parameters whose source cumulant lists are realized by compactly supported non-Gaussian laws (obtained through the truncated-moment-matrix perturbation), and whose axis-conditioned simultaneous binary-form decompositions agree through the one-order-lower truncation K₋ = 2m + 1.
Definition (Lean source)
-- @node: def:real-twin-construction-handle
def realTwinConstructionHandle (m : ℕ) : Prop :=
∃ θ η : ParamSpace ℝ m,
θ ∈ compactlySupportedFeasibleRegion m (2 * m + 1) ∧
η ∈ compactlySupportedFeasibleRegion m (2 * m + 1) ∧
forwardCumulantMap m (2 * m + 1) θ = reverseCumulantMap m (2 * m + 1) η
A cumulant vector has exactly the finite atlas coordinate band 2 ≤ r ≤ 2m+2, 0 ≤ a ≤ r; every other coordinate is zero.
Definition (Lean source)
def IsAtlasBandLimited (m : ℕ) (t : CumVec ℝ) : Prop :=
∀ r a : ℕ, ¬ (2 ≤ r ∧ r ≤ 2 * m + 2 ∧ a ≤ r) → t r a = 0
def realAtlasHandle
Real exceptional-locus atlas handle, forward incidence set Γ_right = {(t, λ) : J_m(t) = 0, Φ^right(λ) = t, right-loading inequalities, Q_K(λ) for every source}, the project's own statable reduction. Here J_m(t) = 0 is realized as t ∈ \bar E_m(ℝ) (membership of the complexified observable in the compatibility closure), the right-loading inequalities are the nonzero direct slope and pairwise-distinct finite slopes, and Q_K is the finite atomic (Hankel-PSD) certificate on each source cumulant list. The reverse mirror is realAtlasHandleReverse. The simultaneous sign-invariant CAD stratification (interface I-3) and the atomic-certificate ↔ real-source equivalence (interface I-4) are external and not built here.
Definition (Lean source)
def realAtlasHandle (m : ℕ) : Set (CumVec ℝ × ParamSpace ℝ m) :=
{ p |
-- observable coordinates above the retained band `K = 2m + 2` are pinned to
-- `0` (the atlas fixes `T_K` and leaves nothing above `K` free):
IsAtlasBandLimited m p.1 ∧
complexifyCumVec p.1 ∈ genericCompatibilityClosure m ∧
-- the parameter `λ` lives in the paper's FINITE ambient `Θ^b_{m,K} = ℝ^{m+1} × ℝ^{n(K-1)}`:
-- every off-band source weight is pinned to `0`. Without this the sections
-- `realAtlasForwardSection` would be cylinders over free off-band weights rather than the
-- band-pinned `R^b_{m,K}(t) ∩ F^b_{m,K}` the note outputs.
p.2 ∈ bandSupportedParams m (2 * m + 2) ∧
forwardCumulantMap m (2 * m + 2) p.2 = p.1 ∧
p.2.1 ≠ 0 ∧
Injective (Fin.cons p.2.1 p.2.2.1 : Fin (m + 1) → ℝ) ∧
∀ j : Fin (m + 2),
atomicCertificate (m + 2) (2 * m + 2) (fun r => if 2 ≤ r then p.2.2.2 j r else 0) }
def realAtlasHandleReverse
Real exceptional-locus atlas handle, reverse incidence set Γ_left = {(t, λ) : J_m(t) = 0, Φ^left(λ) = t, left-loading inequalities, Q_K(λ)} — the reverse mirror of realAtlasHandle, supplying the reverse incidence component the paper's atlas requires.
Definition (Lean source)
def realAtlasHandleReverse (m : ℕ) : Set (CumVec ℝ × ParamSpace ℝ m) :=
{ p |
IsAtlasBandLimited m p.1 ∧
complexifyCumVec p.1 ∈ genericCompatibilityClosure m ∧
-- `λ` lives in the paper's FINITE ambient `Θ^b_{m,K}` (see `realAtlasHandle`).
p.2 ∈ bandSupportedParams m (2 * m + 2) ∧
reverseCumulantMap m (2 * m + 2) p.2 = p.1 ∧
p.2.1 ≠ 0 ∧
Injective (Fin.cons p.2.1 p.2.2.1 : Fin (m + 1) → ℝ) ∧
∀ j : Fin (m + 2),
atomicCertificate (m + 2) (2 * m + 2) (fun r => if 2 ≤ r then p.2.2.2 j r else 0) }
def realAtlasForwardSection
Forward atlas section over an observable t: the t-fiber of the forward incidence set Γ_right, i.e. the local description of R^right_{m,K}(t) ∩ F^right that the atlas outputs cellwise. (The section varies with t; the finite sign-invariant CAD t-cell stratification that makes it constant per cell is the external interface I-3.)
Definition (Lean source)
def realAtlasForwardSection (m : ℕ) (t : CumVec ℝ) : Set (ParamSpace ℝ m) :=
{ lam | (t, lam) ∈ realAtlasHandle m }
def realAtlasReverseSection
Reverse atlas section over t: the t-fiber of Γ_left (local description of R^left_{m,K}(t) ∩ F^left).
Definition (Lean source)
def realAtlasReverseSection (m : ℕ) (t : CumVec ℝ) : Set (ParamSpace ℝ m) :=
{ lam | (t, lam) ∈ realAtlasHandleReverse m }
Forward atlas nonemptiness label ε^right(t): whether the forward incidence stack over t is nonempty — the cell label the CAD stratification attaches.
Definition (Lean source)
Reverse atlas nonemptiness label ε^left(t).
Definition (Lean source)
def AtlasIncidenceCoord
Coordinates of the full CAD incidence system: observable coordinates, loading/cumulant coordinates, and the atomic (w,z) witnesses.
Definition (Lean source)
abbrev AtlasIncidenceCoord (m : ℕ) :=
(ℕ × ℕ) ⊕ RealParamCoord m ⊕ (Fin (m + 2) × Fin (m + 2) × Bool)
def atlasIncidenceCoordDecidableEq
Equality between indices of the atlas-incidence coordinate system can be decided.
Definition (Lean source)
local instance atlasIncidenceCoordDecidableEq (m : ℕ) :
DecidableEq (AtlasIncidenceCoord m) := Classical.decEq _
def atlasPolynomialDecidableEq
Equality between real polynomials in the atlas-incidence coordinates can be decided.
Definition (Lean source)
local instance atlasPolynomialDecidableEq (m : ℕ) :
DecidableEq (MvPolynomial (AtlasIncidenceCoord m) ℝ) := Classical.decEq _
def atlasIncidenceEval
Evaluation of a full incidence polynomial at (t, λ, w, z).
Definition (Lean source)
def atlasIncidenceEval {m : ℕ} (t : CumVec ℝ) (lam : ParamSpace ℝ m)
(w z : Fin (m + 2) → Fin (m + 2) → ℝ) : AtlasIncidenceCoord m → ℝ
| inl ra => t ra.1 ra.2
| inr (inl coord) => realParamEval lam coord
| inr (inr (j, h, isWeight)) => if isWeight then w j h else z j h
A finite polynomial sign presentation is generated from, and defines exactly, one of the two incidence sets Γ_b, including its atomic witnesses.
Definition (Lean source)
def DefinesAtlasIncidenceEquations (m : ℕ) (b : Direction)
(equations nonnegative positive : Finset (MvPolynomial (AtlasIncidenceCoord m) ℝ)) : Prop :=
equations.Nonempty ∧
∀ t lam,
((t, lam) ∈ if b = .forward then realAtlasHandle m else realAtlasHandleReverse m) ↔
(t ∈ bandSupportedCumulants (2 * m + 2) ∧
lam ∈ bandSupportedParams m (2 * m + 2) ∧
∃ w z : Fin (m + 2) → Fin (m + 2) → ℝ,
(∀ P ∈ equations, eval (atlasIncidenceEval t lam w z) P = 0) ∧
(∀ P ∈ nonnegative, 0 ≤ eval (atlasIncidenceEval t lam w z) P) ∧
(∀ P ∈ positive, 0 < eval (atlasIncidenceEval t lam w z) P))
def atlasIncidenceVariableBlock
The block occupied by a concrete coordinate of the full incidence system.
Definition (Lean source)
def atlasIncidenceVariableBlock {m : ℕ} :
AtlasIncidenceCoord m → FiberDecisionVariableBlock
| inl _ => .observable
| inr (inl _) => .loadingAndCumulants
| inr (inr _) => .atomicWitnesses
Every coordinate occurring in an incidence polynomial occurs in the CAD list, and its actual list position obeys the recursive lifting/elimination order: atomic witnesses first, then λ, then the observable base t. The Lean CAD recursion peels and erases the head of this list, so this is the typed orientation of the paper's conventional base-first description t, then λ, then witnesses. Thus the prescribed block relation is a property of order itself, not a separately quantified relation unrelated to the incidence coordinates.
Definition (Lean source)
def IsAtlasIncidenceVariableOrder {m : ℕ}
(incidence : Finset (MvPolynomial (AtlasIncidenceCoord m) ℝ))
(order : List (AtlasIncidenceCoord m)) : Prop :=
(∀ P ∈ incidence, ∀ x ∈ P.vars, x ∈ order) ∧
(∀ x ∈ order, ∀ y ∈ order,
atlasIncidenceVariableBlock x = .atomicWitnesses →
atlasIncidenceVariableBlock y = .loadingAndCumulants →
order.idxOf x < order.idxOf y) ∧
(∀ x ∈ order, ∀ y ∈ order,
atlasIncidenceVariableBlock x = .atomicWitnesses →
atlasIncidenceVariableBlock y = .observable →
order.idxOf x < order.idxOf y) ∧
(∀ x ∈ order, ∀ y ∈ order,
atlasIncidenceVariableBlock x = .loadingAndCumulants →
atlasIncidenceVariableBlock y = .observable →
order.idxOf x < order.idxOf y)
The projection family is generated stage-by-stage from the incidence presentation in an order containing all of its variables in the required blocks.
Definition (Lean source)
def IsGeneratedCADProjectionFamily {m : ℕ}
(incidence : Finset (MvPolynomial (AtlasIncidenceCoord m) ℝ))
(order : List (AtlasIncidenceCoord m))
(projectionFamily : Finset (MvPolynomial (AtlasIncidenceCoord m) ℝ)) : Prop :=
incidence.Nonempty ∧ order.Nodup ∧ IsAtlasIncidenceVariableOrder incidence order ∧
projectionFamily = generatedCADProjectionFamily order incidence
def bandLimitedRealExceptionalLocus
The real exceptional locus in the finite observable coordinate space used by the incidence handles: membership in bar E_m(ℝ) together with zero coordinates off the retained band 2 ≤ r ≤ 2m+2, 0 ≤ a ≤ r.
Definition (Lean source)
def bandLimitedRealExceptionalLocus (m : ℕ) : Set (CumVec ℝ) :=
{ t | IsAtlasBandLimited m t ∧
complexifyCumVec t ∈ genericCompatibilityClosure m }
A retained-observable cell of the paper's finite cumulant coordinate space ℝ^{q_K}: after the off-band coordinates are pinned to zero (bandSupportedCumulants (2m+2)), it is cut out by finitely many real polynomial sign conditions.
Definition (Lean source)
def IsSemialgebraicCumCell (m : ℕ) (cell : Set (CumVec ℝ)) : Prop :=
∃ equations nonnegative positive : Finset (MvPolynomial (ℕ × ℕ) ℝ),
cell = { t |
t ∈ bandSupportedCumulants (2 * m + 2) ∧
(∀ P ∈ equations, eval (fun ra => t ra.1 ra.2) P = 0) ∧
(∀ P ∈ nonnegative, 0 ≤ eval (fun ra => t ra.1 ra.2) P) ∧
(∀ P ∈ positive, 0 < eval (fun ra => t ra.1 ra.2) P) }
def atlasObservableEval
A polynomial has constant sign on a cell.
Definition (Lean source)
def atlasObservableEval {m : ℕ} (t : CumVec ℝ) : AtlasIncidenceCoord m → ℝ
| inl ra => t ra.1 ra.2
| inr _ => 0
A polynomial has the same sign at every pair of observable cumulant vectors in the cell.
Definition (Lean source)
def SignInvariantOn {m : ℕ} (cell : Set (CumVec ℝ))
(P : MvPolynomial (AtlasIncidenceCoord m) ℝ) : Prop :=
∀ t ∈ cell, ∀ t' ∈ cell,
polynomialSign (eval (atlasObservableEval t) P) =
polynomialSign (eval (atlasObservableEval t') P)
Cylindricity of observable cells in lexicographic (r,a) order: whenever two cells meet over the same prefix, their projections to that prefix coincide.
Definition (Lean source)
def CylindricalCumCells {ι : Type} (cell : ι → Set (CumVec ℝ)) : Prop :=
∀ i j, ∀ k : ℕ,
(∃ t ∈ cell i, ∃ t' ∈ cell j,
∀ r a, r < k → t r a = t' r a) →
(∀ t ∈ cell i, ∃ t' ∈ cell j, ∀ r a, r < k → t r a = t' r a) ∨
(∀ t' ∈ cell j, ∃ t ∈ cell i, ∀ r a, r < k → t r a = t' r a)
def AtlasAssignment
A full point of the CAD incidence space, including the atomic witnesses.
Definition (Lean source)
abbrev AtlasAssignment (m : ℕ) := AtlasIncidenceCoord m → ℝ
An actual finite, simultaneous CAD atlas. All arrays are indexed by Fin, so finiteness is data rather than an existential proposition. Its selected cells live in the full (t, λ, w, z) coordinate space, arise by recursive lifting from the incidence-generated projection family, and project exactly to the two feasible fibers over every observable base cell.
Definition (Lean source)
parameters
m :
ℕ
fields
forwardEquations :
forwardNonnegative :
forwardPositive :
reverseEquations :
reverseNonnegative :
reversePositive :
order :
projectionFamily :
forward_presents_incidence :
DefinesAtlasIncidenceEquations m .forward forwardEquations forwardNonnegative forwardPositive
reverse_presents_incidence :
DefinesAtlasIncidenceEquations m .reverse reverseEquations reverseNonnegative reversePositive
projection_generated :
IsGeneratedCADProjectionFamily (forwardEquations ∪ forwardNonnegative ∪ forwardPositive ∪ reverseEquations ∪ reverseNonnegative ∪ reversePositive) order projectionFamily
baseCellCount :
ℕ
base_semialgebraic :
∀ i, IsSemialgebraicCumCell m (baseCell i)
base_cylindrical :
CylindricalCumCells baseCell
base_disjoint :
∀ i j
if
i ≠ j
then
Disjoint (baseCell i) (baseCell j)
base_covers :
(⋃ i, baseCell i) = bandLimitedRealExceptionalLocus m
projection_sign_invariant :
∀ i P
if
P ∈ projectionFamily
then
SignInvariantOn (baseCell i) P
labels_exact :
∀ i t
if
t ∈ baseCell i
then
(forwardLabel i = true ↔ realAtlasForwardLabel m t) ∧
(reverseLabel i = true ↔ realAtlasReverseLabel m t)
forwardCellCount :
Fin baseCellCount → ℕ
reverseCellCount :
Fin baseCellCount → ℕ
forwardCell :
∀ i
if
Fin (forwardCellCount i)
then
Set (AtlasAssignment m)
reverseCell :
∀ i
if
Fin (reverseCellCount i)
then
Set (AtlasAssignment m)
The recursion starts from the INCIDENCE presentation and projects on each descent (BPR's stage-specific `C_i`), exactly as the cited `IsAdaptedCAD.recursively_lifted` does. Starting it from the already fully-accumulated `projectionFamily` would not match the cited theorem.
forward_recursive :
∀ i k,
IsRecursivelyLiftedCADCell (forwardEquations ∪ forwardNonnegative ∪ forwardPositive ∪ reverseEquations ∪ reverseNonnegative ∪ reversePositive) order (forwardCell i k)
reverse_recursive :
∀ i k,
IsRecursivelyLiftedCADCell (forwardEquations ∪ forwardNonnegative ∪ forwardPositive ∪ reverseEquations ∪ reverseNonnegative ∪ reversePositive) order (reverseCell i k)
forward_fiber_exact :
∀ i t
if
t ∈ baseCell i
then
{lam | ∃ w z, ∃ k, atlasIncidenceEval t lam w z ∈ forwardCell i k}
= realAtlasForwardSection m t
reverse_fiber_exact :
∀ i t
if
t ∈ baseCell i
then
{lam | ∃ w z, ∃ k, atlasIncidenceEval t lam w z ∈ reverseCell i k}
= realAtlasReverseSection m t
def AtlasFiberCoord
Coordinates remaining after the atomic moment witnesses have been eliminated: the retained observable coordinates t, followed by the structural coordinates lambda.
Definition (Lean source)
abbrev AtlasFiberCoord (m : ℕ) := (ℕ × ℕ) ⊕ RealParamCoord m
def AtlasFiberAssignment
A point of the witness-eliminated (t, lambda) coordinate space.
Definition (Lean source)
abbrev AtlasFiberAssignment (m : ℕ) := AtlasFiberCoord m → ℝ
def AtlasComplexIncidenceCoord
Coordinates of the complex generic two-arrow incidence used in Step 2: observable cumulants, forward parameters, reverse parameters, and one saturation coordinate for each arrow-genericity product. Atomic real moment witnesses do not occur in this coordinate type.
Definition (Lean source)
def atlasFiberEval
Evaluation of a witness-eliminated fiber polynomial at (t, lambda).
Definition (Lean source)
def atlasFiberEval {m : ℕ} (t : CumVec ℝ) (lam : ParamSpace ℝ m) :
AtlasFiberAssignment m
| inl ra => t ra.1 ra.2
| inr coord => realParamEval lam coord
def atlasFiberCoordDecidableEq
Equality on the witness-eliminated coordinate index.
Definition (Lean source)
local instance atlasFiberCoordDecidableEq (m : ℕ) :
DecidableEq (AtlasFiberCoord m) := Classical.decEq _
def atlasFiberVariableBlock
The variable block occupied by a witness-eliminated fiber coordinate.
Definition (Lean source)
def atlasFiberVariableBlock {m : ℕ} :
AtlasFiberCoord m → FiberDecisionVariableBlock
| inl _ => .observable
| inr _ => .loadingAndCumulants
The recursive fiber CAD eliminates the structural lambda prefix before reaching the observable base. Since IsRecursivelyLiftedCADCell peels the head of its order, every displayed loading/cumulant coordinate must precede every displayed observable coordinate.
Definition (Lean source)
def IsAtlasFiberVariableOrder {m : ℕ} (order : List (AtlasFiberCoord m)) : Prop :=
∀ x ∈ order, ∀ y ∈ order,
atlasFiberVariableBlock x = .loadingAndCumulants →
atlasFiberVariableBlock y = .observable →
order.idxOf x < order.idxOf y
def atlasObservablePolynomialDecidableEq
Equality on observable polynomials used by the finite sign-oracle program.
Definition (Lean source)
local instance atlasObservablePolynomialDecidableEq :
DecidableEq (MvPolynomial (ℕ × ℕ) ℝ) := Classical.decEq _
def atlasComplexIncidenceCoordDecidableEq
Provides a procedure that decides whether two coordinates of the complex generic two-arrow incidence space are equal.
Definition (Lean source)
local instance atlasComplexIncidenceCoordDecidableEq (m : ℕ) :
DecidableEq (AtlasComplexIncidenceCoord m) := Classical.decEq _
def atlasComplexIncidencePolynomialDecidableEq
Provides a procedure that decides whether two complex polynomials in the generic two-arrow incidence coordinates are equal.
Definition (Lean source)
local instance atlasComplexIncidencePolynomialDecidableEq (m : ℕ) :
DecidableEq (MvPolynomial (AtlasComplexIncidenceCoord m) ℂ) := Classical.decEq _
def atlasComplexObservablePolynomialDecidableEq
Provides a procedure that decides whether two complex polynomials in the observable cumulant coordinates are equal.
Definition (Lean source)
local instance atlasComplexObservablePolynomialDecidableEq :
DecidableEq (MvPolynomial (ℕ × ℕ) ℂ) := Classical.decEq _
One exhaustive row of the finite exact-real sign-oracle lookup program.
Definition (Lean source)
fields
A finite sign-oracle program. Its only real-number primitive is exact sign evaluation of the displayed finite polynomial test list; no computable comparison operation on arbitrary real inputs is asserted.
Definition (Lean source)
fields
tests :
List (MvPolynomial (ℕ × ℕ) ℝ)
tests_nodup :
tests.Nodup
rows :
row_width :
∀ row ∈ rows, row.signs.length = tests.length
rows_exhaustive :
∀ signs : List PolynomialSign
if
signs.length = tests.length
then
∃ row ∈ rows, row.signs = signs
rows_functional :
∀ row₁ ∈ rows,
∀ row₂ ∈ rows,
row₁.signs = row₂.signs → row₁.forwardValue = row₂.forwardValue ∧
row₁.reverseValue = row₂.reverseValue
def AtlasExactSignOracle
The only non-discrete primitive used when an atlas program is evaluated: an exact sign query for a displayed observable polynomial.
Definition (Lean source)
An oracle answers each query by the mathematical sign of the corresponding real polynomial value. This is an exact-real oracle contract, not a claim that comparison of arbitrary real numbers is Turing computable.
Definition (Lean source)
def IsExactAtlasSignOracle (oracle : AtlasExactSignOracle) : Prop :=
∀ P t, oracle P t = polynomialSign
(eval (fun ra => t ra.1 ra.2) P)
def evaluateWith
Evaluate the finite lookup program relative to an exact-sign oracle. Once the finite sign answers are supplied, this is ordinary executable list lookup; no noncomputable comparison on ℝ occurs in this interpreter.
Definition (Lean source)
def AtlasSignOracleProgram.evaluateWith
(program : AtlasSignOracleProgram) (oracle : AtlasExactSignOracle)
(t : CumVec ℝ) : Bool × Bool :=
let signs := program.tests.map fun P => oracle P t
match program.rows.find? (fun row => row.signs = signs) with
| some row => (row.forwardValue, row.reverseValue)
| none => (false, false)
def exactAtlasSignOracle
The canonical mathematical exact-sign oracle.
Definition (Lean source)
noncomputable def exactAtlasSignOracle : AtlasExactSignOracle := fun P t =>
polynomialSign (eval (fun ra => t ra.1 ra.2) P)
theorem exactAtlasSignOracle_isExact
The canonical sign oracle is exact: for every displayed observable polynomial and every vector of observable cumulants it returns the mathematical sign of the real value that polynomial takes there.
Formal statement
conclusion
Proof (Lean source)
theorem exactAtlasSignOracle_isExact :
IsExactAtlasSignOracle exactAtlasSignOracle := by
intro P t
rfl
inductive AtlasTraceFamily
Families carried between the full incidence, witness-eliminated fiber, and observable stages of the certified symbolic construction.
Definition (Lean source)
inductive AtlasTraceFamily (m : ℕ)
| complexIncidence
(family : Finset (MvPolynomial (AtlasComplexIncidenceCoord m) ℂ))
| complexObservable (family : Finset (MvPolynomial (ℕ × ℕ) ℂ))
| incidence (family : Finset (MvPolynomial (AtlasIncidenceCoord m) ℝ))
| fiber (family : Finset (MvPolynomial (AtlasFiberCoord m) ℝ))
| observable (family : Finset (MvPolynomial (ℕ × ℕ) ℝ))
def atlasObservableIncidenceFamily
View an observable polynomial family inside the full incidence coordinate space. This is how the dependent intersection basis is supplied to the final simultaneous real CAD/QE job.
Definition (Lean source)
noncomputable def atlasObservableIncidenceFamily (m : ℕ)
(family : Finset (MvPolynomial (ℕ × ℕ) ℝ)) :
Finset (MvPolynomial (AtlasIncidenceCoord m) ℝ) := by
classical
exact family.image fun P => P.rename inl
inductive AtlasTraceOperation
Operations appearing in the paper's finite elimination/projection/lifting construction trace.
Definition (Lean source)
inductive AtlasTraceOperation
| saturationGroebnerElimination (b : Direction)
| idealIntersection
| realImaginarySplit
| cadBuchberger
| cadElimination
| cadIdealIntersection
| cadSaturation
| cadReductaGeneration
| coefficientProjection
| discriminantProjection
| principalSubresultantProjection
| cadProjectionClosure
| prefixCellProjection
| witnessCellRetention (b : Direction) (baseIndex cellIndex : ℕ)
| realRootIsolation
| sectionLifting
| sectorLifting
| signConditionTruth
deriving DecidableEq, Encodable
instance instDecidableEqAtlasTraceOperation
Atlas trace operations have a decidable equality test: any two operations can be effectively determined to be the same or different.
Definition (Lean source)
deriving DecidableEq, Encodable
instance instEncodableAtlasTraceOperation
Every atlas trace operation has an effective numerical encoding and decoding.
Definition (Lean source)
deriving DecidableEq, Encodable
inductive AtlasRationalAlgebraJob
The three rational algebra jobs used by the paper-specific atlas. The general cited interface also supports Gaussian-rational jobs, but this atlas starts from rational incidence equations and casts their outputs to ℂ, so its Gaussian batch is empty.
Definition (Lean source)
inductive AtlasRationalAlgebraJob
| forwardElimination
| reverseElimination
| observableIntersection
deriving DecidableEq, Encodable
instance instDecidableEqAtlasRationalAlgebraJob
The three rational algebra jobs of the paper-specific atlas have a decidable equality test: any two of them can be effectively determined to be the same or different.
Definition (Lean source)
deriving DecidableEq, Encodable
instance instEncodableAtlasRationalAlgebraJob
Each of the three rational algebra jobs of the paper-specific atlas can be encoded as a natural number and decoded back, so the type is countable.
Definition (Lean source)
deriving DecidableEq, Encodable
inductive AtlasCitedPrimitiveCharge
One primitive operation charged by the cited effective computations, with both its paper-side source job and its cited high-level trace stage retained. This is the bridge between the semantic atlas trace and the primitive cost model; it is deliberately unrelated to partial-recursive machine fuel.
Definition (Lean source)
inductive AtlasCitedPrimitiveCharge
| rationalAlgebra (job : AtlasRationalAlgebraJob)
(stage : EffectiveGroebnerTraceOperation)
(primitive : EffectiveGroebnerPrimitiveOperation)
| rationalCAD (sourceStepIndex : ℕ) (stage : EffectiveAlgebraTraceOperation)
(primitive : EffectiveRealAlgebraicPrimitiveOperation)
The actual combined cited result consumed by one paper-specific atlas: exactly two rational incidence-elimination jobs, one rational observable-ideal intersection job, no Gaussian-rational job, and one rational CAD/QE job. The three machine codes are kept distinct, as in the cited combined interface.
Definition (Lean source)
fields
rationalAlgebraMachine :
gaussianAlgebraMachine :
rationalCADMachine :
forwardEliminationJob :
reverseEliminationJob :
The caller-supplied identification of forward and reverse source
coordinates. The certified paper trace below closes this abstract relation
against equality of the displayed observable-coordinate maps.
The cited rational execution is sequential: the observable-intersection
job is constructed only from the two saturated elimination outputs.
dependentPipeline :
EffectiveDependentRationalEliminationPipeline rationalAlgebraMachine forwardEliminationJob reverseEliminationJob sharedCoordinateRelation
gaussianResults :
EffectiveGroebnerBatchResultsOver GaussianRational gaussianAlgebraMachine []
The CAD/QE input is indexed by, and definitionally carried with, the
completed forward/reverse/dependent-intersection pipeline.
dependentCADJob :
EffectiveDependentRationalCADJob dependentPipeline
cadResult :
EffectiveRationalCADCompletedJob rationalCADMachine dependentCADJob.job
def observableIntersectionJob
The observable intersection job constructed by the dependent cited run.
Definition (Lean source)
def AtlasCitedEffectiveExecution.observableIntersectionJob
(execution : AtlasCitedEffectiveExecution) : EffectiveGroebnerJobOver ℚ :=
execution.dependentPipeline.intersectionJob
def cadJob
The rational CAD job consuming the exact dependent intersection result.
Definition (Lean source)
def AtlasCitedEffectiveExecution.cadJob
(execution : AtlasCitedEffectiveExecution) : EffectiveRationalCADJob :=
execution.dependentCADJob.job
def rationalResults
The dependent execution, viewed as the three-result batch used by the generic combined cost bookkeeping.
Definition (Lean source)
def AtlasCitedEffectiveExecution.rationalResults
(execution : AtlasCitedEffectiveExecution) :
EffectiveGroebnerBatchResultsOver ℚ execution.rationalAlgebraMachine
[execution.forwardEliminationJob, execution.reverseEliminationJob,
execution.observableIntersectionJob] :=
.cons execution.dependentPipeline.forwardResult
(.cons execution.dependentPipeline.reverseResult
(.cons execution.dependentPipeline.intersectionResult .nil))
def rationalJobs
The rational job list supplied to the combined cited bound.
Definition (Lean source)
def AtlasCitedEffectiveExecution.rationalJobs
(execution : AtlasCitedEffectiveExecution) : List (EffectiveGroebnerJobOver ℚ) :=
[execution.forwardEliminationJob, execution.reverseEliminationJob,
execution.observableIntersectionJob]
def gaussianJobs
The paper-specific Gaussian-rational job list is exactly empty.
Definition (Lean source)
def AtlasCitedEffectiveExecution.gaussianJobs
(_execution : AtlasCitedEffectiveExecution) :
List (EffectiveGroebnerJobOver GaussianRational) :=
[]
def atlasRationalBatchPrimitiveCharges
Primitive charges of the specialized three-job rational batch, retaining which of the forward, reverse, or intersection results produced each charge.
Definition (Lean source)
def atlasRationalBatchPrimitiveCharges
{machineCode : Code}
{forwardJob reverseJob intersectionJob : EffectiveGroebnerJobOver ℚ} :
EffectiveGroebnerBatchResultsOver ℚ machineCode
[forwardJob, reverseJob, intersectionJob] → List AtlasCitedPrimitiveCharge
| .cons forwardResult (.cons reverseResult (.cons intersectionResult .nil)) =>
(forwardResult.result.payload.trace.flatMap fun step =>
step.primitiveOperations.map fun primitive =>
.rationalAlgebra .forwardElimination step.operation primitive) ++
(reverseResult.result.payload.trace.flatMap fun step =>
step.primitiveOperations.map fun primitive =>
.rationalAlgebra .reverseElimination step.operation primitive) ++
(intersectionResult.result.payload.trace.flatMap fun step =>
step.primitiveOperations.map fun primitive =>
.rationalAlgebra .observableIntersection step.operation primitive)
def atlasRationalCADPrimitiveChargesFrom
Primitive charges of rational CAD source steps, indexed from a supplied offset so the paper-side slice can point back to the exact source step.
Definition (Lean source)
def atlasRationalCADPrimitiveChargesFrom :
ℕ → {r : ℕ} → List (EffectiveAlgebraTraceStep r) →
List AtlasCitedPrimitiveCharge
| _, _, [] => []
| sourceStepIndex, _, step :: steps =>
(step.primitiveOperations.map fun primitive =>
.rationalCAD sourceStepIndex step.operation primitive) ++
atlasRationalCADPrimitiveChargesFrom (sourceStepIndex + 1) steps
def atlasRationalCADPrimitiveCharges
Primitive charges of the one rational real-CAD/QE result.
Definition (Lean source)
def atlasRationalCADPrimitiveCharges
{machineCode : Code} {job : EffectiveRationalCADJob}
(result : EffectiveRationalCADCompletedJob machineCode job) :
List AtlasCitedPrimitiveCharge :=
atlasRationalCADPrimitiveChargesFrom 0 result.result.payload.trace
theorem atlasRationalCADPrimitiveChargesFrom_length
Charging a real-algebraic CAD trace bills exactly one primitive charge per primitive operation: the resulting charge list is as long as the total number of primitive operations recorded across the trace steps. The offset at which the source steps are indexed does not change the count.
Formal statement
hypotheses
conclusion
(atlasRationalCADPrimitiveChargesFrom sourceStepIndex steps).length
= (steps.map EffectiveAlgebraTraceStep.operationCount).sum
Proof (Lean source)
theorem atlasRationalCADPrimitiveChargesFrom_length
(sourceStepIndex : ℕ) {r : ℕ} (steps : List (EffectiveAlgebraTraceStep r)) :
(atlasRationalCADPrimitiveChargesFrom sourceStepIndex steps).length =
(steps.map EffectiveAlgebraTraceStep.operationCount).sum := by
induction steps generalizing sourceStepIndex with
| nil => simp [atlasRationalCADPrimitiveChargesFrom]
| cons step steps ih =>
simp [atlasRationalCADPrimitiveChargesFrom,
EffectiveAlgebraTraceStep.operationCount, ih]
def primitiveCharges
Complete cited primitive stream for the paper-specific combined run. No Gaussian charges occur because gaussianResults is indexed by the empty job list.
Definition (Lean source)
def AtlasCitedEffectiveExecution.primitiveCharges
(execution : AtlasCitedEffectiveExecution) : List AtlasCitedPrimitiveCharge :=
atlasRationalBatchPrimitiveCharges execution.rationalResults ++
atlasRationalCADPrimitiveCharges execution.cadResult
def symbolicOperationCount
The exact operation count on the left side of the cited combined bound.
Definition (Lean source)
def AtlasCitedEffectiveExecution.symbolicOperationCount
(execution : AtlasCitedEffectiveExecution) : ℕ :=
execution.rationalResults.symbolicOperationCount +
execution.gaussianResults.symbolicOperationCount +
execution.cadResult.result.payload.symbolicOperationCount
def forwardResult
The completed forward job stored in the specialized rational batch.
Definition (Lean source)
def AtlasCitedEffectiveExecution.forwardResult
(execution : AtlasCitedEffectiveExecution) :
EffectiveGroebnerCompletedJobOver ℚ execution.rationalAlgebraMachine
execution.forwardEliminationJob :=
execution.dependentPipeline.forwardResult
def reverseResult
The completed reverse job stored in the specialized rational batch.
Definition (Lean source)
def AtlasCitedEffectiveExecution.reverseResult
(execution : AtlasCitedEffectiveExecution) :
EffectiveGroebnerCompletedJobOver ℚ execution.rationalAlgebraMachine
execution.reverseEliminationJob :=
execution.dependentPipeline.reverseResult
def intersectionResult
The completed observable-ideal intersection job stored in the specialized rational batch.
Definition (Lean source)
def AtlasCitedEffectiveExecution.intersectionResult
(execution : AtlasCitedEffectiveExecution) :
EffectiveGroebnerCompletedJobOver ℚ execution.rationalAlgebraMachine
execution.observableIntersectionJob :=
execution.dependentPipeline.intersectionResult
def rationalFamilyToComplexAlong
Rename a finite rational polynomial family into a displayed coordinate type and extend coefficients to ℂ. The embedding is explicit, so finite effective coordinates cannot be silently identified with unrelated paper coordinates.
Definition (Lean source)
noncomputable def rationalFamilyToComplexAlong {r : ℕ} {σ : Type}
[DecidableEq σ] (embedding : Fin r ↪ σ)
(family : Finset (MvPolynomial (Fin r) ℚ)) :
Finset (MvPolynomial σ ℂ) := by
classical
exact family.image fun P => (P.map (Rat.castHom ℂ)).rename embedding
def rationalFamilyToRealAlong
Rename a finite rational polynomial family into a displayed coordinate type and extend coefficients to ℝ.
Definition (Lean source)
noncomputable def rationalFamilyToRealAlong {r : ℕ} {σ : Type}
[DecidableEq σ] (embedding : Fin r ↪ σ)
(family : Finset (MvPolynomial (Fin r) ℚ)) :
Finset (MvPolynomial σ ℝ) := by
classical
exact family.image fun P => (P.map (Rat.castHom ℝ)).rename embedding
def rationalFamilyToComplexOnUsedCoordinates
Rename a rational family after elimination, when only the variables that actually occur in the family must embed into the smaller retained coordinate space. This is the correct transport for (t, lambda) and observable outputs: the eliminated full-space coordinates need no image.
Definition (Lean source)
noncomputable def rationalFamilyToComplexOnUsedCoordinates {r : ℕ} {σ : Type}
[DecidableEq σ] (coordinateMap : Fin r → σ)
(family : Finset (MvPolynomial (Fin r) ℚ)) :
Finset (MvPolynomial σ ℂ) := by
classical
exact family.image fun P => (P.map (Rat.castHom ℂ)).rename coordinateMap
def rationalFamilyToRealOnUsedCoordinates
Real counterpart of the previous transport: rename a finite rational polynomial family into a displayed coordinate space and extend its coefficients to the reals, requiring only the variables that actually occur in the family to receive an image. This is the transport used for the (t, lambda) fiber and observable outputs, where the eliminated coordinates need no image.
Definition (Lean source)
noncomputable def rationalFamilyToRealOnUsedCoordinates {r : ℕ} {σ : Type}
[DecidableEq σ] (coordinateMap : Fin r → σ)
(family : Finset (MvPolynomial (Fin r) ℚ)) :
Finset (MvPolynomial σ ℝ) := by
classical
exact family.image fun P => (P.map (Rat.castHom ℝ)).rename coordinateMap
def realFamilyOnUsedCoordinates
Rename an already-real projected CAD family onto the displayed paper coordinate space. This is the transport used after the cited recursive prefix projection; it performs no additional elimination.
Definition (Lean source)
noncomputable def realFamilyOnUsedCoordinates {r : ℕ} {σ : Type}
[DecidableEq σ] (coordinateMap : Fin r → σ)
(family : Finset (MvPolynomial (Fin r) ℝ)) :
Finset (MvPolynomial σ ℝ) := by
classical
exact family.image fun P => P.rename coordinateMap
def effectiveCodeToObservablePolynomial
Transport one cited rational sign-test code to observable coordinates. The sign attached to the code is transported separately and unchanged.
Definition (Lean source)
noncomputable def effectiveCodeToObservablePolynomial {r : ℕ}
(coordinateMap : Fin r → (ℕ × ℕ)) (code : EffectivePolynomialCode r) :
MvPolynomial (ℕ × ℕ) ℝ :=
(code.toPolynomial.map (Rat.castHom ℝ)).rename coordinateMap
def cadAssignmentAlong
Extend one finite cited CAD assignment along the exact incidence-coordinate embedding, using zero only outside the supplied finite coordinate image.
Definition (Lean source)
noncomputable def cadAssignmentAlong {r m : ℕ}
(embedding : Fin r ↪ AtlasIncidenceCoord m) (point : CADSpace r) :
AtlasAssignment m :=
Function.extend embedding point 0
def cadObservableCumVec
Observable component of a finite cited CAD assignment.
Definition (Lean source)
noncomputable def cadObservableCumVec {r m : ℕ}
(embedding : Fin r ↪ AtlasIncidenceCoord m) (point : CADSpace r) :
CumVec ℝ := fun order exponent =>
cadAssignmentAlong embedding point (inl (order, exponent))
def cadFiberAssignment
Witness-forgotten (t, lambda) component of a finite cited CAD assignment.
Definition (Lean source)
noncomputable def cadFiberAssignment {r m : ℕ}
(embedding : Fin r ↪ AtlasIncidenceCoord m) (point : CADSpace r) :
AtlasFiberAssignment m
| inl orderExponent =>
cadAssignmentAlong embedding point (inl orderExponent)
| inr coord =>
cadAssignmentAlong embedding point (inr (inl coord))
theorem effectiveCADErasePrefix_append
Erasing two consecutive lifting prefixes is the same geometric projection as erasing their concatenation. This is the compatibility used by the witness-to-fiber and fiber-to-observable transports.
Formal statement
hypotheses
conclusion
effectiveCADErasePrefix (first ++ second) point
= effectiveCADErasePrefix second (effectiveCADErasePrefix first point)
Proof (Lean source)
theorem effectiveCADErasePrefix_append {r : ℕ}
(first second : List (Fin r)) (point : CADSpace r) :
effectiveCADErasePrefix (first ++ second) point =
effectiveCADErasePrefix second (effectiveCADErasePrefix first point) := by
simp [effectiveCADErasePrefix, List.foldl_append]
def IsInjectiveOnRationalFamilyVariables Definition aux_IsInjectiveOnRationalFamilyVariables in the paper ↗
A coordinate map is faithful on all variables that actually occur in a displayed polynomial family. It need not inject the already-eliminated ambient coordinates into the smaller output space.
Definition (Lean source)
def IsInjectiveOnRationalFamilyVariables {r : ℕ} {σ : Type}
(coordinateMap : Fin r → σ)
(family : Finset (MvPolynomial (Fin r) ℚ)) : Prop :=
∀ P ∈ family, ∀ x ∈ P.vars, ∀ Q ∈ family, ∀ y ∈ Q.vars,
coordinateMap x = coordinateMap y → x = y
def PopulatesAtlasFamily
Interpret one actual rational CAD trace code-family in a displayed real or complex atlas coordinate type, using an explicit finite-coordinate embedding. Every branch ends in an equality of polynomial families, not an opaque label.
Definition (Lean source)
def EffectiveRationalCodeFamily.PopulatesAtlasFamily {r m : ℕ}
(codes : List (EffectivePolynomialCode r)) : AtlasTraceFamily m → Prop
| .complexIncidence family =>
∃ coordinateMap : Fin r → AtlasComplexIncidenceCoord m,
IsInjectiveOnRationalFamilyVariables coordinateMap
(effectiveDecodedPolynomialFamily codes) ∧
rationalFamilyToComplexOnUsedCoordinates coordinateMap
(effectiveDecodedPolynomialFamily codes) = family
| .complexObservable family =>
∃ coordinateMap : Fin r → (ℕ × ℕ),
IsInjectiveOnRationalFamilyVariables coordinateMap
(effectiveDecodedPolynomialFamily codes) ∧
rationalFamilyToComplexOnUsedCoordinates coordinateMap
(effectiveDecodedPolynomialFamily codes) = family
| .incidence family =>
∃ coordinateMap : Fin r → AtlasIncidenceCoord m,
IsInjectiveOnRationalFamilyVariables coordinateMap
(effectiveDecodedPolynomialFamily codes) ∧
rationalFamilyToRealOnUsedCoordinates coordinateMap
(effectiveDecodedPolynomialFamily codes) = family
| .fiber family =>
∃ coordinateMap : Fin r → AtlasFiberCoord m,
IsInjectiveOnRationalFamilyVariables coordinateMap
(effectiveDecodedPolynomialFamily codes) ∧
rationalFamilyToRealOnUsedCoordinates coordinateMap
(effectiveDecodedPolynomialFamily codes) = family
| .observable family =>
∃ coordinateMap : Fin r → (ℕ × ℕ),
IsInjectiveOnRationalFamilyVariables coordinateMap
(effectiveDecodedPolynomialFamily codes) ∧
rationalFamilyToRealOnUsedCoordinates coordinateMap
(effectiveDecodedPolynomialFamily codes) = family
def PopulatesAtlasIncidenceSignCondition
A cited truth/retention query is exactly one of this paper's displayed full-incidence sign conditions after the fixed full-coordinate embedding.
Definition (Lean source)
def EffectiveCADSignQuery.PopulatesAtlasIncidenceSignCondition {r m : ℕ}
(query : EffectiveCADSignQuery r) (embedding : Fin r ↪ AtlasIncidenceCoord m)
(equations nonnegative positive :
Finset (MvPolynomial (AtlasIncidenceCoord m) ℝ)) : Prop :=
rationalFamilyToRealAlong embedding
(effectiveDecodedPolynomialFamily query.equations) = equations ∧
rationalFamilyToRealAlong embedding
(effectiveDecodedPolynomialFamily query.nonnegative) = nonnegative ∧
rationalFamilyToRealAlong embedding
(effectiveDecodedPolynomialFamily query.positive) = positive
def IsFromCADStep
A CAD-source primitive belongs to the indicated indexed cited trace step, including exact agreement of the source high-level operation.
Definition (Lean source)
def AtlasCitedPrimitiveCharge.IsFromCADStep (sourceStepIndex : ℕ)
(sourceOperation : EffectiveAlgebraTraceOperation) :
AtlasCitedPrimitiveCharge → Prop
| .rationalCAD index operation _ =>
index = sourceStepIndex ∧ operation = sourceOperation
| _ => False
theorem primitiveCharges_length
The explicit primitive stream has exactly the combined cited count.
Formal statement
hypotheses
execution :
conclusion
execution.primitiveCharges.length = execution.symbolicOperationCount
Proof (Lean source)
theorem AtlasCitedEffectiveExecution.primitiveCharges_length
(execution : AtlasCitedEffectiveExecution) :
execution.primitiveCharges.length = execution.symbolicOperationCount := by
rcases execution with
⟨rationalMachine, gaussianMachine, cadMachine, forwardJob, reverseJob,
sharedCoordinateRelation, pipeline, gaussianResults, cadJob, cadResult⟩
rcases pipeline with
⟨forwardResult, reverseResult, intersectionJob, forwardMap, reverseMap,
forwardMapInjective, reverseMapInjective, forwardReverseExact,
hforward, hreverse, intersectionResult⟩
cases gaussianResults
show ((forwardResult.result.payload.trace.flatMap fun step =>
step.primitiveOperations.map fun primitive =>
AtlasCitedPrimitiveCharge.rationalAlgebra
AtlasRationalAlgebraJob.forwardElimination step.operation primitive) ++
(reverseResult.result.payload.trace.flatMap fun step =>
step.primitiveOperations.map fun primitive =>
AtlasCitedPrimitiveCharge.rationalAlgebra
AtlasRationalAlgebraJob.reverseElimination step.operation primitive) ++
(intersectionResult.result.payload.trace.flatMap fun step =>
step.primitiveOperations.map fun primitive =>
AtlasCitedPrimitiveCharge.rationalAlgebra
AtlasRationalAlgebraJob.observableIntersection step.operation primitive) ++
atlasRationalCADPrimitiveChargesFrom 0 cadResult.result.payload.trace).length =
((forwardResult.result.payload.trace.map
fun a => a.primitiveOperations.length).sum +
((reverseResult.result.payload.trace.map
fun a => a.primitiveOperations.length).sum +
(intersectionResult.result.payload.trace.map
fun a => a.primitiveOperations.length).sum)) +
(cadResult.result.payload.trace.map EffectiveAlgebraTraceStep.operationCount).sum
simp [length_append, List.length_flatMap,
atlasRationalCADPrimitiveChargesFrom_length]
omega
def MatchesAtlasOperation
A cited primitive may be assigned only to the atlas operation consuming its source job. Rational algebra charges go to the corresponding forward, reverse, or intersection step; CAD charges stay on real projection/lifting or witness-retention steps. The real/imaginary coefficient reinterpretation is therefore necessarily an uncharged semantic step.
Definition (Lean source)
def AtlasCitedPrimitiveCharge.MatchesAtlasOperation :
AtlasCitedPrimitiveCharge → AtlasTraceOperation → Prop
| .rationalAlgebra .forwardElimination _ _,
.saturationGroebnerElimination .forward => True
| .rationalAlgebra .reverseElimination _ _,
.saturationGroebnerElimination .reverse => True
| .rationalAlgebra .observableIntersection _ _, .idealIntersection => True
| .rationalCAD _ .buchberger _, .cadBuchberger => True
| .rationalCAD _ .elimination _, .cadElimination => True
| .rationalCAD _ .idealIntersection _, .cadIdealIntersection => True
| .rationalCAD _ .saturation _, .cadSaturation => True
| .rationalCAD _ .reductaGeneration _, .cadReductaGeneration => True
| .rationalCAD _ .coefficientProjection _, .coefficientProjection => True
| .rationalCAD _ .discriminantProjection _, .discriminantProjection => True
| .rationalCAD _ .principalSubresultantProjection _,
.principalSubresultantProjection => True
| .rationalCAD _ .projectionClosure _, .cadProjectionClosure => True
| .rationalCAD _ .prefixCellProjection _, .prefixCellProjection => True
| .rationalCAD _ .witnessCellRetention _, .witnessCellRetention _ _ _ => True
| .rationalCAD _ .rootIsolation _, .realRootIsolation => True
| .rationalCAD _ .sectionLifting _, .sectionLifting => True
| .rationalCAD _ .sectorLifting _, .sectorLifting => True
| .rationalCAD _ .signConditionTruth _, .signConditionTruth => True
| _, _ => False
A declared input/output step of the finite symbolic atlas construction, together with its contiguous slice of the cited primitive stream.
Definition (Lean source)
def IsLinkedToCitedCADStep
Operation-specific linkage from one high-level atlas step to one actual step of the cited rational CAD result. Its inputs and output must be populated by the source step's decoded polynomial code families after explicit finite coordinate renaming.
Definition (Lean source)
def AtlasTraceStep.IsLinkedToCitedCADStep {m r : ℕ}
(step : AtlasTraceStep m) (sourceStepIndex : ℕ)
(sourceStep : EffectiveAlgebraTraceStep r) : Prop :=
(match sourceStep.operation, step.operation with
| .buchberger, .cadBuchberger => True
| .elimination, .cadElimination => True
| .idealIntersection, .cadIdealIntersection => True
| .saturation, .cadSaturation => True
| .reductaGeneration, .cadReductaGeneration => True
| .coefficientProjection, .coefficientProjection => True
| .discriminantProjection, .discriminantProjection => True
| .principalSubresultantProjection, .principalSubresultantProjection => True
| .projectionClosure, .cadProjectionClosure => True
| .prefixCellProjection, .prefixCellProjection => True
| .rootIsolation, .realRootIsolation => True
| .sectionLifting, .sectionLifting => True
| .sectorLifting, .sectorLifting => True
| .signConditionTruth, .signConditionTruth => True
| .witnessCellRetention, .witnessCellRetention _ _ _ => True
| _, _ => False) ∧
(match sourceStep.operation with
| .prefixCellProjection | .signConditionTruth | .witnessCellRetention => True
| _ => ∀ family ∈ step.inputs, ∃ codes ∈ sourceStep.inputFamilies,
EffectiveRationalCodeFamily.PopulatesAtlasFamily codes family) ∧
(match sourceStep.operation with
| .prefixCellProjection =>
sourceStep.outputFamilies = [] ∧
sourceStep.producedPrefixProjectionCertificateCodes ≠ []
| .signConditionTruth =>
sourceStep.outputFamilies = [] ∧ sourceStep.producedTruthRowCodes ≠ []
| .witnessCellRetention =>
sourceStep.outputFamilies = [] ∧ sourceStep.producedRetentionRowCodes ≠ []
| .rootIsolation | .sectionLifting | .sectorLifting =>
sourceStep.outputFamilies = [] ∧ ∃ codes ∈ sourceStep.inputFamilies,
EffectiveRationalCodeFamily.PopulatesAtlasFamily codes step.output
| _ => ∃ codes ∈ sourceStep.outputFamilies,
EffectiveRationalCodeFamily.PopulatesAtlasFamily codes step.output) ∧
∀ charge ∈ step.chargedPrimitives,
charge.IsFromCADStep sourceStepIndex sourceStep.operation
def IsCitedCADOperation
Exactly the operations sourced from the rational CAD/QE result.
Definition (Lean source)
def AtlasTraceOperation.IsCitedCADOperation : AtlasTraceOperation → Prop
| .cadBuchberger | .cadElimination | .cadIdealIntersection | .cadSaturation
| .cadReductaGeneration | .coefficientProjection | .discriminantProjection
| .principalSubresultantProjection | .cadProjectionClosure
| .prefixCellProjection
| .witnessCellRetention _ _ _ | .realRootIsolation | .sectionLifting
| .sectorLifting | .signConditionTruth => True
| _ => False
def IsReal
Real polynomial-family variants used by the rational CAD/QE branch.
Definition (Lean source)
def AtlasTraceFamily.IsReal {m : ℕ} : AtlasTraceFamily m → Prop
| .incidence _ | .fiber _ | .observable _ => True
| _ => False
def HasCitedCADFamilyShape
Basic family shape for a cited CAD algebra/projection-closure step. Its full polynomial semantics comes from IsLinkedToCitedCADStep, which identifies the actual semantically certified source step and its decoded families.
Definition (Lean source)
def AtlasTraceStep.HasCitedCADFamilyShape {m : ℕ} (step : AtlasTraceStep m) : Prop :=
step.inputs ≠ [] ∧ (∀ family ∈ step.inputs, family.IsReal) ∧ step.output.IsReal
def atlasObservableZeroSet
The common real zero set of a finite observable polynomial family.
Definition (Lean source)
def atlasObservableZeroSet
(m : ℕ) (family : Finset (MvPolynomial (ℕ × ℕ) ℝ)) : Set (CumVec ℝ) :=
{ t | t ∈ bandSupportedCumulants (2 * m + 2) ∧
∀ P ∈ family, eval (fun ra => t ra.1 ra.2) P = 0 }
def atlasComplexIncidenceEval
Evaluate the complex generic two-arrow incidence at (t, theta, eta, s).
def DefinesComplexGenericIncidenceEquations Definition aux_DefinesComplexGenericIncidenceEquations in the paper ↗
A finite complex polynomial family presents the generic two-arrow incidence with the indicated arrow's genericity product saturated. This is the Step-2 incidence whose elimination produces observable equations for bar E_m; it is separate from the Step-3 real incidence with atomic moment witnesses.
Definition (Lean source)
def DefinesComplexGenericIncidenceEquations (m : ℕ) (b : Direction)
(family : Finset (MvPolynomial (AtlasComplexIncidenceCoord m) ℂ)) : Prop :=
family.Nonempty ∧ ∀ t theta eta,
(t ∈ bandSupportedCumulants (2 * m + 2) ∧
theta ∈ bandSupportedParams m (2 * m + 2) ∧
eta ∈ bandSupportedParams m (2 * m + 2) ∧
forwardCumulantMap m (2 * m + 2) theta = t ∧
reverseCumulantMap m (2 * m + 2) eta = t ∧
(if b = .forward then theta ∈ genericParameterLocus m (2 * m + 2)
else eta ∈ genericParameterLocus m (2 * m + 2))) ↔
(t ∈ bandSupportedCumulants (2 * m + 2) ∧
theta ∈ bandSupportedParams m (2 * m + 2) ∧
eta ∈ bandSupportedParams m (2 * m + 2) ∧
∃ s : Direction → ℂ, ∀ P ∈ family,
eval (atlasComplexIncidenceEval t theta eta s) P = 0)
def atlasComplexObservableZeroSet
The common complex zero set of a finite observable polynomial family.
Definition (Lean source)
def atlasComplexObservableZeroSet
(m : ℕ) (family : Finset (MvPolynomial (ℕ × ℕ) ℂ)) : Set (CumVec ℂ) :=
{ t | t ∈ bandSupportedCumulants (2 * m + 2) ∧
∀ P ∈ family, eval (fun ra => t ra.1 ra.2) P = 0 }
def atlasComplexObservableProjectionClosure
Complex Zariski closure of the observable projection of the saturated generic two-arrow incidence. This is complex algebraic elimination only; it does not describe projection over real atomic witnesses.
Definition (Lean source)
def atlasComplexObservableProjectionClosure (m : ℕ) (b : Direction) :
Set (CumVec ℂ) :=
zariskiClosure { t | t ∈ bandSupportedCumulants (2 * m + 2) ∧
∃ theta ∈ bandSupportedParams m (2 * m + 2),
∃ eta ∈ bandSupportedParams m (2 * m + 2),
forwardCumulantMap m (2 * m + 2) theta = t ∧
reverseCumulantMap m (2 * m + 2) eta = t ∧
(if b = .forward then theta ∈ genericParameterLocus m (2 * m + 2)
else eta ∈ genericParameterLocus m (2 * m + 2)) }
def IsExactComplexObservableElimination Definition aux_IsExactComplexObservableElimination in the paper ↗
A finite complex observable family cuts out exactly the complex projection closure of a saturated generic incidence.
Definition (Lean source)
def IsExactComplexObservableElimination (m : ℕ) (b : Direction)
(observable : Finset (MvPolynomial (ℕ × ℕ) ℂ)) : Prop :=
atlasComplexObservableZeroSet m observable =
atlasComplexObservableProjectionClosure m b
def atlasForgetWitnesses
Restriction of a full incidence assignment to the witness-eliminated (t, lambda) coordinates.
Definition (Lean source)
def atlasForgetWitnesses {m : ℕ}
(a : AtlasIncidenceCoord m → ℝ) : AtlasFiberAssignment m
| inl ra => a (inl ra)
| inr coord => a (inr (inl coord))
def atlasIncidenceProjectionClosure
Zariski closure of a real projection, retained only as a diagnostic notion used by the counterexample module. It is deliberately not the semantics of any atlas construction-trace operation: complex Groebner elimination cannot compute this real witness projection.
Definition (Lean source)
def atlasIncidenceProjectionClosure {m : ℕ}
(family : Finset (MvPolynomial (AtlasIncidenceCoord m) ℝ)) :
Set (AtlasFiberAssignment m) :=
{ a | ∀ Q : MvPolynomial (AtlasFiberCoord m) ℝ,
(∀ x : AtlasIncidenceCoord m → ℝ,
(∀ P ∈ family, eval x P = 0) →
eval (atlasForgetWitnesses x) Q = 0) →
eval a Q = 0 }
def IsExactWitnessElimination
Diagnostic predicate for exact real witness projection. The effective atlas does not require this predicate; Step 4 eliminates witnesses cellwise instead.
Definition (Lean source)
def IsExactWitnessElimination {m : ℕ}
(incidence : Finset (MvPolynomial (AtlasIncidenceCoord m) ℝ))
(fiber : Finset (MvPolynomial (AtlasFiberCoord m) ℝ)) : Prop :=
{ a | ∀ P ∈ fiber, eval a P = 0 } =
atlasIncidenceProjectionClosure incidence
def IsSemanticallyCorrect
Operation-specific semantics for every symbolic trace step. Saturation and Groebner elimination act only on the complex generic two-arrow incidence and produce complex observable equations. Real atomic witnesses are removed later, cellwise, by witnessCellRetention; they are never assigned complex-elimination semantics.
Definition (Lean source)
def AtlasTraceStep.IsSemanticallyCorrect {m : ℕ} (step : AtlasTraceStep m) : Prop :=
match step.operation, step.inputs, step.output with
| .saturationGroebnerElimination b, [.complexIncidence _], .complexObservable B =>
IsExactComplexObservableElimination m b B
| .idealIntersection, [.complexObservable A, .complexObservable B],
.complexObservable C =>
atlasComplexObservableZeroSet m C =
atlasComplexObservableZeroSet m A ∪ atlasComplexObservableZeroSet m B
| .realImaginarySplit, [.complexObservable A], .observable B =>
atlasObservableZeroSet m B =
{ t | t ∈ bandSupportedCumulants (2 * m + 2) ∧
complexifyCumVec t ∈ atlasComplexObservableZeroSet m A }
| .cadBuchberger, _, _ => step.HasCitedCADFamilyShape
| .cadElimination, _, _ => step.HasCitedCADFamilyShape
| .cadIdealIntersection, _, _ => step.HasCitedCADFamilyShape
| .cadSaturation, _, _ => step.HasCitedCADFamilyShape
| .cadReductaGeneration, [.incidence A], .incidence B =>
∃ x, B = cadReductaFamily x A
| .cadReductaGeneration, [.fiber A], .fiber B =>
∃ x, B = cadReductaFamily x A
| .cadReductaGeneration, [.observable A], .observable B =>
∃ x, B = cadReductaFamily x A
| .coefficientProjection, [.incidence A], .incidence B =>
∃ x, B = cadCoefficients x A
| .coefficientProjection, [.fiber A], .fiber B =>
∃ x, B = cadCoefficients x A
| .coefficientProjection, [.observable A], .observable B =>
∃ x, B = cadCoefficients x A
| .discriminantProjection, [.incidence A], .incidence B =>
∃ x, B = cadDiscriminants x A
| .discriminantProjection, [.fiber A], .fiber B =>
∃ x, B = cadDiscriminants x A
| .discriminantProjection, [.observable A], .observable B =>
∃ x, B = cadDiscriminants x A
| .principalSubresultantProjection, [.incidence A], .incidence B =>
∃ x, B = cadPrincipalSubresultants x A
| .principalSubresultantProjection, [.fiber A], .fiber B =>
∃ x, B = cadPrincipalSubresultants x A
| .principalSubresultantProjection, [.observable A], .observable B =>
∃ x, B = cadPrincipalSubresultants x A
| .cadProjectionClosure, _, _ => step.HasCitedCADFamilyShape
| .prefixCellProjection, [.incidence _], .observable _ => True
| .prefixCellProjection, [.incidence _], .fiber _ => True
| .witnessCellRetention _ _ _, [.fiber A], .fiber B => B = A
| .realRootIsolation, [.fiber A], .fiber B => B = A
| .realRootIsolation, [.observable A], .observable B => B = A
| .sectionLifting, [.fiber A], .fiber B => B = A
| .sectorLifting, [.fiber A], .fiber B => B = A
| .signConditionTruth, [.fiber A], .fiber B => B = A
| .signConditionTruth, [.observable A], .observable B => B = A
| _, _, _ => False
def operationCost
Exact arithmetic/sign-operation charge for one certified atlas step: the length of its displayed slice of the cited primitive execution.
Definition (Lean source)
def AtlasTraceStep.operationCost {m : ℕ} (step : AtlasTraceStep m) : ℕ :=
step.chargedPrimitives.length
def complexIncidenceFamilies
Complex-incidence families read or emitted by a trace step.
Definition (Lean source)
def AtlasTraceStep.complexIncidenceFamilies {m : ℕ} (step : AtlasTraceStep m) :
List (Finset (MvPolynomial (AtlasComplexIncidenceCoord m) ℂ)) :=
(step.inputs ++ [step.output]).filterMap fun family => match family with
| .complexIncidence A => some A
| _ => none
def complexObservableFamilies
Complex-observable families read or emitted by a trace step.
Definition (Lean source)
def AtlasTraceStep.complexObservableFamilies {m : ℕ} (step : AtlasTraceStep m) :
List (Finset (MvPolynomial (ℕ × ℕ) ℂ)) :=
(step.inputs ++ [step.output]).filterMap fun family => match family with
| .complexObservable A => some A
| _ => none
def incidenceFamilies
Incidence-coordinate families read or emitted by a trace step.
Definition (Lean source)
def AtlasTraceStep.incidenceFamilies {m : ℕ} (step : AtlasTraceStep m) :
List (Finset (MvPolynomial (AtlasIncidenceCoord m) ℝ)) :=
(step.inputs ++ [step.output]).filterMap fun family => match family with
| .incidence A => some A
| _ => none
def fiberFamilies
Witness-eliminated fiber families read or emitted by a trace step.
Definition (Lean source)
def AtlasTraceStep.fiberFamilies {m : ℕ} (step : AtlasTraceStep m) :
List (Finset (MvPolynomial (AtlasFiberCoord m) ℝ)) :=
(step.inputs ++ [step.output]).filterMap fun family => match family with
| .fiber A => some A
| _ => none
def observableFamilies
Observable families read or emitted by a trace step.
Definition (Lean source)
def AtlasTraceStep.observableFamilies {m : ℕ} (step : AtlasTraceStep m) :
List (Finset (MvPolynomial (ℕ × ℕ) ℝ)) :=
(step.inputs ++ [step.output]).filterMap fun family => match family with
| .observable A => some A
| _ => none
An observable polynomial has constant mathematical sign on a base cell.
Definition (Lean source)
def ObservableSignInvariantOn (cell : Set (CumVec ℝ))
(P : MvPolynomial (ℕ × ℕ) ℝ) : Prop :=
∀ t ∈ cell, ∀ t' ∈ cell,
polynomialSign (eval (fun ra => t ra.1 ra.2) P) =
polynomialSign (eval (fun ra => t' ra.1 ra.2) P)
def IsWellTyped
A trace step has the correct symbolic stage shape. In particular, the three CAD projection operations are not mere labels: their output family is definitionally the corresponding shared generic CAD operator applied to the declared input family. The remaining operations change or preserve stages as specified by the paper's elimination/lifting pipeline; their global correctness is certified by the endpoint, retained-cell, and exact-section fields of EffectiveRealAtlasOutput.
Definition (Lean source)
def AtlasTraceStep.IsWellTyped {m : ℕ} (step : AtlasTraceStep m) : Prop :=
match step.operation, step.inputs, step.output with
| .saturationGroebnerElimination _, [.complexIncidence _], .complexObservable _ => True
| .idealIntersection, [.complexObservable _, .complexObservable _],
.complexObservable _ => True
| .realImaginarySplit, [.complexObservable _], .observable _ => True
| .cadBuchberger, _, _ => step.HasCitedCADFamilyShape
| .cadElimination, _, _ => step.HasCitedCADFamilyShape
| .cadIdealIntersection, _, _ => step.HasCitedCADFamilyShape
| .cadSaturation, _, _ => step.HasCitedCADFamilyShape
| .cadReductaGeneration, [.incidence A], .incidence B =>
∃ x, B = cadReductaFamily x A
| .cadReductaGeneration, [.fiber A], .fiber B =>
∃ x, B = cadReductaFamily x A
| .cadReductaGeneration, [.observable A], .observable B =>
∃ x, B = cadReductaFamily x A
| .coefficientProjection, [.incidence A], .incidence B =>
∃ x, B = cadCoefficients x A
| .coefficientProjection, [.fiber A], .fiber B =>
∃ x, B = cadCoefficients x A
| .coefficientProjection, [.observable A], .observable B =>
∃ x, B = cadCoefficients x A
| .discriminantProjection, [.incidence A], .incidence B =>
∃ x, B = cadDiscriminants x A
| .discriminantProjection, [.fiber A], .fiber B =>
∃ x, B = cadDiscriminants x A
| .discriminantProjection, [.observable A], .observable B =>
∃ x, B = cadDiscriminants x A
| .principalSubresultantProjection, [.incidence A], .incidence B =>
∃ x, B = cadPrincipalSubresultants x A
| .principalSubresultantProjection, [.fiber A], .fiber B =>
∃ x, B = cadPrincipalSubresultants x A
| .principalSubresultantProjection, [.observable A], .observable B =>
∃ x, B = cadPrincipalSubresultants x A
| .cadProjectionClosure, _, _ => step.HasCitedCADFamilyShape
| .prefixCellProjection, [.incidence _], .observable _ => True
| .prefixCellProjection, [.incidence _], .fiber _ => True
| .witnessCellRetention _ _ _, [.fiber _], .fiber _ => True
| .realRootIsolation, [.fiber _], .fiber _ => True
| .realRootIsolation, [.observable _], .observable _ => True
| .sectionLifting, [.fiber _], .fiber _ => True
| .sectorLifting, [.fiber _], .fiber _ => True
| .signConditionTruth, [.fiber _], .fiber _ => True
| .signConditionTruth, [.observable _], .observable _ => True
| _, _, _ => False
An observable polynomial family explicitly presents every base cell.
Definition (Lean source)
def DefinesAtlasBaseCellFamily (m : ℕ) {ι : Type}
(cell : ι → Set (CumVec ℝ))
(family : Finset (MvPolynomial (ℕ × ℕ) ℝ)) : Prop :=
family.Nonempty ∧ ∀ i, ∃ equations nonnegative positive,
equations ∪ nonnegative ∪ positive ⊆ family ∧
cell i = { t |
t ∈ bandSupportedCumulants (2 * m + 2) ∧
(∀ P ∈ equations, eval (fun ra => t ra.1 ra.2) P = 0) ∧
(∀ P ∈ nonnegative, 0 ≤ eval (fun ra => t ra.1 ra.2) P) ∧
(∀ P ∈ positive, 0 < eval (fun ra => t ra.1 ra.2) P) }
structure CertifiedAtlasConstructionTrace Definition aux_CertifiedAtlasConstructionTrace in the paper ↗
A finite construction trace starts Step 2 from the two complex generic incidences, produces their observable elimination ideals and their intersection, then runs real CAD and Step-4 witness-cell retention on the separately displayed real incidence and (t, lambda) families.
Definition (Lean source)
parameters
m :
ℕ
atlas :
forwardComplexIncidence reverseComplexIncidence :
forwardComplexObservable reverseComplexObservable complexExceptional :
Finset (MvPolynomial (ℕ × ℕ) ℂ)
forwardFamily reverseFamily :
baseObservableFamily baseGeometryFamily :
Finset (MvPolynomial (ℕ × ℕ) ℝ)
fields
steps :
List (AtlasTraceStep m)
citedExecution :
forwardIncidenceEmbedding :
Fin citedExecution.forwardEliminationJob.r ↪ AtlasComplexIncidenceCoord m
forwardObservableCoordinateMap :
Fin citedExecution.forwardEliminationJob.r → (ℕ × ℕ)
forward_observable_coordinates_injective :
IsInjectiveOnRationalFamilyVariables forwardObservableCoordinateMap citedExecution.forwardResult.result.saturatedEliminationBasis
forward_retained_coordinates_exact :
∀ i ∈ citedExecution.forwardEliminationJob.keep,
forwardIncidenceEmbedding i = inl (forwardObservableCoordinateMap i)
forward_cited_input_exact :
rationalFamilyToComplexAlong forwardIncidenceEmbedding citedExecution.forwardEliminationJob.input
= forwardComplexIncidence
forward_cited_order_is_elimination :
IsEffectiveEliminationMonomialOrder citedExecution.forwardEliminationJob.monomialOrder citedExecution.forwardEliminationJob.keep
forward_cited_output_exact :
rationalFamilyToComplexOnUsedCoordinates forwardObservableCoordinateMap citedExecution.forwardResult.result.saturatedEliminationBasis
= forwardComplexObservable
reverseIncidenceEmbedding :
Fin citedExecution.reverseEliminationJob.r ↪ AtlasComplexIncidenceCoord m
reverseObservableCoordinateMap :
Fin citedExecution.reverseEliminationJob.r → (ℕ × ℕ)
reverse_observable_coordinates_injective :
IsInjectiveOnRationalFamilyVariables reverseObservableCoordinateMap citedExecution.reverseResult.result.saturatedEliminationBasis
reverse_retained_coordinates_exact :
∀ i ∈ citedExecution.reverseEliminationJob.keep,
reverseIncidenceEmbedding i = inl (reverseObservableCoordinateMap i)
reverse_cited_input_exact :
rationalFamilyToComplexAlong reverseIncidenceEmbedding citedExecution.reverseEliminationJob.input
= reverseComplexIncidence
reverse_cited_order_is_elimination :
IsEffectiveEliminationMonomialOrder citedExecution.reverseEliminationJob.monomialOrder citedExecution.reverseEliminationJob.keep
reverse_cited_output_exact :
rationalFamilyToComplexOnUsedCoordinates reverseObservableCoordinateMap citedExecution.reverseResult.result.saturatedEliminationBasis
= reverseComplexObservable
intersectionObservableEmbedding :
Fin citedExecution.observableIntersectionJob.r ↪ (ℕ × ℕ)
forward_intersection_coordinates_exact :
∀ i ∈ citedExecution.forwardEliminationJob.keep,
intersectionObservableEmbedding (citedExecution.dependentPipeline.forwardToIntersection i)
= forwardObservableCoordinateMap i
reverse_intersection_coordinates_exact :
∀ i ∈ citedExecution.reverseEliminationJob.keep,
intersectionObservableEmbedding (citedExecution.dependentPipeline.reverseToIntersection i)
= reverseObservableCoordinateMap i
intersection_cited_left_input_exact :
rationalFamilyToComplexAlong intersectionObservableEmbedding citedExecution.observableIntersectionJob.input
= forwardComplexObservable
intersection_cited_right_input_exact :
rationalFamilyToComplexAlong intersectionObservableEmbedding citedExecution.observableIntersectionJob.secondInput
= reverseComplexObservable
intersection_cited_output_exact :
rationalFamilyToComplexAlong intersectionObservableEmbedding citedExecution.intersectionResult.result.intersectionBasis
= complexExceptional
cadIncidenceEmbedding :
Fin citedExecution.cadJob.r ↪ AtlasIncidenceCoord m
cad_cited_exceptional_input_exact :
rationalFamilyToRealAlong cadIncidenceEmbedding citedExecution.cadJob.input
= atlasObservableIncidenceFamily m baseObservableFamily
cad_cited_simultaneous_sign_input_exact :
atlasObservableIncidenceFamily m baseObservableFamily ∪ rationalFamilyToRealAlong cadIncidenceEmbedding citedExecution.cadJob.secondInput
= (atlas.forwardEquations ∪ atlas.forwardNonnegative ∪ atlas.forwardPositive) ∪ (atlas.reverseEquations ∪ atlas.reverseNonnegative ∪ atlas.reversePositive)
cad_cited_complete_input_exact :
rationalFamilyToRealAlong cadIncidenceEmbedding (citedExecution.cadJob.input ∪ citedExecution.cadJob.secondInput)
= atlasObservableIncidenceFamily m baseObservableFamily ∪ ((atlas.forwardEquations ∪ atlas.forwardNonnegative ∪ atlas.forwardPositive) ∪ (atlas.reverseEquations ∪ atlas.reverseNonnegative ∪ atlas.reversePositive))
cad_cited_order_exact :
citedExecution.cadJob.order.map cadIncidenceEmbedding = atlas.order
Coordinate transports for the two cited prefix splits. Their values on
eliminated coordinates are irrelevant; injectivity is required exactly on
variables occurring in the corresponding projected stage family.
cadFiberCoordinateMap :
Fin citedExecution.cadJob.r → AtlasFiberCoord m
cadObservableCoordinateMap :
Fin citedExecution.cadJob.r → (ℕ × ℕ)
cad_order_prefix_suffix_exact :
citedExecution.cadJob.order = witnessPrefix ++ loadingPrefix ++ observableSuffix
witness_prefix_exact :
witnessPrefix.map cadIncidenceEmbedding
= atlas.order.filter fun x => decide (atlasIncidenceVariableBlock x = .atomicWitnesses)
loading_prefix_exact :
loadingPrefix.map cadIncidenceEmbedding
= atlas.order.filter fun x => decide (atlasIncidenceVariableBlock x = .loadingAndCumulants)
observable_suffix_exact :
observableSuffix.map cadIncidenceEmbedding
= atlas.order.filter fun x => decide (atlasIncidenceVariableBlock x = .observable)
fiber_coordinate_transport_exact :
observable_coordinate_transport_exact :
∀ x ∈ observableSuffix,
∃ ra, cadIncidenceEmbedding x = inl ra ∧ cadObservableCoordinateMap x = ra
fiber_projected_family_exact :
let transported := realFamilyOnUsedCoordinates cadFiberCoordinateMap (effectiveCADFamilyAfterPrefix witnessPrefix (rationalPolynomialFamilyToReal (citedExecution.cadJob.input ∪ citedExecution.cadJob.secondInput))) transported
= forwardFamily ∧
transported = reverseFamily
base_geometry_family_exact :
realFamilyOnUsedCoordinates cadObservableCoordinateMap (effectiveCADFamilyAfterPrefix (witnessPrefix ++ loadingPrefix) (rationalPolynomialFamilyToReal (citedExecution.cadJob.input ∪ citedExecution.cadJob.secondInput)))
= baseGeometryFamily
steps_nonempty :
steps ≠ []
steps_well_typed :
∀ step ∈ steps, step.IsWellTyped
steps_semantically_correct :
∀ step ∈ steps, step.IsSemanticallyCorrect
charged_primitives_match_operations :
∀ step ∈ steps,
∀ primitive ∈ step.chargedPrimitives, primitive.MatchesAtlasOperation step.operation
The per-step lists are contiguous slices whose concatenation is exactly
the full cited primitive stream. List equality supplies both coverage and
disjoint positional use: no cited charge is dropped, duplicated, or silently
reassigned outside these slices.
charged_primitives_exact :
steps.flatMap (fun step => step.chargedPrimitives) = citedExecution.primitiveCharges
cited_cad_steps_linked :
∀ step ∈ steps
if
step.operation.IsCitedCADOperation
then
∃ sourceStepIndex sourceStep,
citedExecution.cadResult.result.payload.trace[sourceStepIndex]? = some sourceStep ∧
step.IsLinkedToCitedCADStep sourceStepIndex sourceStep
cited_cad_source_steps_consumed :
∀ sourceStepIndex sourceStep
if
citedExecution.cadResult.result.payload.trace[sourceStepIndex]? = some sourceStep
then
∃ step ∈ steps, step.IsLinkedToCitedCADStep sourceStepIndex sourceStep
cited_cad_retention_rows_present :
∃ sourceStep ∈ citedExecution.cadResult.result.payload.trace,
sourceStep.operation = .witnessCellRetention ∧ sourceStep.producedRetentionRowCodes ≠ []
cited_cad_projects_observable_geometry :
∃ sourceStep ∈ citedExecution.cadResult.result.payload.trace,
sourceStep.operation = .prefixCellProjection ∧
sourceStep.producedPrefixProjectionCertificateCodes ≠ []
starts_forward :
∃ step ∈ steps,
step.operation = .saturationGroebnerElimination .forward ∧
step.inputs = [.complexIncidence forwardComplexIncidence] ∧
step.output = .complexObservable forwardComplexObservable
starts_reverse :
∃ step ∈ steps,
step.operation = .saturationGroebnerElimination .reverse ∧
step.inputs = [.complexIncidence reverseComplexIncidence] ∧
step.output = .complexObservable reverseComplexObservable
has_ideal_intersection :
∃ step ∈ steps,
step.operation = .idealIntersection ∧
step.inputs
= [.complexObservable forwardComplexObservable, .complexObservable reverseComplexObservable] ∧
step.output = .complexObservable complexExceptional
has_real_imaginary_split :
∃ step ∈ steps,
step.operation = .realImaginarySplit ∧
step.inputs = [.complexObservable complexExceptional] ∧
step.output = .observable baseObservableFamily
has_reducta_generation :
∃ step ∈ steps, step.operation = .cadReductaGeneration
has_coefficient_projection :
∃ step ∈ steps, step.operation = .coefficientProjection
has_discriminant_projection :
∃ step ∈ steps, step.operation = .discriminantProjection
has_principal_subresultants :
∃ step ∈ steps, step.operation = .principalSubresultantProjection
has_prefix_cell_projection :
∃ step ∈ steps, step.operation = .prefixCellProjection
has_real_root_isolation :
∃ step ∈ steps, step.operation = .realRootIsolation
has_section_lifting :
∃ step ∈ steps, step.operation = .sectionLifting
has_sector_lifting :
∃ step ∈ steps, step.operation = .sectorLifting
has_sign_condition_truth :
∃ step ∈ steps, step.operation = .signConditionTruth
outputs_forward_family :
∃ step ∈ steps, step.output = .fiber forwardFamily
outputs_reverse_family :
∃ step ∈ steps, step.output = .fiber reverseFamily
outputs_base_observable_family :
∃ step ∈ steps, step.output = .observable baseObservableFamily
outputs_base_geometry_family :
∃ step ∈ steps,
step.operation = .prefixCellProjection ∧ step.output = .observable baseGeometryFamily
theorem operationCost_sum_eq_cited
Exact accounting consequence of the slice certificate: the high-level atlas total is the combined cited primitive count.
Formal statement
hypotheses
m :
forwardComplexObservable reverseComplexObservable complexExceptional :
Finset (MvPolynomial (ℕ × ℕ) ℂ)
forwardFamily reverseFamily :
baseObservableFamily baseGeometryFamily :
Finset (MvPolynomial (ℕ × ℕ) ℝ)
trace :
CertifiedAtlasConstructionTrace m atlas forwardComplexIncidence reverseComplexIncidence forwardComplexObservable reverseComplexObservable complexExceptional forwardFamily reverseFamily baseObservableFamily baseGeometryFamily
conclusion
(trace.steps.map AtlasTraceStep.operationCost).sum
= trace.citedExecution.symbolicOperationCount
Proof (Lean source)
theorem CertifiedAtlasConstructionTrace.operationCost_sum_eq_cited
{m : ℕ} {atlas : RealAtlasCADData m}
{forwardComplexIncidence reverseComplexIncidence :
Finset (MvPolynomial (AtlasComplexIncidenceCoord m) ℂ)}
{forwardComplexObservable reverseComplexObservable complexExceptional :
Finset (MvPolynomial (ℕ × ℕ) ℂ)}
{forwardFamily reverseFamily : Finset (MvPolynomial (AtlasFiberCoord m) ℝ)}
{baseObservableFamily baseGeometryFamily :
Finset (MvPolynomial (ℕ × ℕ) ℝ)}
(trace : CertifiedAtlasConstructionTrace m atlas
forwardComplexIncidence reverseComplexIncidence
forwardComplexObservable reverseComplexObservable complexExceptional
forwardFamily reverseFamily baseObservableFamily baseGeometryFamily) :
(trace.steps.map AtlasTraceStep.operationCost).sum =
trace.citedExecution.symbolicOperationCount := by
calc
(trace.steps.map AtlasTraceStep.operationCost).sum =
(trace.steps.flatMap (fun step => step.chargedPrimitives)).length := by
rw [List.length_flatMap]
rfl
_ = trace.citedExecution.primitiveCharges.length :=
congrArg length trace.charged_primitives_exact
_ = trace.citedExecution.symbolicOperationCount :=
trace.citedExecution.primitiveCharges_length
Rational finite syntax for a polynomial. Coefficients and exponent lists are discrete data suitable for a genuine machine encoding.
Definition (Lean source)
instance instEncodableAtlasPolynomialCode
Finite rational syntax for a polynomial — its list of coefficients with exponent lists — can be encoded as a natural number and decoded back, so the type of polynomial codes is countable whenever its variables are.
Definition (Lean source)
deriving Encodable
inductive AtlasCellCode
Finite syntax for one recursively lifted CAD cell. The six constructors record the zero-dimensional point and all five lifting cases of IsRecursivelyLiftedCADCell: a root-free whole fibre, a root section, and the three lower/bounded/upper sectors. Root indices are exact symbolic indices in the ordered real-root stack; evaluating signs or comparing arbitrary reals is not part of this discrete code.
Definition (Lean source)
inductive AtlasCellCode
| point
| wholeFiber (base : AtlasCellCode)
| section (rootIndex : ℕ) (base : AtlasCellCode)
| lowerSector (base : AtlasCellCode)
| boundedSector (lowerIndex : ℕ) (base : AtlasCellCode)
| upperSector (lowerIndex : ℕ) (base : AtlasCellCode)
deriving Encodable
instance instEncodableAtlasCellCode
Finite syntax for one recursively lifted CAD cell can be encoded as a natural number and decoded back, so the type of cell codes is countable.
Definition (Lean source)
deriving Encodable
def toAtlasCellCode
Forget the effective cited certificate's rational root presentations and sign row while retaining its exact recursive CAD-cell shape and root indices.
Definition (Lean source)
def EffectiveCADCellCertificate.toAtlasCellCode {r : ℕ} :
EffectiveCADCellCertificate r → AtlasCellCode
| .point => .point
| .wholeFiber base => .wholeFiber base.toAtlasCellCode
| .section root base => .section root.rootIndex base.toAtlasCellCode
| .lowerSector baseRoot base => .lowerSector base.toAtlasCellCode
| .boundedSector lower _upper base =>
.boundedSector lower.rootIndex base.toAtlasCellCode
| .upperSector lower base => .upperSector lower.rootIndex base.toAtlasCellCode
def Realizes
Exact interpretation of finite cell syntax in the generic recursive CAD cell language. This ties every machine-emitted geometry code to the actual section/sector set it denotes, rather than merely recording a constructor tag.
Definition (Lean source)
def AtlasCellCode.Realizes {σ : Type} [DecidableEq σ] :
Finset (MvPolynomial σ ℝ) → List σ → AtlasCellCode → Set (σ → ℝ) → Prop
| _, [], .point, cell => cell = { a | ∀ x, a x = 0 }
| family, x :: xs, .wholeFiber baseCode, cell =>
∃ base, Realizes (cadProjectionStep x family) xs baseCode base ∧
(∀ a ∈ base, cadRealRootsAt x family a = ∅) ∧
cell = { a | cadEraseCoordinate x a ∈ base }
| family, x :: xs, .section rootIndex baseCode, cell =>
∃ base, Realizes (cadProjectionStep x family) xs baseCode base ∧
∃ root, IsCADAlgebraicRoot x base rootIndex root family ∧
cell = { a | cadEraseCoordinate x a ∈ base ∧
a x = root (cadEraseCoordinate x a) }
| family, x :: xs, .lowerSector baseCode, cell =>
∃ base, Realizes (cadProjectionStep x family) xs baseCode base ∧
∃ upper, IsCADAlgebraicRoot x base 0 upper family ∧
cell = { a | cadEraseCoordinate x a ∈ base ∧
a x < upper (cadEraseCoordinate x a) }
| family, x :: xs, .boundedSector lowerIndex baseCode, cell =>
∃ base, Realizes (cadProjectionStep x family) xs baseCode base ∧
∃ lower upper,
IsCADAlgebraicRoot x base lowerIndex lower family ∧
IsCADAlgebraicRoot x base (lowerIndex + 1) upper family ∧
(∀ a ∈ base, lower a < upper a) ∧
cell = { a | cadEraseCoordinate x a ∈ base ∧
lower (cadEraseCoordinate x a) < a x ∧
a x < upper (cadEraseCoordinate x a) }
| family, x :: xs, .upperSector lowerIndex baseCode, cell =>
∃ base, Realizes (cadProjectionStep x family) xs baseCode base ∧
∃ lower, IsCADLastAlgebraicRoot x base lowerIndex lower family ∧
cell = { a | cadEraseCoordinate x a ∈ base ∧
lower (cadEraseCoordinate x a) < a x }
| _, _, _, _ => False
def toReal
Interpret rational polynomial syntax as an actual real multivariate polynomial.
Definition (Lean source)
def AtlasPolynomialCode.toReal {σ : Type} [DecidableEq σ]
(code : AtlasPolynomialCode σ) : MvPolynomial σ ℝ :=
code.terms.foldl (fun P term =>
P + monomial
(term.2.foldl (fun exponents xe => exponents + Finsupp.single xe.1 xe.2) 0)
(term.1 : ℝ)) 0
Entire discrete symbolic payload emitted by the atlas construction machine. Every polynomial list is rational syntax; the fields of EffectiveRealAtlasOutput below identify its real interpretation with the actual incidence, fiber, base, and sign-test families.
Definition (Lean source)
structure EncodedAtlasConstruction (m : ℕ) where
forwardComplexIncidence : List (AtlasPolynomialCode (AtlasComplexIncidenceCoord m))
reverseComplexIncidence : List (AtlasPolynomialCode (AtlasComplexIncidenceCoord m))
forwardComplexObservable : List (AtlasPolynomialCode (ℕ × ℕ))
reverseComplexObservable : List (AtlasPolynomialCode (ℕ × ℕ))
complexExceptional : List (AtlasPolynomialCode (ℕ × ℕ))
forwardIncidence : List (AtlasPolynomialCode (AtlasIncidenceCoord m))
reverseIncidence : List (AtlasPolynomialCode (AtlasIncidenceCoord m))
forwardFiber : List (AtlasPolynomialCode (AtlasFiberCoord m))
reverseFiber : List (AtlasPolynomialCode (AtlasFiberCoord m))
observableBase : List (AtlasPolynomialCode (ℕ × ℕ))
observableGeometry : List (AtlasPolynomialCode (ℕ × ℕ))
signTests : List (AtlasPolynomialCode (ℕ × ℕ))
baseOrder : List (ℕ × ℕ)
forwardOrder : List (AtlasFiberCoord m)
reverseOrder : List (AtlasFiberCoord m)
baseCellCount : ℕ
baseCells : List AtlasCellCode
forwardCandidateCellCounts : List ℕ
reverseCandidateCellCounts : List ℕ
forwardRetainedCellCounts : List ℕ
reverseRetainedCellCounts : List ℕ
forwardCandidateCells : List (List AtlasCellCode)
reverseCandidateCells : List (List AtlasCellCode)
forwardRetainedSelections : List (List ℕ)
reverseRetainedSelections : List (List ℕ)
traceIncidenceFamilies : List (List (AtlasPolynomialCode (AtlasIncidenceCoord m)))
traceFiberFamilies : List (List (AtlasPolynomialCode (AtlasFiberCoord m)))
traceObservableFamilies : List (List (AtlasPolynomialCode (ℕ × ℕ)))
traceComplexIncidenceFamilies :
List (List (AtlasPolynomialCode (AtlasComplexIncidenceCoord m)))
traceComplexObservableFamilies : List (List (AtlasPolynomialCode (ℕ × ℕ)))
operations : List AtlasTraceOperation
lookupRows : List (List ℕ × Bool × Bool)
deriving Encodable
instance instEncodableEncodedAtlasConstruction
Every encoded atlas construction, including its finite polynomial and trace data, has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
A real polynomial family is exactly the interpretation of a displayed list of rational polynomial codes.
Definition (Lean source)
def PolynomialCodesRealize {σ : Type} [DecidableEq σ]
(codes : List (AtlasPolynomialCode σ))
(family : Finset (MvPolynomial σ ℝ)) : Prop :=
codes.Nodup ∧ (codes.map AtlasPolynomialCode.toReal).toFinset = family
def toComplex
Interpret the same rational syntax as a complex polynomial.
Definition (Lean source)
def AtlasPolynomialCode.toComplex {σ : Type} [DecidableEq σ]
(code : AtlasPolynomialCode σ) : MvPolynomial σ ℂ :=
code.terms.foldl (fun P term =>
P + monomial
(term.2.foldl (fun exponents xe => exponents + Finsupp.single xe.1 xe.2) 0)
(term.1 : ℂ)) 0
A complex polynomial family is exactly the interpretation of rational polynomial codes.
Definition (Lean source)
def ComplexPolynomialCodesRealize {σ : Type} [DecidableEq σ]
(codes : List (AtlasPolynomialCode σ))
(family : Finset (MvPolynomial σ ℂ)) : Prop :=
codes.Nodup ∧ (codes.map AtlasPolynomialCode.toComplex).toFinset = family
Every intermediate family in a machine payload decodes, in order, to the corresponding family actually read or emitted by the certified trace.
Definition (Lean source)
def PolynomialCodeFamiliesRealize {σ : Type} [DecidableEq σ]
(codes : List (List (AtlasPolynomialCode σ)))
(families : List (Finset (MvPolynomial σ ℝ))) : Prop :=
List.Forall₂ PolynomialCodesRealize codes families
def ComplexPolynomialCodeFamiliesRealize Definition aux_ComplexPolynomialCodeFamiliesRealize in the paper ↗
Every complex intermediate family in the payload decodes to the family actually read or emitted by the certified Step-2 trace.
Definition (Lean source)
def ComplexPolynomialCodeFamiliesRealize {σ : Type} [DecidableEq σ]
(codes : List (List (AtlasPolynomialCode σ)))
(families : List (Finset (MvPolynomial σ ℂ))) : Prop :=
List.Forall₂ ComplexPolynomialCodesRealize codes families
def atlasPolynomialSignCode
Encode the three-valued sign alphabet by natural numbers for the machine payload.
Definition (Lean source)
def atlasPolynomialSignCode : PolynomialSign → ℕ
| .negative => 0
| .zero => 1
| .positive => 2
A concrete halting partial-recursive run producing the complete finite symbolic payload. Its output is required to be the Encodable code of the payload actually used by the atlas, so the effectivity witness cannot be an unrelated existence Prop. The existential evaln fuel witnesses halting only; it is not compared with the separate real-algebraic arithmetic/sign-operation count.
Definition (Lean source)
parameters
m :
ℕ
payload :
fields
code :
inputCode :
ℕ
outputCode :
ℕ
fuel :
ℕ
input_eq :
inputCode = m
output_eq :
outputCode = Encodable.encode payload
halts_within :
code.evaln fuel inputCode = some outputCode
def atlasObservableCoordinateCount
Observable-coordinate count q_K, for K = 2m+2.
Definition (Lean source)
def atlasObservableCoordinateCount (m : ℕ) : ℕ :=
let K := 2 * m + 2
K * (K + 3) / 2 - 2
def atlasParameterCoordinateCount
Structural-coordinate count p_K = (m+2)K-1.
Definition (Lean source)
def atlasParameterCoordinateCount (m : ℕ) : ℕ := (m + 2) * (2 * m + 2) - 1
def atlasSourceCoordinateCount
Number of real coordinates in the simultaneous two-arrow incidence input.
Definition (Lean source)
def atlasSourceCoordinateCount (m : ℕ) : ℕ :=
atlasObservableCoordinateCount m + 2 * atlasParameterCoordinateCount m +
4 * (m + 2) ^ 2
def atlasSourceDegreeBound
Explicit degree bound from the cumulant/moment equations and the two genericity-saturation products.
Definition (Lean source)
def atlasSourceDegreeBound (m : ℕ) : ℕ :=
max (2 * m + 3) (1 + m + m * (m - 1) / 2 + (m + 2) * (2 * m + 1))
theorem atlasSourceDegreeBound_positive
The concrete incidence presentation has a positive degree envelope. This is derived from the displayed formula, rather than assumed by the atlas theorem, and supplies the 1 ≤ D domain premise of the cited complexity interface.
Formal statement
Proof (Lean source)
theorem atlasSourceDegreeBound_positive (m : ℕ) :
1 ≤ atlasSourceDegreeBound m := by
unfold atlasSourceDegreeBound
omega
def atlasPolynomialFamilyDegreeMaximum
The largest total degree in one finite polynomial family. This is a paper-side bookkeeping operation: it is evaluated only after the cited elimination output has been returned, so it does not pretend that the pre-elimination incidence bound also bounds a Gröbner basis.
Definition (Lean source)
def atlasPolynomialFamilyDegreeMaximum {K : Type} [Field K] [DecidableEq K]
{r : ℕ} (family : Finset (MvPolynomial (Fin r) K)) : ℕ :=
family.sup totalDegree
def atlasGroebnerJobDegreeMaximum
The largest total degree charged by one supplied algebra job.
Definition (Lean source)
def atlasGroebnerJobDegreeMaximum {K : Type} [Field K] [DecidableEq K]
(job : EffectiveGroebnerJobOver K) : ℕ :=
atlasPolynomialFamilyDegreeMaximum
(job.input ∪ job.secondInput ∪ {job.saturating})
def atlasCADJobDegreeMaximum
The largest total degree charged by one supplied CAD input. Generated CAD projection polynomials are outputs of the cited run and are deliberately not reclassified as inputs in this envelope.
Definition (Lean source)
def atlasCADJobDegreeMaximum (job : EffectiveRationalCADJob) : ℕ :=
max (atlasPolynomialFamilyDegreeMaximum job.input)
(max (atlasPolynomialFamilyDegreeMaximum job.secondInput)
job.saturating.totalDegree)
theorem atlasPolynomialFamily_degreeBoundedBy_maximum
The largest total degree occurring in a finite polynomial family is a valid uniform degree envelope for that family: every member has total degree at most that maximum.
Formal statement
hypotheses
conclusion
Proof (Lean source)
theorem atlasPolynomialFamily_degreeBoundedBy_maximum
{K : Type} [Field K] [DecidableEq K] {r : ℕ}
(family : Finset (MvPolynomial (Fin r) K)) :
EffectivePolynomialFamilyDegreeBoundedBy family
(atlasPolynomialFamilyDegreeMaximum family) := by
intro P hP
exact Finset.le_sup hP
theorem atlasGroebnerJob_degreeBoundedBy_maximum
The largest total degree charged by an algebra job is a valid uniform degree bound for it: both input families and the saturating polynomial have total degree at most that maximum.
Formal statement
Proof (Lean source)
theorem atlasGroebnerJob_degreeBoundedBy_maximum
{K : Type} [Field K] [DecidableEq K]
(job : EffectiveGroebnerJobOver K) :
job.DegreeBoundedBy (atlasGroebnerJobDegreeMaximum job) := by
intro P hP
exact Finset.le_sup hP
theorem atlasCADJob_degreeBoundedBy_maximum
Proves the stated mathematical property of atlas CADJob degree Bounded By maximum.
Formal statement
Proof (Lean source)
theorem atlasCADJob_degreeBoundedBy_maximum (job : EffectiveRationalCADJob) :
job.DegreeBoundedBy (atlasCADJobDegreeMaximum job) := by
intro P hP
simp only [mem_union, mem_singleton] at hP
rcases hP with (hP | hP) | rfl
· exact (Finset.le_sup hP).trans (by
unfold atlasCADJobDegreeMaximum atlasPolynomialFamilyDegreeMaximum
omega)
· exact (Finset.le_sup hP).trans (by
unfold atlasCADJobDegreeMaximum atlasPolynomialFamilyDegreeMaximum
omega)
· unfold atlasCADJobDegreeMaximum atlasPolynomialFamilyDegreeMaximum
omega
def atlasChargedDegreeBound
Post-elimination degree envelope for the actual paper execution. In addition to the exact source-incidence degree, this finite maximum charges the two supplied elimination jobs, their returned saturated elimination bases, the dependent intersection job and its returned intersection basis, and the CAD input that consumes that basis.
Definition (Lean source)
def atlasChargedDegreeBound (m : ℕ) (execution : AtlasCitedEffectiveExecution) : ℕ :=
max (atlasSourceDegreeBound m)
(max (atlasGroebnerJobDegreeMaximum execution.forwardEliminationJob)
(max (atlasGroebnerJobDegreeMaximum execution.reverseEliminationJob)
(max (atlasPolynomialFamilyDegreeMaximum
execution.dependentPipeline.forwardResult.result.saturatedEliminationBasis)
(max (atlasPolynomialFamilyDegreeMaximum
execution.dependentPipeline.reverseResult.result.saturatedEliminationBasis)
(max (atlasGroebnerJobDegreeMaximum
execution.dependentPipeline.intersectionJob)
(max (atlasPolynomialFamilyDegreeMaximum
execution.dependentPipeline.intersectionResult.result.intersectionBasis)
(atlasCADJobDegreeMaximum execution.cadJob)))))))
theorem atlasSourceDegreeBound_le_charged
Proves the stated mathematical property of atlas Source Degree Bound le charged.
Formal statement
hypotheses
m :
ℕ
execution :
conclusion
atlasSourceDegreeBound m ≤ atlasChargedDegreeBound m execution
Proof (Lean source)
theorem atlasSourceDegreeBound_le_charged (m : ℕ)
(execution : AtlasCitedEffectiveExecution) :
atlasSourceDegreeBound m ≤ atlasChargedDegreeBound m execution := by
exact Nat.le_max_left _ _
theorem atlasChargedDegreeBound_positive
Proves the stated mathematical property of atlas Charged Degree Bound positive.
Formal statement
Proof (Lean source)
theorem atlasChargedDegreeBound_positive (m : ℕ)
(execution : AtlasCitedEffectiveExecution) :
1 ≤ atlasChargedDegreeBound m execution :=
(atlasSourceDegreeBound_positive m).trans
(atlasSourceDegreeBound_le_charged m execution)
theorem atlasDependentPipeline_degreeBoundedBy_charged
The finite maximum really bounds every input and returned basis charged by the dependent two-arrow elimination/intersection pipeline.
Formal statement
hypotheses
m :
ℕ
execution :
conclusion
execution.dependentPipeline.DegreeBoundedBy (atlasChargedDegreeBound m execution)
Proof (Lean source)
theorem atlasDependentPipeline_degreeBoundedBy_charged (m : ℕ)
(execution : AtlasCitedEffectiveExecution) :
execution.dependentPipeline.DegreeBoundedBy
(atlasChargedDegreeBound m execution) := by
refine ⟨?_, ?_, ?_, ?_, ?_, ?_⟩
· exact fun P hP =>
(atlasGroebnerJob_degreeBoundedBy_maximum
execution.forwardEliminationJob P hP).trans (by
unfold atlasChargedDegreeBound
omega)
· exact fun P hP =>
(atlasGroebnerJob_degreeBoundedBy_maximum
execution.reverseEliminationJob P hP).trans (by
unfold atlasChargedDegreeBound
omega)
· exact fun P hP =>
(atlasPolynomialFamily_degreeBoundedBy_maximum
execution.dependentPipeline.forwardResult.result.saturatedEliminationBasis
P hP).trans (by
unfold atlasChargedDegreeBound
omega)
· exact fun P hP =>
(atlasPolynomialFamily_degreeBoundedBy_maximum
execution.dependentPipeline.reverseResult.result.saturatedEliminationBasis
P hP).trans (by
unfold atlasChargedDegreeBound
omega)
· exact fun P hP =>
(atlasGroebnerJob_degreeBoundedBy_maximum
execution.dependentPipeline.intersectionJob P hP).trans (by
unfold atlasChargedDegreeBound
omega)
· exact fun P hP =>
(atlasPolynomialFamily_degreeBoundedBy_maximum
execution.dependentPipeline.intersectionResult.result.intersectionBasis
P hP).trans (by
unfold atlasChargedDegreeBound
omega)
theorem atlasCADJob_degreeBoundedBy_charged
The same charged maximum bounds the exact CAD input. The generated CAD projection family is intentionally absent: it is an output, not an input to the universal complexity call.
Formal statement
hypotheses
m :
ℕ
execution :
conclusion
execution.cadJob.DegreeBoundedBy (atlasChargedDegreeBound m execution)
Proof (Lean source)
theorem atlasCADJob_degreeBoundedBy_charged (m : ℕ)
(execution : AtlasCitedEffectiveExecution) :
execution.cadJob.DegreeBoundedBy (atlasChargedDegreeBound m execution) := by
intro P hP
exact (atlasCADJob_degreeBoundedBy_maximum execution.cadJob P hP).trans (by
unfold atlasChargedDegreeBound
omega)
Explicit size and complexity receipt for the finite symbolic construction. The source-incidence bound remains the displayed cumulant-equation formula; the distinct charged bound is chosen after the cited elimination pipeline and is the degree parameter used by the combined complexity theorem.
Definition (Lean source)
parameters
fields
q :
ℕ
p :
ℕ
n :
ℕ
sourceCoordinateCount :
ℕ
sourcePolynomialCount :
ℕ
sourceDegreeBound :
ℕ
chargedDegreeBound :
ℕ
arithmeticSignOperations :
ℕ
exponentConstant :
ℕ
exponentOffset :
ℕ
recordedTraceLength :
ℕ
q_eq :
p_eq :
n_eq :
n = m + 2
source_coordinates_eq :
sourceCoordinateCount = atlasSourceCoordinateCount m
source_degree_eq :
sourceDegreeBound = atlasSourceDegreeBound m
source_degree_positive :
1 ≤ sourceDegreeBound
charged_degree_eq :
chargedDegreeBound = atlasChargedDegreeBound m execution
source_degree_le_charged :
sourceDegreeBound ≤ chargedDegreeBound
charged_degree_positive :
1 ≤ chargedDegreeBound
universal_algorithm_constants :
UniversalEffectiveRationalGroebnerCADBound exponentConstant exponentOffset
operations_le_bound :
arithmeticSignOperations
≤ (max 2 (sourcePolynomialCount * chargedDegreeBound)) ^ (2 ^ (exponentConstant * sourceCoordinateCount + exponentOffset))
trace_length_eq :
recordedTraceLength = traceLength
trace_length_le :
recordedTraceLength ≤ arithmeticSignOperations
The paper-specific effective/evaluable real exceptional atlas output.
Definition (Lean source)
parameters
m :
ℕ
fields
atlas :
forwardComplexIncidenceFamily :
reverseComplexIncidenceFamily :
forwardComplexObservableFamily :
Finset (MvPolynomial (ℕ × ℕ) ℂ)
reverseComplexObservableFamily :
Finset (MvPolynomial (ℕ × ℕ) ℂ)
complexExceptionalFamily :
Finset (MvPolynomial (ℕ × ℕ) ℂ)
forward_complex_incidence_exact :
DefinesComplexGenericIncidenceEquations m .forward forwardComplexIncidenceFamily
reverse_complex_incidence_exact :
DefinesComplexGenericIncidenceEquations m .reverse reverseComplexIncidenceFamily
forward_complex_elimination_exact :
IsExactComplexObservableElimination m .forward forwardComplexObservableFamily
reverse_complex_elimination_exact :
IsExactComplexObservableElimination m .reverse reverseComplexObservableFamily
complex_exceptional_exact :
atlasComplexObservableZeroSet m complexExceptionalFamily = genericCompatibilityClosure m
baseObservableFamily :
Finset (MvPolynomial (ℕ × ℕ) ℝ)
The effective CAD stage family after both the witness and structural
prefixes have been projected. Unlike `baseObservableFamily`, this family
describes the recursive geometry of individual observable base cells.
baseGeometryFamily :
Finset (MvPolynomial (ℕ × ℕ) ℝ)
baseOrder :
List (ℕ × ℕ)
base_order_nodup :
baseOrder.Nodup
base_order_covers :
∀ P ∈ baseGeometryFamily, ∀ x ∈ P.vars, x ∈ baseOrder
baseCellCode :
Fin atlas.baseCellCount → AtlasCellCode
base_code_realizes :
∀ i,
(baseCellCode i).Realizes baseGeometryFamily baseOrder { a : (ℕ × ℕ) → ℝ | (fun r s => a (r, s)) ∈ atlas.baseCell i }
forwardFiberFamily :
reverseFiberFamily :
forwardFiberOrder :
List (AtlasFiberCoord m)
reverseFiberOrder :
List (AtlasFiberCoord m)
forward_order_nodup :
forwardFiberOrder.Nodup
reverse_order_nodup :
reverseFiberOrder.Nodup
forward_order_covers :
∀ P ∈ forwardFiberFamily, ∀ x ∈ P.vars, x ∈ forwardFiberOrder
reverse_order_covers :
∀ P ∈ reverseFiberFamily, ∀ x ∈ P.vars, x ∈ reverseFiberOrder
forward_order_loading_before_observable :
IsAtlasFiberVariableOrder forwardFiberOrder
reverse_order_loading_before_observable :
IsAtlasFiberVariableOrder reverseFiberOrder
forwardCandidateCellCount :
Fin atlas.baseCellCount → ℕ
reverseCandidateCellCount :
Fin atlas.baseCellCount → ℕ
forwardCandidateCell :
∀ i
if
Fin (forwardCandidateCellCount i)
then
reverseCandidateCell :
∀ i
if
Fin (reverseCandidateCellCount i)
then
forwardCandidateCellCode :
∀ i
if
Fin (forwardCandidateCellCount i)
then
reverseCandidateCellCode :
∀ i
if
Fin (reverseCandidateCellCount i)
then
forward_candidate_code_realizes :
∀ i k,
(forwardCandidateCellCode i k).Realizes forwardFiberFamily forwardFiberOrder (forwardCandidateCell i k)
reverse_candidate_code_realizes :
∀ i k,
(reverseCandidateCellCode i k).Realizes reverseFiberFamily reverseFiberOrder (reverseCandidateCell i k)
forwardRetainedCellCount :
Fin atlas.baseCellCount → ℕ
reverseRetainedCellCount :
Fin atlas.baseCellCount → ℕ
forwardRetainedCell :
∀ i
if
Fin (forwardRetainedCellCount i)
then
reverseRetainedCell :
∀ i
if
Fin (reverseRetainedCellCount i)
then
forwardRetainedSelection :
reverseRetainedSelection :
forward_retained_selected :
∀ i k, forwardRetainedCell i k = forwardCandidateCell i (forwardRetainedSelection i k)
reverse_retained_selected :
∀ i k, reverseRetainedCell i k = reverseCandidateCell i (reverseRetainedSelection i k)
forward_cell_nonempty :
∀ i k, (forwardRetainedCell i k).Nonempty
reverse_cell_nonempty :
∀ i k, (reverseRetainedCell i k).Nonempty
forward_recursive :
∀ i k,
IsRecursivelyLiftedCADCell forwardFiberFamily forwardFiberOrder (forwardRetainedCell i k)
reverse_recursive :
∀ i k,
IsRecursivelyLiftedCADCell reverseFiberFamily reverseFiberOrder (reverseRetainedCell i k)
forward_stack_disjoint :
∀ i k l
if
k ≠ l
then
Disjoint (forwardRetainedCell i k) (forwardRetainedCell i l)
reverse_stack_disjoint :
∀ i k l
if
k ≠ l
then
Disjoint (reverseRetainedCell i k) (reverseRetainedCell i l)
forward_stack_cylindrical :
∀ i, IsCylindricallyArranged forwardFiberOrder (forwardRetainedCell i)
reverse_stack_cylindrical :
∀ i, IsCylindricallyArranged reverseFiberOrder (reverseRetainedCell i)
forward_projects_base :
∀ i k, { t | ∃ lam, atlasFiberEval t lam ∈ forwardRetainedCell i k } = atlas.baseCell i
reverse_projects_base :
∀ i k, { t | ∃ lam, atlasFiberEval t lam ∈ reverseRetainedCell i k } = atlas.baseCell i
forward_witness_eliminated :
∀ i t
if
t ∈ atlas.baseCell i
then
{ lam | ∃ w z, ∃ k, atlasIncidenceEval t lam w z ∈ atlas.forwardCell i k }
= { lam | ∃ k, atlasFiberEval t lam ∈ forwardRetainedCell i k }
reverse_witness_eliminated :
∀ i t
if
t ∈ atlas.baseCell i
then
{ lam | ∃ w z, ∃ k, atlasIncidenceEval t lam w z ∈ atlas.reverseCell i k }
= { lam | ∃ k, atlasFiberEval t lam ∈ reverseRetainedCell i k }
forward_section_exact :
∀ i t
if
t ∈ atlas.baseCell i
then
{ lam | ∃ k, atlasFiberEval t lam ∈ forwardRetainedCell i k }
= realAtlasForwardSection m t
reverse_section_exact :
∀ i t
if
t ∈ atlas.baseCell i
then
{ lam | ∃ k, atlasFiberEval t lam ∈ reverseRetainedCell i k }
= realAtlasReverseSection m t
trace :
CertifiedAtlasConstructionTrace m atlas forwardComplexIncidenceFamily reverseComplexIncidenceFamily forwardComplexObservableFamily reverseComplexObservableFamily complexExceptionalFamily forwardFiberFamily reverseFiberFamily baseObservableFamily baseGeometryFamily
Every displayed base/fiber cell indexes the cited prefix-projection
artifact that produced it. Raw full-cell certificates are retained only as
source indices; no paper cell is manufactured by syntactically peeling a
full recursive code.
citedForwardCandidateSourceCell :
citedReverseCandidateSourceCell :
citedBasePrefixCertificate :
citedForwardCandidatePrefixCertificate :
citedReverseCandidatePrefixCertificate :
cited_base_cell_artifact_exact :
∀ i,
let certificate := trace.citedExecution.cadResult.result.payload.prefixProjectionCertificates.get (citedBasePrefixCertificate i) certificate.eliminatedVariables
= trace.witnessPrefix ++ trace.loadingPrefix ∧
certificate.retainedVariables = trace.observableSuffix ∧
certificate.sourceCellIndex = (citedBaseSourceCell i).val ∧
certificate.sourceCellCertificateCode
= Encodable.encode (trace.citedExecution.cadResult.result.cellCertificate (citedBaseSourceCell i)) ∧
certificate.projectedGeometryCode = Encodable.encode certificate.projectedGeometry ∧
certificate.projectedGeometry.toAtlasCellCode = baseCellCode i
cited_forward_candidate_artifact_exact :
∀ i k,
let certificate := trace.citedExecution.cadResult.result.payload.prefixProjectionCertificates.get (citedForwardCandidatePrefixCertificate i k) certificate.eliminatedVariables
= trace.witnessPrefix ∧
certificate.retainedVariables = trace.loadingPrefix ++ trace.observableSuffix ∧
certificate.sourceCellIndex = (citedForwardCandidateSourceCell i k).val ∧
certificate.sourceCellCertificateCode
= Encodable.encode (trace.citedExecution.cadResult.result.cellCertificate (citedForwardCandidateSourceCell i k)) ∧
certificate.projectedGeometryCode = Encodable.encode certificate.projectedGeometry ∧
certificate.projectedGeometry.toAtlasCellCode = forwardCandidateCellCode i k
cited_reverse_candidate_artifact_exact :
∀ i k,
let certificate := trace.citedExecution.cadResult.result.payload.prefixProjectionCertificates.get (citedReverseCandidatePrefixCertificate i k) certificate.eliminatedVariables
= trace.witnessPrefix ∧
certificate.retainedVariables = trace.loadingPrefix ++ trace.observableSuffix ∧
certificate.sourceCellIndex = (citedReverseCandidateSourceCell i k).val ∧
certificate.sourceCellCertificateCode
= Encodable.encode (trace.citedExecution.cadResult.result.cellCertificate (citedReverseCandidateSourceCell i k)) ∧
certificate.projectedGeometryCode = Encodable.encode certificate.projectedGeometry ∧
certificate.projectedGeometry.toAtlasCellCode = reverseCandidateCellCode i k
cited_base_cell_transport_exact :
∀ i,
cadObservableCumVec trace.cadIncidenceEmbedding '' trace.citedExecution.cadResult.result.prefixProjectedCell (trace.witnessPrefix ++ trace.loadingPrefix) (citedBaseSourceCell i)
= atlas.baseCell i
cited_forward_candidate_transport_exact :
∀ i k,
cadFiberAssignment trace.cadIncidenceEmbedding '' trace.citedExecution.cadResult.result.prefixProjectedCell trace.witnessPrefix (citedForwardCandidateSourceCell i k)
= forwardCandidateCell i k
cited_reverse_candidate_transport_exact :
∀ i k,
cadFiberAssignment trace.cadIncidenceEmbedding '' trace.citedExecution.cadResult.result.prefixProjectedCell trace.witnessPrefix (citedReverseCandidateSourceCell i k)
= reverseCandidateCell i k
cited_base_prefix_artifact_traced :
∀ i,
let certificate := trace.citedExecution.cadResult.result.payload.prefixProjectionCertificates.get (citedBasePrefixCertificate i) ∃ step ∈ trace.citedExecution.cadResult.result.payload.trace, step.operation
= .prefixCellProjection ∧
Encodable.encode certificate ∈ step.producedPrefixProjectionCertificateCodes
cited_forward_prefix_artifact_traced :
∀ i k,
let certificate := trace.citedExecution.cadResult.result.payload.prefixProjectionCertificates.get (citedForwardCandidatePrefixCertificate i k) ∃ step ∈ trace.citedExecution.cadResult.result.payload.trace, step.operation
= .prefixCellProjection ∧
Encodable.encode certificate ∈ step.producedPrefixProjectionCertificateCodes
cited_reverse_prefix_artifact_traced :
∀ i k,
let certificate := trace.citedExecution.cadResult.result.payload.prefixProjectionCertificates.get (citedReverseCandidatePrefixCertificate i k) ∃ step ∈ trace.citedExecution.cadResult.result.payload.trace, step.operation
= .prefixCellProjection ∧
Encodable.encode certificate ∈ step.producedPrefixProjectionCertificateCodes
citedForwardRetentionRow :
citedReverseRetentionRow :
Retention is deduplication by equality of projected images. Each kept
projected cell has a retained source representative, representatives are
distinct after projection, and every retained raw source is covered by one
representative.
cited_forward_retained_representative :
∀ i k,
(citedForwardCandidateSourceCell i (forwardRetainedSelection i k)).val ∈ (trace.citedExecution.cadResult.result.payload.retainedCellRows.get (citedForwardRetentionRow i)).retainedCellIndices
cited_forward_retained_images_distinct :
∀ i k l
if
k ≠ l
then
trace.citedExecution.cadResult.result.prefixProjectedCell trace.witnessPrefix (citedForwardCandidateSourceCell i (forwardRetainedSelection i k))
≠ trace.citedExecution.cadResult.result.prefixProjectedCell trace.witnessPrefix (citedForwardCandidateSourceCell i (forwardRetainedSelection i l))
cited_forward_retained_source_cover :
∀ i (source : Fin trace.citedExecution.cadResult.result.cellCount)
if
source.val ∈ (trace.citedExecution.cadResult.result.payload.retainedCellRows.get (citedForwardRetentionRow i)).retainedCellIndices
then
∃ k,
trace.citedExecution.cadResult.result.prefixProjectedCell trace.witnessPrefix source
= trace.citedExecution.cadResult.result.prefixProjectedCell trace.witnessPrefix (citedForwardCandidateSourceCell i (forwardRetainedSelection i k))
cited_forward_retention_query_exact :
∀ i,
(trace.citedExecution.cadResult.result.payload.retainedCellRows.get (citedForwardRetentionRow i)).query.PopulatesAtlasIncidenceSignCondition trace.cadIncidenceEmbedding atlas.forwardEquations atlas.forwardNonnegative atlas.forwardPositive
cited_reverse_retained_representative :
∀ i k,
(citedReverseCandidateSourceCell i (reverseRetainedSelection i k)).val ∈ (trace.citedExecution.cadResult.result.payload.retainedCellRows.get (citedReverseRetentionRow i)).retainedCellIndices
cited_reverse_retained_images_distinct :
∀ i k l
if
k ≠ l
then
trace.citedExecution.cadResult.result.prefixProjectedCell trace.witnessPrefix (citedReverseCandidateSourceCell i (reverseRetainedSelection i k))
≠ trace.citedExecution.cadResult.result.prefixProjectedCell trace.witnessPrefix (citedReverseCandidateSourceCell i (reverseRetainedSelection i l))
cited_reverse_retained_source_cover :
∀ i (source : Fin trace.citedExecution.cadResult.result.cellCount), source.val ∈
The output shape of the paper's atlas handle at complexity m: the engine returns a value of RealAtlasCADData m. This is a definition of what the handle emits, not an assertion that it exists. It is retained as an unasserted name for the weaker raw-CAD output shape. The proved paper-specific theorem concludes the strictly richer Nonempty (EffectiveRealAtlasOutput m), which also carries finite sign-table evaluators and their exactness certificates.
Definition (Lean source)
def realAtlasCADStratification (m : ℕ) : Prop := Nonempty (RealAtlasCADData m)
Real exceptional-locus atlas handle — the CITED external interface (I-3).
Definition (Lean source)
-- @node: def:real-atlas-handle
def realAtlasHandleOutput : Prop := RealClosedFieldCADInterface
Helpers.AdmissibleSwaps 12 declarations
The admissible middle-block relabeling, as a permutation of all source indices.
Definition (Lean source)
-- @node: permMiddleEquiv
def permMiddleEquiv (m : ℕ) (π : Perm (Fin m)) : Perm (Fin (m + 2)) where
toFun := permMiddle m π
invFun := permMiddle m π⁻¹
left_inv := by
intro j
apply Fin.ext
simp only [permMiddle]
split_ifs <;> simp_all <;> omega
right_inv := by
intro j
apply Fin.ext
simp only [permMiddle]
split_ifs <;> simp_all <;> omega
Relabeling the middle source indices while keeping the two endpoint indices fixed does not change a finite sum.
Formal statement
hypotheses
conclusion
(∑ j, f (permMiddle m π j)) = ∑ j, f j
Proof (Lean source)
lemma sum_permMiddle {A : Type*} [AddCommMonoid A] (m : ℕ) (π : Perm (Fin m))
(f : Fin (m + 2) → A) :
(∑ j, f (permMiddle m π j)) = ∑ j, f j := by
exact Fintype.sum_equiv (permMiddleEquiv m π) _ _ (fun _ => rfl)
theorem forwardLoading_admissibleSourceSwap
After an admissible source relabeling, each forward loading equals the original loading at the correspondingly relabeled source.
Formal statement
hypotheses
conclusion
= forwardLoading m θ.1 θ.2.1 (permMiddle m π j)
Proof (Lean source)
lemma forwardLoading_admissibleSourceSwap {R : Type*} [CommRing R] (m : ℕ)
(π : Perm (Fin m)) (θ : ParamSpace R m) (j : Fin (m + 2)) :
forwardLoading m (admissibleSourceSwap m π θ).1
(admissibleSourceSwap m π θ).2.1 j =
forwardLoading m θ.1 θ.2.1 (permMiddle m π j) := by
simp only [admissibleSourceSwap, forwardLoading, permMiddle]
split_ifs <;> simp_all <;> try omega
theorem reverseLoading_admissibleSourceSwap
After an admissible source relabeling, each reverse loading equals the original loading at the correspondingly relabeled source.
Formal statement
hypotheses
conclusion
= reverseLoading m η.1 η.2.1 (permMiddle m π j)
Proof (Lean source)
lemma reverseLoading_admissibleSourceSwap {R : Type*} [CommRing R] (m : ℕ)
(π : Perm (Fin m)) (η : ParamSpace R m) (j : Fin (m + 2)) :
reverseLoading m (admissibleSourceSwap m π η).1
(admissibleSourceSwap m π η).2.1 j =
reverseLoading m η.1 η.2.1 (permMiddle m π j) := by
simp only [admissibleSourceSwap, reverseLoading, permMiddle]
split_ifs <;> simp_all <;> try omega
theorem forwardCumulantMap_admissibleSourceSwap
The forward cumulant map is unchanged by any admissible relabeling of the middle sources.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma forwardCumulantMap_admissibleSourceSwap {R : Type*} [CommRing R] (m L : ℕ)
(π : Perm (Fin m)) (θ : ParamSpace R m) :
forwardCumulantMap m L (admissibleSourceSwap m π θ) = forwardCumulantMap m L θ := by
funext r a
simp only [forwardCumulantMap]
split_ifs
· simp_rw [forwardLoading_admissibleSourceSwap]
change (∑ j : Fin (m + 2),
θ.2.2 (permMiddle m π j) r *
(forwardLoading m θ.1 θ.2.1 (permMiddle m π j)).1 ^ (r - a) *
(forwardLoading m θ.1 θ.2.1 (permMiddle m π j)).2 ^ a) = _
exact sum_permMiddle (A := R) m π (fun j =>
θ.2.2 j r * (forwardLoading m θ.1 θ.2.1 j).1 ^ (r - a) *
(forwardLoading m θ.1 θ.2.1 j).2 ^ a)
· rfl
theorem reverseCumulantMap_admissibleSourceSwap
The reverse cumulant map is unchanged by any admissible relabeling of the middle sources.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma reverseCumulantMap_admissibleSourceSwap {R : Type*} [CommRing R] (m L : ℕ)
(π : Perm (Fin m)) (η : ParamSpace R m) :
reverseCumulantMap m L (admissibleSourceSwap m π η) = reverseCumulantMap m L η := by
funext r a
simp only [reverseCumulantMap]
split_ifs
· simp_rw [reverseLoading_admissibleSourceSwap]
change (∑ j : Fin (m + 2),
η.2.2 (permMiddle m π j) r *
(reverseLoading m η.1 η.2.1 (permMiddle m π j)).1 ^ (r - a) *
(reverseLoading m η.1 η.2.1 (permMiddle m π j)).2 ^ a) = _
exact sum_permMiddle (A := R) m π (fun j =>
η.2.2 j r * (reverseLoading m η.1 η.2.1 j).1 ^ (r - a) *
(reverseLoading m η.1 η.2.1 j).2 ^ a)
· rfl
Extend a permutation of the middle slopes by fixing the leading direct-slope index.
Definition (Lean source)
def permLeadingEquiv (m : ℕ) (π : Perm (Fin m)) : Perm (Fin (m + 1)) where
toFun := Fin.cases 0 (fun i => succ (π i))
invFun := Fin.cases 0 (fun i => succ (π⁻¹ i))
left_inv := by
intro j
refine Fin.cases ?_ (fun i => ?_) j
· rfl
· simp
right_inv := by
intro j
refine Fin.cases ?_ (fun i => ?_) j
· rfl
· simp
If the direct slope together with all latent slopes are distinct, they remain distinct after permuting the latent slopes.
Formal statement
Proof (Lean source)
lemma finCons_comp_perm_injective {R : Type*} {m : ℕ} (x : R) (f : Fin m → R)
(π : Perm (Fin m)) (h : Injective (Fin.cons x f)) :
Injective (Fin.cons x (fun i => f (π i))) := by
have hcomp (i : Fin (m + 1)) :
(Fin.cons x (fun j => f (π j)) : Fin (m + 1) → R) i =
(Fin.cons x f : Fin (m + 1) → R) (permLeadingEquiv m π i) := by
refine Fin.cases ?_ (fun j => ?_) i
· rfl
· rfl
intro i j hij
apply (permLeadingEquiv m π).injective
apply h
rw [← hcomp i, ← hcomp j]
exact hij
theorem realFeasibleRegion_admissibleSourceSwap
The real feasible parameter region is closed under admissible relabeling of the middle sources.
Formal statement
hypotheses
conclusion
admissibleSourceSwap m π θ ∈ realFeasibleRegion m L
Proof (Lean source)
lemma realFeasibleRegion_admissibleSourceSwap (m L : ℕ) (π : Perm (Fin m))
(θ : ParamSpace ℝ m) (hθ : θ ∈ realFeasibleRegion m L) :
admissibleSourceSwap m π θ ∈ realFeasibleRegion m L := by
rcases hθ with ⟨hedge, hinj, hout, hreal⟩
refine ⟨hedge, finCons_comp_perm_injective θ.1 θ.2.1 π hinj, ?_, ?_⟩
· intro j r hr
exact hout (permMiddle m π j) r hr
· intro j
exact hreal (permMiddle m π j)
theorem forwardAxisModel_admissibleSourceSwap
A forward axis model remains a forward axis model when middle sources and their parameters are relabeled together.
Formal statement
hypotheses
Ω :
Type*
m :
ℕ
θ :
ParamSpace ℝ m
S :
Fin (m + 2) → Ω → ℝ
X Y :
Ω → ℝ
h :
ForwardAxisModel X Y S θ.1 θ.2.1
conclusion
ForwardAxisModel X Y (fun i => S (permMiddle m π i)) (admissibleSourceSwap m π θ).1 (admissibleSourceSwap m π θ).2.1
Proof (Lean source)
lemma forwardAxisModel_admissibleSourceSwap {Ω : Type*} [MeasurableSpace Ω] (m : ℕ)
(π : Perm (Fin m)) (θ : ParamSpace ℝ m) (S : Fin (m + 2) → Ω → ℝ)
(X Y : Ω → ℝ) (h : ForwardAxisModel X Y S θ.1 θ.2.1) :
ForwardAxisModel X Y (fun i => S (permMiddle m π i))
(admissibleSourceSwap m π θ).1 (admissibleSourceSwap m π θ).2.1 := by
constructor
· intro ω
rw [h.1 ω]
simp only [forwardLoading_admissibleSourceSwap]
exact (sum_permMiddle m π _).symm
· intro ω
rw [h.2 ω]
simp only [forwardLoading_admissibleSourceSwap]
exact (sum_permMiddle m π _).symm
theorem reverseAxisModel_admissibleSourceSwap
A reverse axis model remains a reverse axis model when middle sources and their parameters are relabeled together.
Formal statement
hypotheses
Ω :
Type*
m :
ℕ
η :
ParamSpace ℝ m
S :
Fin (m + 2) → Ω → ℝ
X Y :
Ω → ℝ
h :
ReverseAxisModel X Y S η.1 η.2.1
conclusion
ReverseAxisModel X Y (fun i => S (permMiddle m π i)) (admissibleSourceSwap m π η).1 (admissibleSourceSwap m π η).2.1
Proof (Lean source)
lemma reverseAxisModel_admissibleSourceSwap {Ω : Type*} [MeasurableSpace Ω] (m : ℕ)
(π : Perm (Fin m)) (η : ParamSpace ℝ m) (S : Fin (m + 2) → Ω → ℝ)
(X Y : Ω → ℝ) (h : ReverseAxisModel X Y S η.1 η.2.1) :
ReverseAxisModel X Y (fun i => S (permMiddle m π i))
(admissibleSourceSwap m π η).1 (admissibleSourceSwap m π η).2.1 := by
constructor
· intro ω
rw [h.1 ω]
simp only [reverseLoading_admissibleSourceSwap]
exact (sum_permMiddle m π _).symm
· intro ω
rw [h.2 ω]
simp only [reverseLoading_admissibleSourceSwap]
exact (sum_permMiddle m π _).symm
theorem arrowTaggedOrbit_right_left_disjoint
The admissible-swap orbits tagged as forward and reverse are disjoint, regardless of their parameter values.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma arrowTaggedOrbit_right_left_disjoint {R : Type*} (m : ℕ) (θ η : ParamSpace R m) :
Disjoint (arrowTaggedOrbit m Arrow.right θ) (arrowTaggedOrbit m Arrow.left η) := by
rw [Set.disjoint_left]
intro p hpR hpL
rcases hpR with ⟨π, rfl⟩
rcases hpL with ⟨σ, hσ⟩
have htag := congrArg fst hσ
simp [admissibleSourceSwapTagged] at htag
Helpers.ApolarDefs 3 declarations These realize the divided-power blocks f_r, the constant-coefficient differential operator q(∂), and the squarefree degree-n support annihilator Q_D = ∏_{ℓ ∈ D} ℓ^⊥ used in the common-contraction-kernel identity ker = ⟨Q
Divided-power binary forms, apolar contraction, and the support annihilator
These realize the divided-power blocks f_r, the constant-coefficient differential
operator q(∂), and the squarefree degree-n support annihilator
Q_D = ∏_{ℓ ∈ D} ℓ^⊥ used in the common-contraction-kernel identity ker = ⟨Q_D⟩.
Divided-power binary form of the order-r cumulant block: f_r(x, y) = Σ_{a=0}^r C(r,a) t_{r,a} x^{r-a} y^a (with x = X 0, y = X 1).
Definition (Lean source)
noncomputable def dividedPowerBlock (t : CumVec ℂ) (r : ℕ) : MvPolynomial (Fin 2) ℂ :=
∑ a ∈ range (r + 1),
C ((Nat.choose r a : ℂ) * t r a)
* X 0 ^ (r - a) * X 1 ^ a
Apply the constant-coefficient differential operator q(∂) (with ∂ = (∂_x, ∂_y)) to a binary form f: q(∂) f = Σ_d (coeff_d q) ∂_x^{d 0} ∂_y^{d 1} f.
Definition (Lean source)
noncomputable def diffApply (q f : MvPolynomial (Fin 2) ℂ) : MvPolynomial (Fin 2) ℂ :=
∑ d ∈ q.support,
coeff d q •
((fun g => (pderiv (0 : Fin 2)) g)^[d 0]
((fun g => (pderiv (1 : Fin 2)) g)^[d 1] f))
Squarefree degree-n support annihilator Q_D = ∏_{j} ℓ_j^⊥, the product over all n = m + 2 projective loading directions of the linear form perpendicular to u_j = (u_{j1}, u_{j2}), namely u_{j2} · X 0 - u_{j1} · X 1.
Definition (Lean source)
noncomputable def supportAnnihilator {m : ℕ} (dirs : Fin (m + 2) → ℂ × ℂ) :
MvPolynomial (Fin 2) ℂ :=
∏ j : Fin (m + 2),
(C (dirs j).2 * X 0 - C (dirs j).1 * X 1)
Helpers.ApolarKernel 6 declarations
theorem supportAnnihilator_ne_zero
Each linear factor C b * X0 - C a * X1 is nonzero when (a,b) ≠ (0,0).
Formal statement
hypotheses
conclusion
supportAnnihilator dirs ≠ 0
Proof (Lean source)
lemma supportAnnihilator_ne_zero {m : ℕ} (dirs : Fin (m + 2) → ℂ × ℂ)
(h : ∀ j, (dirs j).1 ≠ 0 ∨ (dirs j).2 ≠ 0) : supportAnnihilator dirs ≠ 0 := by
rw [supportAnnihilator]
apply (Finset.prod_ne_zero_iff).2
intro j _
rcases h j with ha | hb
· intro hj
have he := congrArg
(eval₂ (id ℂ) (fun i : Fin 2 => if i = 0 then 0 else 1)) hj
apply ha
simpa using he
· intro hj
have he := congrArg
(eval₂ (id ℂ) (fun i : Fin 2 => if i = 0 then 1 else 0)) hj
apply hb
simpa using he
theorem X0_dvd_supportAnnihilator_forward
For the forward loading family, the index-(m+1) factor equals X 0, so X 0 ∣ Q_D.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma X0_dvd_supportAnnihilator_forward {m : ℕ} (γ : ℂ) (ρ : Fin m → ℂ) :
(X (0 : Fin 2)) ∣ supportAnnihilator (forwardLoading m γ ρ) := by
rw [supportAnnihilator]
refine dvd_trans ?_ (Finset.dvd_prod_of_mem _
(Finset.mem_univ (⟨m + 1, by omega⟩ : Fin (m + 2))))
simp [forwardLoading]
theorem not_X1_dvd_supportAnnihilator_forward
X 1 ∤ Q_D for the forward loading when its finite slopes are nonzero.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma not_X1_dvd_supportAnnihilator_forward {m : ℕ} (γ : ℂ) (ρ : Fin m → ℂ)
(hγ : γ ≠ 0) (hρ : ∀ i, ρ i ≠ 0) :
¬ (X (1 : Fin 2)) ∣ supportAnnihilator (forwardLoading m γ ρ) := by
intro hd
obtain ⟨p, hp⟩ := hd
have hne : eval₂ (id ℂ) (fun i : Fin 2 => if i = 0 then 1 else 0)
(supportAnnihilator (forwardLoading m γ ρ)) ≠ 0 := by
rw [supportAnnihilator]
rw [eval₂_prod]
simp only [MvPolynomial.eval₂_sub, MvPolynomial.eval₂_mul,
MvPolynomial.eval₂_C, MvPolynomial.eval₂_X, RingHom.id_apply]
apply (Finset.prod_ne_zero_iff).2
intro j _
by_cases hj0 : j.val = 0
· simp [forwardLoading, hj0, hγ]
by_cases hjlast : j.val = m + 1
· simp [forwardLoading, hjlast]
have hjzero : j ≠ 0 := by
intro h
apply hj0
simp [h]
simpa [forwardLoading, hjzero, hjlast] using hρ ⟨j.val - 1, by omega⟩
apply hne
rw [hp]
simp
theorem X1_dvd_supportAnnihilator_reverse
Mirror fixed-axis divisibility for the reverse loading family.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma X1_dvd_supportAnnihilator_reverse {m : ℕ} (δ : ℂ) (σ : Fin m → ℂ) :
(X (1 : Fin 2)) ∣ supportAnnihilator (reverseLoading m δ σ) := by
rw [supportAnnihilator]
refine dvd_trans ?_ (Finset.dvd_prod_of_mem _
(Finset.mem_univ (⟨0, by omega⟩ : Fin (m + 2))))
simp [reverseLoading]
theorem not_X0_dvd_supportAnnihilator_reverse
Mirror nondivisibility for the reverse loading family.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma not_X0_dvd_supportAnnihilator_reverse {m : ℕ} (δ : ℂ) (σ : Fin m → ℂ)
(hδ : δ ≠ 0) (hσ : ∀ i, σ i ≠ 0) :
¬ (X (0 : Fin 2)) ∣ supportAnnihilator (reverseLoading m δ σ) := by
intro hd
obtain ⟨p, hp⟩ := hd
have hne : eval₂ (id ℂ) (fun i : Fin 2 => if i = 0 then 0 else 1)
(supportAnnihilator (reverseLoading m δ σ)) ≠ 0 := by
rw [supportAnnihilator]
rw [eval₂_prod]
simp only [MvPolynomial.eval₂_sub, MvPolynomial.eval₂_mul,
MvPolynomial.eval₂_C, MvPolynomial.eval₂_X, RingHom.id_apply]
apply (Finset.prod_ne_zero_iff).2
intro j _
by_cases hj0 : j.val = 0
· simp [reverseLoading, hj0]
by_cases hjlast : j.val = m + 1
· simpa [reverseLoading, hj0, hjlast] using neg_ne_zero.mpr hδ
simpa [reverseLoading, hj0, hjlast] using neg_ne_zero.mpr
(hσ ⟨j.val - 1, by omega⟩)
apply hne
rw [hp]
simp
theorem supportAnnihilator_eval_zero
The support annihilator vanishes at every listed direction. This is the easy inclusion of the support-annihilator line in the apolar evaluation kernel.
Formal statement
Proof (Lean source)
lemma supportAnnihilator_eval_zero {m : ℕ} (dirs : Fin (m + 2) → ℂ × ℂ)
(j : Fin (m + 2)) :
eval₂ (id ℂ)
(fun i : Fin 2 => if i = 0 then (dirs j).1 else (dirs j).2)
(supportAnnihilator dirs) = 0 := by
rw [supportAnnihilator, eval₂_prod]
rw [Finset.prod_eq_zero_iff]
refine ⟨j, Finset.mem_univ _, ?_⟩
simp [MvPolynomial.eval₂_sub, mul_comm]
Helpers.ApolarKernelAux 3 declarations
theorem supportAnnihilator_isHomogeneous
The support annihilator is a binary form of degree m + 2.
Formal statement
hypotheses
m :
ℕ
dirs :
Fin (m + 2) → ℂ × ℂ
conclusion
(supportAnnihilator dirs).IsHomogeneous (m + 2)
Proof (Lean source)
lemma supportAnnihilator_isHomogeneous {m : ℕ} (dirs : Fin (m + 2) → ℂ × ℂ) :
(supportAnnihilator dirs).IsHomogeneous (m + 2) := by
rw [supportAnnihilator]
have h := MvPolynomial.IsHomogeneous.prod univ
(fun j => C (dirs j).2 * X (0 : Fin 2) -
C (dirs j).1 * X (1 : Fin 2)) (fun _ => 1) ?_
· simpa using h
· intro i hi
exact (MvPolynomial.isHomogeneous_C_mul_X (dirs i).2 (0 : Fin 2)).sub
(MvPolynomial.isHomogeneous_C_mul_X (dirs i).1 (1 : Fin 2))
theorem reverse_supportAnnihilator_in_contraction_kernel
The reverse support-annihilator line lies in the common contraction kernel.
Formal statement
hypotheses
m :
ℕ
η :
ParamSpace ℂ m
q :
MvPolynomial (Fin 2) ℂ
hq :
q.IsHomogeneous (m + 2)
hqD :
∃ c : ℂ, q = c • supportAnnihilator (reverseLoading m η.1 η.2.1)
conclusion
∀ k
if
k ≤ m
then
Proof (Lean source)
lemma reverse_supportAnnihilator_in_contraction_kernel (m : ℕ) (η : ParamSpace ℂ m)
(q : MvPolynomial (Fin 2) ℂ) (hq : q.IsHomogeneous (m + 2))
(hqD : ∃ c : ℂ, q = c • supportAnnihilator (reverseLoading m η.1 η.2.1)) :
∀ k, k ≤ m → diffApply q
(dividedPowerBlock (reverseCumulantMap m (2 * m + 2) η) (m + 2 + k)) = 0 := by
rintro k hk
apply reverse_contractions_vanish_of_evalAtDir_zero m η q hq _ k hk
intro j
rcases hqD with ⟨c, rfl⟩
simp only [MvPolynomial.smul_eq_C_mul]
have hQ : evalAtDir (supportAnnihilator (reverseLoading m η.1 η.2.1))
(reverseLoading m η.1 η.2.1 j) = 0 :=
evalAtDir_supportAnnihilator_eq_zero _ j
simp only [evalAtDir] at hQ ⊢
rw [MvPolynomial.eval_mul, hQ, mul_zero]
theorem qDefault_rtsF_roots
The roots of the default forward finite-slope polynomial are its slopes.
Formal statement
hypotheses
m :
ℕ
θ :
ParamSpace ℂ m
Proof (Lean source)
lemma qDefault_rtsF_roots {m : ℕ} (θ : ParamSpace ℂ m) :
(qDefault (rtsF θ)).roots = θ.1 ::ₘ (Finset.univ.val.map (fun i => θ.2.1 i)) := by
rw [qDefault_roots, rtsF]
Helpers.ApolarKernelDiff 5 declarations Linear forms attached to loading directions
Linear forms attached to loading directions
def linForm
The binary linear form associated with a loading direction.
def evalAtDir
Evaluation of a differential symbol at a loading direction.
Definition (Lean source)
noncomputable def evalAtDir (q : MvPolynomial (Fin 2) ℂ) (u : ℂ × ℂ) : ℂ :=
eval (fun i => if i = 0 then u.1 else u.2) q
theorem dividedPowerBlock_forward_eq_sum_linForm_pow
A retained forward divided-power cumulant block is the corresponding sum of loading-direction powers.
Formal statement
hypotheses
conclusion
dividedPowerBlock (forwardCumulantMap m L θ) r
Proof (Lean source)
lemma dividedPowerBlock_forward_eq_sum_linForm_pow (m L r : ℕ) (θ : ParamSpace ℂ m)
(hr : 2 ≤ r) (hrL : r ≤ L) :
dividedPowerBlock (forwardCumulantMap m L θ) r =
∑ j : Fin (m + 2), C (θ.2.2 j r) *
linForm (forwardLoading m θ.1 θ.2.1 j) ^ r := by
rw [dividedPowerBlock]
simp only [forwardCumulantMap, hr, hrL]
calc
_ = ∑ a ∈ range (r + 1), ∑ j : Fin (m + 2),
C (θ.2.2 j r) *
(C (r.choose a : ℂ) *
(C (forwardLoading m θ.1 θ.2.1 j).1 * X 0) ^ (r - a) *
(C (forwardLoading m θ.1 θ.2.1 j).2 * X 1) ^ a) := by
apply Finset.sum_congr rfl
intro a ha
have har : a ≤ r := Nat.lt_succ_iff.mp (Finset.mem_range.mp ha)
rw [if_pos ⟨by simp, by simp, har⟩]
rw [MvPolynomial.C_mul, map_sum, Finset.mul_sum, Finset.sum_mul, Finset.sum_mul]
apply Finset.sum_congr rfl
intro j hj
simp only [MvPolynomial.C_mul]
rw [map_pow, map_pow]
ring
_ = ∑ j : Fin (m + 2), C (θ.2.2 j r) *
linForm (forwardLoading m θ.1 θ.2.1 j) ^ r := by
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro j hj
rw [linForm_pow]
simp_rw [Finset.mul_sum]
theorem dividedPowerBlock_reverse_eq_sum_linForm_pow
The corresponding retained reverse divided-power cumulant block.
Formal statement
hypotheses
conclusion
dividedPowerBlock (reverseCumulantMap m L η) r
Proof (Lean source)
lemma dividedPowerBlock_reverse_eq_sum_linForm_pow (m L r : ℕ) (η : ParamSpace ℂ m)
(hr : 2 ≤ r) (hrL : r ≤ L) :
dividedPowerBlock (reverseCumulantMap m L η) r =
∑ j : Fin (m + 2), C (η.2.2 j r) *
linForm (reverseLoading m η.1 η.2.1 j) ^ r := by
rw [dividedPowerBlock]
simp only [reverseCumulantMap, hr, hrL]
calc
_ = ∑ a ∈ range (r + 1), ∑ j : Fin (m + 2),
C (η.2.2 j r) *
(C (r.choose a : ℂ) *
(C (reverseLoading m η.1 η.2.1 j).1 * X 0) ^ (r - a) *
(C (reverseLoading m η.1 η.2.1 j).2 * X 1) ^ a) := by
apply Finset.sum_congr rfl
intro a ha
have har : a ≤ r := Nat.lt_succ_iff.mp (Finset.mem_range.mp ha)
rw [if_pos ⟨by simp, by simp, har⟩]
rw [MvPolynomial.C_mul, map_sum, Finset.mul_sum, Finset.sum_mul, Finset.sum_mul]
apply Finset.sum_congr rfl
intro j hj
simp only [MvPolynomial.C_mul]
rw [map_pow, map_pow]
ring
_ = ∑ j : Fin (m + 2), C (η.2.2 j r) *
linForm (reverseLoading m η.1 η.2.1 j) ^ r := by
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro j hj
rw [linForm_pow]
simp_rw [Finset.mul_sum]
theorem diffApply_linForm_pow
Applying a homogeneous differential symbol to a loading-direction power.
Formal statement
hypotheses
Proof (Lean source)
lemma diffApply_linForm_pow (q : MvPolynomial (Fin 2) ℂ) {n : ℕ}
(hq : q.IsHomogeneous n) (u : ℂ × ℂ) (k : ℕ) :
diffApply q (linForm u ^ (n + k)) =
C (descFactorial (n + k) n : ℂ) *
C (evalAtDir q u) * linForm u ^ k := by
classical
have hdegree : ∀ d ∈ q.support, d 0 + d 1 = n := by
intro d hd
have hd' : coeff d q ≠ 0 := by
exact MvPolynomial.mem_support_iff.mp hd
have h := hq hd'
simpa [Finsupp.weight_apply, Finsupp.sum_fintype, Fin.sum_univ_two] using h
rw [diffApply]
calc
∑ d ∈ q.support, coeff d q •
((fun g => pderiv (0 : Fin 2) g)^[d 0]
((fun g => pderiv (1 : Fin 2) g)^[d 1] (linForm u ^ (n + k)))) =
sum q.support (fun d =>
C (descFactorial (n + k) n : ℂ) *
C (coeff d q * u.1 ^ (d 0) * u.2 ^ (d 1)) *
linForm u ^ k) := by
apply Finset.sum_congr rfl
intro d hd
have hddeg := hdegree d hd
have hdle : d 0 + d 1 ≤ n + k := by omega
rw [pderiv_mixed_linForm_pow u (n + k) (d 0) (d 1) hdle]
rw [show n + k - (d 0 + d 1) = k by omega, hddeg]
rw [MvPolynomial.smul_eq_C_mul]
simp only [← map_pow, ← map_mul]
calc
C (coeff d q) *
(C (↑(descFactorial (n + k) n) * u.1 ^ d 0 * u.2 ^ d 1) *
linForm u ^ k) =
(C (coeff d q) *
C (↑(descFactorial (n + k) n) * u.1 ^ d 0 * u.2 ^ d 1)) *
linForm u ^ k := by ring
_ = C (coeff d q *
(↑(descFactorial (n + k) n) * u.1 ^ d 0 * u.2 ^ d 1)) * linForm u ^ k := by
rw [← map_mul C]
_ = _ := by
congr 1
ring
_ = C (descFactorial (n + k) n : ℂ) *
C (∑ d ∈ q.support,
coeff d q * u.1 ^ d 0 * u.2 ^ d 1) * linForm u ^ k := by
rw [map_sum, Finset.mul_sum, Finset.sum_mul]
_ = _ := by rw [← evalAtDir_eq_sum]
Helpers.ApolarKernelIdentity 9 declarations
theorem evalAtDir_supportAnnihilator_eq_zero
Evaluation at a direction is the eval₂ used by the support-annihilator lemma, so the latter can be used directly in apolar calculations.
Formal statement
hypotheses
conclusion
evalAtDir (supportAnnihilator dirs) (dirs j) = 0
Proof (Lean source)
lemma evalAtDir_supportAnnihilator_eq_zero {m : ℕ}
(dirs : Fin (m + 2) → ℂ × ℂ) (j : Fin (m + 2)) :
evalAtDir (supportAnnihilator dirs) (dirs j) = 0 := by
exact supportAnnihilator_eval_zero dirs j
theorem diffApply_sum
Proves the stated mathematical property of diff Apply sum.
Formal statement
hypotheses
Proof (Lean source)
lemma diffApply_sum (q : MvPolynomial (Fin 2) ℂ) {ι : Type*}
(s : Finset ι) (f : ι → MvPolynomial (Fin 2) ℂ) :
diffApply q (∑ i ∈ s, f i) = ∑ i ∈ s, diffApply q (f i) := by
classical
unfold diffApply
simp_rw [pderiv_iterate_sum]
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro d hd
rw [Finset.smul_sum]
theorem diffApply_C_mul
Proves the stated mathematical property of diff Apply C mul.
Formal statement
Proof (Lean source)
lemma diffApply_C_mul (q f : MvPolynomial (Fin 2) ℂ) (a : ℂ) :
diffApply q (C a * f) = C a * diffApply q f := by
classical
unfold diffApply
simp_rw [pderiv_iterate_C_mul]
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro d hd
simp only [MvPolynomial.smul_eq_C_mul]
ring
theorem forward_contractions_vanish_of_evalAtDir_zero
The easy half of the apolar kernel calculation: a homogeneous form that vanishes on every loading direction annihilates every retained contraction.
Formal statement
hypotheses
m :
ℕ
θ :
ParamSpace ℂ m
q :
MvPolynomial (Fin 2) ℂ
hq :
q.IsHomogeneous (m + 2)
hzero :
∀ j, evalAtDir q (forwardLoading m θ.1 θ.2.1 j) = 0
k :
ℕ
hk :
k ≤ m
conclusion
Proof (Lean source)
lemma forward_contractions_vanish_of_evalAtDir_zero (m : ℕ)
(θ : ParamSpace ℂ m) (q : MvPolynomial (Fin 2) ℂ)
(hq : q.IsHomogeneous (m + 2))
(hzero : ∀ j, evalAtDir q (forwardLoading m θ.1 θ.2.1 j) = 0)
(k : ℕ) (hk : k ≤ m) :
diffApply q
(dividedPowerBlock (forwardCumulantMap m (2 * m + 2) θ) (m + 2 + k)) = 0 := by
rw [dividedPowerBlock_forward_eq_sum_linForm_pow m (2 * m + 2) (m + 2 + k) θ]
· rw [diffApply_sum]
apply Finset.sum_eq_zero
intro j hj
rw [diffApply_C_mul, diffApply_linForm_pow q hq]
rw [hzero j]
simp
· omega
· omega
theorem forward_supportAnnihilator_in_contraction_kernel
The support-annihilator line is contained in the common contraction kernel. This is the backwards implication of the desired ker = ⟨Q_D⟩.
Formal statement
hypotheses
m :
ℕ
θ :
ParamSpace ℂ m
q :
MvPolynomial (Fin 2) ℂ
hq :
q.IsHomogeneous (m + 2)
hqD :
∃ c : ℂ, q = c • supportAnnihilator (forwardLoading m θ.1 θ.2.1)
conclusion
∀ k
if
k ≤ m
then
Proof (Lean source)
lemma forward_supportAnnihilator_in_contraction_kernel (m : ℕ)
(θ : ParamSpace ℂ m) (q : MvPolynomial (Fin 2) ℂ)
(hq : q.IsHomogeneous (m + 2))
(hqD : ∃ c : ℂ, q = c • supportAnnihilator (forwardLoading m θ.1 θ.2.1)) :
∀ k, k ≤ m → diffApply q
(dividedPowerBlock (forwardCumulantMap m (2 * m + 2) θ) (m + 2 + k)) = 0 := by
rintro k hk
apply forward_contractions_vanish_of_evalAtDir_zero m θ q hq _ k hk
intro j
rcases hqD with ⟨c, rfl⟩
simp only [MvPolynomial.smul_eq_C_mul]
have hQ : evalAtDir (supportAnnihilator (forwardLoading m θ.1 θ.2.1))
(forwardLoading m θ.1 θ.2.1 j) = 0 :=
evalAtDir_supportAnnihilator_eq_zero _ j
simp only [evalAtDir] at hQ ⊢
rw [MvPolynomial.eval_mul, hQ, mul_zero]
def forwardWeightedContraction
The genuine (un-charted) weighted block-contraction map. Its injectivity is exactly the rank-open condition needed in the forward implication.
Definition (Lean source)
noncomputable def forwardWeightedContraction (m : ℕ) (θ : ParamSpace ℂ m)
(e : Fin (m + 2) → ℂ) : Fin (m + 1) → MvPolynomial (Fin 2) ℂ :=
fun k => ∑ j : Fin (m + 2),
C (θ.2.2 j (m + 2 + k.1)) * C (e j) *
linForm (forwardLoading m θ.1 θ.2.1 j) ^ k.1
theorem evalAtDir_zero_of_forward_contractions
Under injectivity of the actual weighted contraction map, the common contraction equations force every directional evaluation to vanish.
Formal statement
hypotheses
m :
ℕ
θ :
ParamSpace ℂ m
q :
MvPolynomial (Fin 2) ℂ
hq :
q.IsHomogeneous (m + 2)
hrank :
hcon :
∀ k
if
k ≤ m
then
conclusion
∀ j, evalAtDir q (forwardLoading m θ.1 θ.2.1 j) = 0
Proof (Lean source)
lemma evalAtDir_zero_of_forward_contractions (m : ℕ) (θ : ParamSpace ℂ m)
(q : MvPolynomial (Fin 2) ℂ) (hq : q.IsHomogeneous (m + 2))
(hrank : Injective (forwardWeightedContraction m θ))
(hcon : ∀ k, k ≤ m → diffApply q
(dividedPowerBlock (forwardCumulantMap m (2 * m + 2) θ) (m + 2 + k)) = 0) :
∀ j, evalAtDir q (forwardLoading m θ.1 θ.2.1 j) = 0 := by
let e : Fin (m + 2) → ℂ := fun j => evalAtDir q (forwardLoading m θ.1 θ.2.1 j)
have hB : forwardWeightedContraction m θ e = forwardWeightedContraction m θ 0 := by
funext k
have hk : k.1 ≤ m := Nat.lt_succ_iff.mp k.2
have h := hcon k.1 hk
rw [dividedPowerBlock_forward_eq_sum_linForm_pow m (2 * m + 2) (m + 2 + k.1) θ
(by omega) (by omega), diffApply_sum] at h
simp_rw [diffApply_C_mul, diffApply_linForm_pow q hq] at h
-- The nonzero descending-factorial scalar is common to all summands.
have hfac : (descFactorial (m + 2 + k.1) (m + 2) : ℂ) ≠ 0 := by
exact_mod_cast Nat.ne_of_gt
(Nat.descFactorial_pos.mpr (by omega : m + 2 ≤ m + 2 + k.1))
rw [forwardWeightedContraction]
change (∑ j : Fin (m + 2),
C (θ.2.2 j (m + 2 + k.1)) * C (e j) *
linForm (forwardLoading m θ.1 θ.2.1 j) ^ k.1) =
∑ j : Fin (m + 2),
C (θ.2.2 j (m + 2 + k.1)) * C ((0 : Fin (m + 2) → ℂ) j) *
linForm (forwardLoading m θ.1 θ.2.1 j) ^ k.1
simp only [Pi.zero_apply, map_zero, mul_zero, zero_mul, Finset.sum_const_zero]
apply (mul_eq_zero.mp ?_).resolve_left (MvPolynomial.C_ne_zero.mpr hfac)
calc
C (descFactorial (m + 2 + k.1) (m + 2) : ℂ) *
∑ j : Fin (m + 2),
C (θ.2.2 j (m + 2 + k.1)) * C (e j) *
linForm (forwardLoading m θ.1 θ.2.1 j) ^ k.1 =
∑ j : Fin (m + 2),
C (descFactorial (m + 2 + k.1) (m + 2) : ℂ) *
(C (θ.2.2 j (m + 2 + k.1)) * C (e j) *
linForm (forwardLoading m θ.1 θ.2.1 j) ^ k.1) := by
rw [Finset.mul_sum]
_ = 0 := by
convert h using 1
apply Finset.sum_congr rfl
intro j hj
dsimp [e]
ring
have he : e = 0 := hrank hB
intro j
exact congrFun he j
theorem forward_points_imply_supportAnnihilator_multiple
The binary interpolation step: a degree-m+2 homogeneous binary form vanishing on the m+1 finite forward directions and on the direction at infinity is a multiple of their support annihilator.
Formal statement
hypotheses
m :
ℕ
θ :
ParamSpace ℂ m
q :
MvPolynomial (Fin 2) ℂ
hq :
q.IsHomogeneous (m + 2)
hslopes :
hnonzero :
hzero :
∀ j, evalAtDir q (forwardLoading m θ.1 θ.2.1 j) = 0
conclusion
∃ c : ℂ, q = c • supportAnnihilator (forwardLoading m θ.1 θ.2.1)
Proof (Lean source)
lemma forward_points_imply_supportAnnihilator_multiple (m : ℕ)
(θ : ParamSpace ℂ m) (q : MvPolynomial (Fin 2) ℂ)
(hq : q.IsHomogeneous (m + 2))
(hslopes : Injective
(fun j : Fin (m + 1) =>
(forwardLoading m θ.1 θ.2.1 (castSucc j)).2))
(hnonzero : ∀ j : Fin (m + 1),
(forwardLoading m θ.1 θ.2.1 (castSucc j)).2 ≠ 0)
(hzero : ∀ j, evalAtDir q (forwardLoading m θ.1 θ.2.1 j) = 0) :
∃ c : ℂ, q = c • supportAnnihilator (forwardLoading m θ.1 θ.2.1) := by
let dirs : Fin (m + 2) → ℂ × ℂ := forwardLoading m θ.1 θ.2.1
let Q := supportAnnihilator dirs
have hb : ∀ j, (dirs j).2 ≠ 0 := by
intro j
by_cases hj : j.val = m + 1
· have hjlast : j = (⟨m + 1, by omega⟩ : Fin (m + 2)) := Fin.ext hj
simp [dirs, hjlast, forwardLoading]
· let k : Fin (m + 1) := ⟨j.val, by omega⟩
have hjcast : castSucc k = j := Fin.ext rfl
rw [← hjcast]
exact hnonzero k
have hQhom : Q.IsHomogeneous (m + 2) := supportAnnihilator_isHomogeneous m dirs
have hQtop : (dehomInf Q).coeff (m + 2) ≠ 0 :=
dehomInf_support_coeff_top_ne m dirs hb
let c : ℂ := (dehomInf q).coeff (m + 2) / (dehomInf Q).coeff (m + 2)
let r : MvPolynomial (Fin 2) ℂ := q - C c * Q
have hrhom : r.IsHomogeneous (m + 2) := by
apply (MvPolynomial.homogeneousSubmodule (Fin 2) ℂ (m + 2)).sub_mem hq
exact hQhom.C_mul c
have hrtop : (dehomInf r).coeff (m + 2) = 0 := by
dsimp [r, c]
rw [map_sub, map_mul]
rw [show dehomInf (C
((dehomInf q).coeff (m + 2) / (dehomInf Q).coeff (m + 2))) =
Polynomial.C ((dehomInf q).coeff (m + 2) /
(dehomInf Q).coeff (m + 2)) by simp [dehomInf]]
change (dehomInf q - Polynomial.C
((dehomInf q).coeff (m + 2) / (dehomInf Q).coeff (m + 2)) *
dehomInf Q).coeff (m + 2) = 0
rw [Polynomial.coeff_sub, Polynomial.coeff_C_mul]
rw [div_mul_cancel₀ _ hQtop, sub_self]
have hratio : Injective (fun j : Fin (m + 2) =>
(dirs j).1 / (dirs j).2) := by
exact forward_ratio_injective m θ hslopes hb
have hrroot : ∀ j : Fin (m + 2),
Polynomial.IsRoot (dehomInf r) ((dirs j).1 / (dirs j).2) := by
intro j
have hQzero : evalAtDir Q (dirs j) = 0 := by
exact evalAtDir_supportAnnihilator_eq_zero dirs j
have hqzero : evalAtDir q (dirs j) = 0 := by
simpa [dirs] using hzero j
have hrorig : evalAtDir r (dirs j) = 0 := by
change evalAtDir (q - C c * Q) (dirs j) = 0
simp only [evalAtDir, MvPolynomial.eval_sub, MvPolynomial.eval_mul,
MvPolynomial.eval_C] at hqzero hQzero ⊢
rw [hqzero, hQzero]
ring
have hs := homogeneous_eval_scale hrhom (dirs j).2
(fun i : Fin 2 => if i = 0 then (dirs j).1 / (dirs j).2 else 1)
have hleft :
eval
(fun i : Fin 2 => (dirs j).2 *
(if i = 0 then (dirs j).1 / (dirs j).2 else 1)) r =
evalAtDir r (dirs j) := by
unfold evalAtDir
apply congrArg (fun f : Fin 2 → ℂ => eval f r)
funext i
fin_cases i
· change (dirs j).2 * ((dirs j).1 / (dirs j).2) = (dirs j).1
rw [mul_comm, div_mul_cancel₀ _ (hb j)]
· change (dirs j).2 * 1 = (dirs j).2
simp
rw [hleft, hrorig] at hs
change (dehomInf r).eval ((dirs j).1 / (dirs j).2) = 0
rw [dehomInf_eval]
apply (mul_eq_zero.mp hs.symm).resolve_left
exact pow_ne_zero _ (hb j)
have hrdehom : dehomInf r = 0 := by
by_contra hne
have hdeg_le : (dehomInf r).natDegree ≤ m + 2 :=
dehomInf_natDegree_le_of_homogeneous hrhom
have hdeg_ne : (dehomInf r).natDegree ≠ m + 2 := by
intro heq
have hlc : (dehomInf r).leadingCoeff ≠ 0 :=
Polynomial.leadingCoeff_ne_zero.mpr hne
apply hlc
rw [← Polynomial.coeff_natDegree, heq, hrtop]
have hdeg_lt : (dehomInf r).natDegree < m + 2 := by omega
have hsub : image (fun j : Fin (m + 2) =>
(dirs j).1 / (dirs j).2) univ ⊆ (dehomInf r).roots.toFinset := by
intro z hz
rw [mem_image] at hz
obtain ⟨j, hj, rfl⟩ := hz
simp only [Multiset.mem_toFinset, Polynomial.mem_roots hne]
exact hrroot j
have hmany : m + 2 ≤ (dehomInf r).natDegree := by
calc
m + 2 = (image (fun j : Fin (m + 2) =>
(dirs j).1 / (dirs j).2) univ).card := by
rw [Finset.card_image_iff.mpr hratio.injOn]
simp
_ ≤ (dehomInf r).roots.toFinset.card := Finset.card_le_card hsub
_ ≤ (dehomInf r).roots.card := Multiset.toFinset_card_le _
_ ≤ (dehomInf r).natDegree := Polynomial.card_roots' _
omega
have hrzero : r = 0 := dehomInf_injective_on_homogeneous hrhom hrdehom
refine ⟨c, ?_⟩
have heq : q = C c * Q := sub_eq_zero.mp hrzero
simpa [Q, dirs, MvPolynomial.smul_eq_C_mul] using heq
theorem forward_apolar_kernel_identity
Forward apolar kernel identity. This is the actual common-kernel statement used by the flagship: among homogeneous degree-m+2 binary forms, the simultaneous contractions with orders m+2,…,2m+2 have exactly the support-annihilator line as their kernel.
Formal statement
hypotheses
conclusion
∀ q : MvPolynomial (Fin 2) ℂ
if
q.IsHomogeneous (m + 2)
then
((∀ k, k ≤ m → diffApply q (dividedPowerBlock (forwardCumulantMap m (2 * m + 2) θ) (m + 2 + k)) = 0) ↔ ∃ c : ℂ, q = c • supportAnnihilator (forwardLoading m θ.1 θ.2.1))
Proof (Lean source)
theorem forward_apolar_kernel_identity (m : ℕ) (θ : ParamSpace ℂ m)
(hslopes : Injective
(fun j : Fin (m + 1) =>
(forwardLoading m θ.1 θ.2.1 (castSucc j)).2))
(hnonzero : ∀ j : Fin (m + 1),
(forwardLoading m θ.1 θ.2.1 (castSucc j)).2 ≠ 0)
(hrank : Injective (forwardWeightedContraction m θ)) :
∀ q : MvPolynomial (Fin 2) ℂ, q.IsHomogeneous (m + 2) →
((∀ k, k ≤ m → diffApply q
(dividedPowerBlock (forwardCumulantMap m (2 * m + 2) θ) (m + 2 + k)) = 0)
↔ ∃ c : ℂ, q = c • supportAnnihilator (forwardLoading m θ.1 θ.2.1)) := by
intro q hq
constructor
· intro hcon
apply forward_points_imply_supportAnnihilator_multiple m θ q hq hslopes hnonzero
exact evalAtDir_zero_of_forward_contractions m θ q hq hrank hcon
· exact forward_supportAnnihilator_in_contraction_kernel m θ q hq
Helpers.ApolarQD 8 declarations A default polynomial for a prescribed finite multiset of roots
A default polynomial for a prescribed finite multiset of roots
def qDefault
The monic polynomial with the given multiset of complex roots.
Definition (Lean source)
noncomputable def qDefault (rts : Multiset ℂ) : Polynomial ℂ :=
(rts.map (fun r => Polynomial.X - Polynomial.C r)).prod
theorem qDefault_ne_zero
The default root polynomial is nonzero because every linear factor is nonzero.
Proof (Lean source)
lemma qDefault_ne_zero (rts : Multiset ℂ) : qDefault rts ≠ 0 := by
unfold qDefault
apply Multiset.prod_ne_zero
simp [Polynomial.X_sub_C_ne_zero]
theorem qDefault_roots
The roots of qDefault have exactly the prescribed multiplicities.
Proof (Lean source)
lemma qDefault_roots (rts : Multiset ℂ) : (qDefault rts).roots = rts := by
exact Polynomial.roots_multiset_prod_X_sub_C rts
theorem qDefault_squarefree
Distinct prescribed roots make the default root polynomial squarefree.
Formal statement
Proof (Lean source)
lemma qDefault_squarefree (rts : Multiset ℂ) (h : rts.Nodup) : Squarefree (qDefault rts) := by
apply Polynomial.Separable.squarefree
apply (Polynomial.nodup_roots_iff_of_splits (qDefault_ne_zero rts)
(qDefault_splits rts)).mp
simpa only [qDefault_roots] using h
theorem qDefault_eval_zero_ne
If zero is absent from the prescribed roots, the default root polynomial is nonzero at zero.
Formal statement
Proof (Lean source)
lemma qDefault_eval_zero_ne (rts : Multiset ℂ)
(h0 : (0 : ℂ) ∉ rts) :
(qDefault rts).eval 0 ≠ 0 := by
unfold qDefault
rw [Polynomial.eval_multiset_prod]
apply Multiset.prod_ne_zero
intro hzero
rw [Multiset.mem_map] at hzero
obtain ⟨p, hp, hpzero⟩ := hzero
rw [Multiset.mem_map] at hp
obtain ⟨r, hr, rfl⟩ := hp
simp only [Polynomial.eval_sub, Polynomial.eval_X, Polynomial.eval_C] at hpzero
have hr0 : r = 0 := by simpa using hpzero
apply h0
simpa [hr0] using hr
def rtsF
The finite slopes in the forward parametrization: the direct slope followed by the latent slopes.
Definition (Lean source)
def rtsF {m : ℕ} (θ : ParamSpace ℂ m) : Multiset ℂ :=
θ.1 ::ₘ (Finset.univ.val.map fun i => θ.2.1 i)
theorem rtsF_nodup
Genericity makes the direct and latent finite slopes pairwise distinct.
Formal statement
hypotheses
conclusion
(rtsF θ).Nodup
Proof (Lean source)
lemma rtsF_nodup {m L : ℕ} (θ : ParamSpace ℂ m)
(hθ : θ ∈ genericParameterLocus m L) (_hρ : ∀ i, θ.2.1 i ≠ 0) :
(rtsF θ).Nodup := by
rw [rtsF, Multiset.nodup_cons]
refine ⟨?_, ?_⟩
· intro hmem
rw [Multiset.mem_map] at hmem
obtain ⟨i, -, hi⟩ := hmem
exact generic_gamma_ne_rho hθ i hi.symm
· exact Fintype.nodup_map_univ_iff_injective.mpr (generic_rho_injective hθ)
theorem zero_notMem_rtsF
Under genericity and nonzero latent slopes, zero is absent from the forward slope multiset.
Formal statement
hypotheses
conclusion
(0 : ℂ) ∉ rtsF θ
Proof (Lean source)
lemma zero_notMem_rtsF {m L : ℕ} (θ : ParamSpace ℂ m)
(hθ : θ ∈ genericParameterLocus m L) (hρ : ∀ i, θ.2.1 i ≠ 0) :
(0 : ℂ) ∉ rtsF θ := by
rw [rtsF, Multiset.mem_cons]
rintro (hzero | hzero)
· exact generic_gamma_ne_zero hθ hzero.symm
· rw [Multiset.mem_map] at hzero
obtain ⟨i, -, hi⟩ := hzero
exact hρ i hi
Helpers.ApolarRankBridge 10 declarations
def binaryDehom
Defines the mathematical object called the binary Dehom.
Definition (Lean source)
noncomputable def binaryDehom :
MvPolynomial (Fin 2) ℂ →+* Polynomial ℂ :=
MvPolynomial.eval₂Hom Polynomial.C (fun i => if i = 0 then 1 else Polynomial.X)
theorem coeff_binaryDehom_linForm_pow
Proves the stated mathematical property of coeff binary Dehom lin Form pow.
Formal statement
hypotheses
u :
ℂ × ℂ
m r :
ℕ
conclusion
(binaryDehom (linForm u ^ m)).coeff r = (m.choose r : ℂ) * u.1 ^ (m - r) * u.2 ^ r
Proof (Lean source)
lemma coeff_binaryDehom_linForm_pow (u : ℂ × ℂ) (m r : ℕ) :
(binaryDehom (linForm u ^ m)).coeff r =
(m.choose r : ℂ) * u.1 ^ (m - r) * u.2 ^ r := by
rw [map_pow]
have hlin : binaryDehom (linForm u) =
Polynomial.C u.1 + Polynomial.C u.2 * Polynomial.X := by
simp [binaryDehom, linForm]
rw [hlin]
rw [add_comm]
rw [Commute.add_pow (Commute.all _ _)]
simp only [Polynomial.finset_sum_coeff]
have hterm (x : ℕ) :
(Polynomial.C u.2 * Polynomial.X) ^ x * Polynomial.C u.1 ^ (m - x) =
Polynomial.C (u.1 ^ (m - x) * u.2 ^ x) * Polynomial.X ^ x := by
rw [mul_pow, ← map_pow, ← map_pow, map_mul]
ring
simp only [hterm, ← Polynomial.C_eq_natCast, Polynomial.coeff_mul_C,
Polynomial.coeff_C_mul_X_pow]
by_cases hr : r < m + 1
· rw [Finset.sum_eq_single r]
· simp
ring
· intro b hb hbr
simp [Ne.symm hbr]
· intro hnot
exact elim (hnot (Finset.mem_range.mpr hr))
· have hmr : m < r := by omega
have hchoose : m.choose r = 0 := Nat.choose_eq_zero_of_lt hmr
rw [show (m.choose r : ℂ) = 0 by simp [hchoose]]
simp only [zero_mul]
apply Finset.sum_eq_zero
intro b hb
have hbr : r ≠ b := by
have := Finset.mem_range.mp hb
omega
simp [hbr]
theorem coeff_binaryDehom_linForm_pow'
Proves the stated mathematical property of coeff binary Dehom lin Form pow'.
Formal statement
hypotheses
u :
ℂ × ℂ
m r :
ℕ
conclusion
(binaryDehom (linForm u) ^ m).coeff r = (m.choose r : ℂ) * u.1 ^ (m - r) * u.2 ^ r
Proof (Lean source)
lemma coeff_binaryDehom_linForm_pow' (u : ℂ × ℂ) (m r : ℕ) :
(binaryDehom (linForm u) ^ m).coeff r =
(m.choose r : ℂ) * u.1 ^ (m - r) * u.2 ^ r := by
rw [← map_pow]
exact coeff_binaryDehom_linForm_pow u m r
def forwardSelectedContractionMatrix
The selected weighted-contraction coefficient matrix, exposed independently of parameter polynomials so observable contraction minors can factor through it.
Definition (Lean source)
def forwardSelectedContractionMatrix (m : ℕ) (theta : ParamSpace ℂ m) :
Matrix (Fin (m + 2)) (Fin (m + 2)) ℂ :=
fun i j => Fin.cases (theta.2.2 j (m + 2))
(fun r => theta.2.2 j (2 * m + 2) * (m.choose r.1 : ℂ) *
(forwardLoading m theta.1 theta.2.1 j).1 ^ (m - r.1) *
(forwardLoading m theta.1 theta.2.1 j).2 ^ r.1) i
def forwardContractionMinorWitnessParameter
Explicit retained-band parameter at which the selected contraction matrix is nonsingular.
Definition (Lean source)
def forwardContractionMinorWitnessParameter (m : ℕ) : ParamSpace ℂ m :=
witnessParameter m
theorem forwardContractionMinorWitness_det_ne_zero
At the explicitly constructed witness parameter, and whenever there is at least one latent source slot, the selected forward weighted-contraction matrix has nonzero determinant. This exhibits a single point at which the contraction minor is nonsingular, which is what makes the corresponding minor polynomial not identically zero.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
Proof (Lean source)
lemma forwardContractionMinorWitness_det_ne_zero (m : ℕ) (hm : 1 ≤ m) :
(forwardSelectedContractionMatrix m
(forwardContractionMinorWitnessParameter m)).det ≠ 0 := by
have heq : forwardSelectedContractionMatrix m
(forwardContractionMinorWitnessParameter m) =
contractionMinor m (witnessParameter m) := by
ext i j
rw [contractionMinor_apply]
rfl
rw [heq]
exact witness_minor_det_ne_zero m hm
theorem forwardContractionMinorWitness_loading_castSucc
Proves the stated mathematical property of forward Contraction Minor Witness loading cast Succ.
Formal statement
hypotheses
m :
ℕ
j :
Fin (m + 1)
conclusion
forwardLoading m (forwardContractionMinorWitnessParameter m).1 (forwardContractionMinorWitnessParameter m).2.1 j.castSucc
= ((1 : ℂ), ((j.1 + 1 : ℕ) : ℂ))
Proof (Lean source)
lemma forwardContractionMinorWitness_loading_castSucc (m : ℕ)
(j : Fin (m + 1)) :
forwardLoading m (forwardContractionMinorWitnessParameter m).1
(forwardContractionMinorWitnessParameter m).2.1 j.castSucc =
((1 : ℂ), ((j.1 + 1 : ℕ) : ℂ)) := by
exact witness_loading_castSucc m j
theorem forwardContractionMinorWitness_slope_injective
Proves that the map or coordinate assignment called the forward Contraction Minor Witness slope is injective.
Proof (Lean source)
lemma forwardContractionMinorWitness_slope_injective (m : ℕ) :
Injective (fun j : Fin (m + 1) => ((j.1 + 1 : ℕ) : ℂ)) :=
witnessSlope_injective m
theorem forwardContractionMinorWitness_loading_last
Proves the stated mathematical property of forward Contraction Minor Witness loading last.
Formal statement
hypotheses
m :
ℕ
conclusion
forwardLoading m (forwardContractionMinorWitnessParameter m).1 (forwardContractionMinorWitnessParameter m).2.1 (last (m + 1))
= (0, 1)
Proof (Lean source)
lemma forwardContractionMinorWitness_loading_last (m : ℕ) :
forwardLoading m (forwardContractionMinorWitnessParameter m).1
(forwardContractionMinorWitnessParameter m).2.1 (last (m + 1)) =
(0, 1) := by
simp [forwardContractionMinorWitnessParameter, witnessParameter, forwardLoading]
theorem forward_contraction_injective_of_generic_and_minor
Injectivity of the genuine contraction holds on the principal open set cut out by the determinant of an explicit coefficient minor. The polynomial is nonzero at an explicit witness whose weights vanish outside the pinned degree band.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
∃ P : MvPolynomial (ParamCoord m) ℂ
if
P ≠ 0 ∧
(∃ θ₀ : ParamSpace ℂ m, (∀ (j : Fin (m + 2)) (r : ℕ), (r < 2 ∨ 2 * m + 2 < r) → θ₀.2.2 j r = 0) ∧ eval (paramEval θ₀) P ≠ 0) ∧
then
Injective (forwardWeightedContraction m theta)
Proof (Lean source)
theorem forward_contraction_injective_of_generic_and_minor (m : ℕ) (hm : 1 ≤ m) :
∃ P : MvPolynomial (ParamCoord m) ℂ, P ≠ 0 ∧
(∃ θ₀ : ParamSpace ℂ m,
(∀ (j : Fin (m + 2)) (r : ℕ), (r < 2 ∨ 2 * m + 2 < r) → θ₀.2.2 j r = 0) ∧
eval (paramEval θ₀) P ≠ 0) ∧
∀ theta : ParamSpace ℂ m, eval (paramEval theta) P ≠ 0 →
Injective (forwardWeightedContraction m theta) := by
refine ⟨(contractionMinorPolynomial m).det, ?_, ?_, ?_⟩
· intro hzero
apply witness_minor_det_ne_zero m hm
change det ((eval (paramEval (witnessParameter m))).mapMatrix
(contractionMinorPolynomial m)) = 0
rw [← RingHom.map_det, hzero, map_zero]
· refine ⟨witnessParameter m, ?_, ?_⟩
· intro j r hr
simp only [witnessParameter]
rcases hr with hr | hr
· rw [if_neg (by omega), if_neg (by omega)]
· rw [if_neg (by omega), if_neg (by omega)]
· intro hzero
apply witness_minor_det_ne_zero m hm
change det ((eval (paramEval (witnessParameter m))).mapMatrix
(contractionMinorPolynomial m)) = 0
rw [← RingHom.map_det]
exact hzero
· intro theta htheta
apply contraction_injective_of_minor_det_ne_zero m theta
change det ((eval (paramEval theta)).mapMatrix
(contractionMinorPolynomial m)) ≠ 0
rw [← RingHom.map_det]
exact htheta
Helpers.ArrowPolynomialGeometry 15 declarations For a degree-m+2 differential operator divisible by X 1, use the monomial basis X 0 ^ (m+1-b) * X 1 ^ (b+1), 0 ≤ b < m+2.
An observable common-axis contraction minor
For a degree-m+2 differential operator divisible by X 1, use the monomial
basis X 0 ^ (m+1-b) * X 1 ^ (b+1), 0 ≤ b < m+2. We retain the scalar
contraction at order m+2 and every coefficient of the degree-m contraction
at order 2m+2. Up to nonzero row factors, the resulting observable matrix is
t_(m+2,b+1) in its first row and
choose(m,a) * t_(2m+2,a+b+1) in row a+1.
Every reverse loading list contains (1,0). The direction-evaluation factor
of this matrix therefore has a zero row, so its determinant vanishes on the
whole reverse arrow variety. On the forward common-axis family the same zero
row is supplied by the loading (1,ρ₀)=(1,0).
def IsPolynomialCumMap
A cumulant-valued map whose scalar coordinates are polynomials in all structural parameter coordinates.
Definition (Lean source)
def IsPolynomialCumMap {m : ℕ} (Φ : ParamSpace ℂ m → CumVec ℂ) : Prop :=
∃ coord : ℕ × ℕ → MvPolynomial (ParamCoord m) ℂ,
∀ θ r a, eval (paramEval θ) (coord (r, a)) = Φ θ r a
theorem forwardCumulantMap_isPolynomial
Proves that the map called the forward Cumulant Map is Polynomial is polynomial.
Formal statement
Proof (Lean source)
lemma forwardCumulantMap_isPolynomial (m L : ℕ) :
IsPolynomialCumMap (forwardCumulantMap m L) := by
refine ⟨fun ra => forwardCoordPolynomial m L ra.1 ra.2, ?_⟩
intro θ r a
simp only [forwardCoordPolynomial, forwardCumulantMap]
split
· simp only [map_sum, map_mul, map_pow, weightPolynomial,
MvPolynomial.eval_X, paramEval]
apply Finset.sum_congr rfl
intro j _
rw [show eval (paramEval θ) (forwardLoadingPolynomial m j).1 =
(forwardLoading m θ.1 θ.2.1 j).1 by
simpa using congrArg fst (eval_forwardLoadingPolynomial θ j),
show eval (paramEval θ) (forwardLoadingPolynomial m j).2 =
(forwardLoading m θ.1 θ.2.1 j).2 by
simpa using congrArg snd (eval_forwardLoadingPolynomial θ j)]
· simp
theorem reverseCumulantMap_isPolynomial
Proves that the map called the reverse Cumulant Map is Polynomial is polynomial.
Formal statement
Proof (Lean source)
lemma reverseCumulantMap_isPolynomial (m L : ℕ) :
IsPolynomialCumMap (reverseCumulantMap m L) := by
refine ⟨fun ra => reverseCoordPolynomial m L ra.1 ra.2, ?_⟩
intro η r a
simp only [reverseCoordPolynomial, reverseCumulantMap]
split
· simp only [map_sum, map_mul, map_pow, weightPolynomial,
MvPolynomial.eval_X, paramEval]
apply Finset.sum_congr rfl
intro j _
rw [show eval (paramEval η) (reverseLoadingPolynomial m j).1 =
(reverseLoading m η.1 η.2.1 j).1 by
simpa using congrArg fst (eval_reverseLoadingPolynomial η j),
show eval (paramEval η) (reverseLoadingPolynomial m j).2 =
(reverseLoading m η.1 η.2.1 j).2 by
simpa using congrArg snd (eval_reverseLoadingPolynomial η j)]
· simp
theorem cumulantImageVariety_isIrreducible
The closure of the image of an affine polynomial map is irreducible.
Formal statement
Proof (Lean source)
lemma cumulantImageVariety_isIrreducible {m : ℕ} {Φ : ParamSpace ℂ m → CumVec ℂ}
(hΦ : IsPolynomialCumMap Φ) :
IsIrreducibleZariskiClosed (cumulantImageVariety Φ) := by
obtain ⟨coord, hcoord⟩ := hΦ
refine ⟨zariskiClosure_idem _, ?_, ?_⟩
· exact ⟨Φ default, subset_zariskiClosure _ ⟨default, rfl⟩⟩
· intro Z₁ Z₂ hZ₁ hZ₂ hunion
by_contra hne
push_neg at hne
obtain ⟨hneq₁, hneq₂⟩ := hne
have hrange₁ : ¬ range Φ ⊆ Z₁ := by
intro h
apply hneq₁
apply Set.Subset.antisymm
· have hc := zariskiClosure_mono h
rw [hZ₁] at hc
exact hc
· rw [hunion]
exact Set.subset_union_left
have hrange₂ : ¬ range Φ ⊆ Z₂ := by
intro h
apply hneq₂
apply Set.Subset.antisymm
· have hc := zariskiClosure_mono h
rw [hZ₂] at hc
exact hc
· rw [hunion]
exact Set.subset_union_right
obtain ⟨_, ⟨θ₁, rfl⟩, hθ₁⟩ := Set.not_subset.mp hrange₁
obtain ⟨_, ⟨θ₂, rfl⟩, hθ₂⟩ := Set.not_subset.mp hrange₂
have hp₁ : ∃ P : MvPolynomial (ℕ × ℕ) ℂ,
(∀ t ∈ Z₁, eval (fun ra => t ra.1 ra.2) P = 0) ∧
eval (fun ra => Φ θ₁ ra.1 ra.2) P ≠ 0 := by
have hnot : Φ θ₁ ∉ zariskiClosure Z₁ := by
rw [hZ₁]
exact hθ₁
simp only [zariskiClosure, Set.mem_setOf_eq] at hnot
push_neg at hnot
exact hnot
have hp₂ : ∃ P : MvPolynomial (ℕ × ℕ) ℂ,
(∀ t ∈ Z₂, eval (fun ra => t ra.1 ra.2) P = 0) ∧
eval (fun ra => Φ θ₂ ra.1 ra.2) P ≠ 0 := by
have hnot : Φ θ₂ ∉ zariskiClosure Z₂ := by
rw [hZ₂]
exact hθ₂
simp only [zariskiClosure, Set.mem_setOf_eq] at hnot
push_neg at hnot
exact hnot
obtain ⟨P₁, hP₁Z, hP₁ne⟩ := hp₁
obtain ⟨P₂, hP₂Z, hP₂ne⟩ := hp₂
have hprod : pullbackPolynomial coord P₁ * pullbackPolynomial coord P₂ = 0 := by
apply MvPolynomial.funext
intro x
obtain ⟨θ, rfl⟩ := paramEval_surjective m x
rw [map_zero, map_mul, eval_pullbackPolynomial hcoord,
eval_pullbackPolynomial hcoord]
have hx : Φ θ ∈ cumulantImageVariety Φ :=
subset_zariskiClosure _ ⟨θ, rfl⟩
rw [hunion] at hx
rcases hx with hx | hx
· rw [hP₁Z _ hx, zero_mul]
· rw [hP₂Z _ hx, mul_zero]
rcases mul_eq_zero.mp hprod with hzero | hzero
· exact hP₁ne (by
rw [← eval_pullbackPolynomial hcoord θ₁ P₁, hzero, map_zero])
· exact hP₂ne (by
rw [← eval_pullbackPolynomial hcoord θ₂ P₂, hzero, map_zero])
theorem forwardCumulantImageVariety_isIrreducible
Proves the stated mathematical property of forward Cumulant Image Variety is Irreducible.
Formal statement
hypotheses
m L :
ℕ
conclusion
Proof (Lean source)
theorem reverseCumulantImageVariety_isIrreducible
Proves the stated mathematical property of reverse Cumulant Image Variety is Irreducible.
Formal statement
hypotheses
m L :
ℕ
conclusion
Proof (Lean source)
def horizontalContractionMinorMatrixPolynomial
The explicit observable contraction matrix restricted to operators divisible by the horizontal-axis annihilator X 1.
Definition (Lean source)
def horizontalContractionMinorMatrixPolynomial (m : ℕ) :
Matrix (Fin (m + 2)) (Fin (m + 2))
(MvPolynomial (RetainedCumCoord (2 * m + 2)) ℂ) :=
fun i b => Fin.cases
(X (retainedCumCoordOf (r := m + 2) (a := b.1 + 1)
(by omega) (by omega) (by omega)))
(fun a => C (m.choose a.1 : ℂ) *
X (retainedCumCoordOf (r := 2 * m + 2)
(a := a.1 + b.1 + 1) (by omega) (by omega) (by omega))) i
def horizontalContractionMinorPolynomial
The observable contraction-minor polynomial detecting the presence of the horizontal direction in a length-m+2 power decomposition.
Definition (Lean source)
def horizontalContractionMinorPolynomial (m : ℕ) :
MvPolynomial (RetainedCumCoord (2 * m + 2)) ℂ :=
(horizontalContractionMinorMatrixPolynomial m).det
theorem eval_horizontalContractionMinorPolynomial
Evaluating the horizontal contraction-minor polynomial at the retained cumulants of a cumulant vector returns the determinant of the explicit numerical contraction matrix built from those same cumulants. The polynomial is therefore just a symbolic name for that determinant.
Formal statement
Proof (Lean source)
lemma eval_horizontalContractionMinorPolynomial (m : ℕ) (t : CumVec ℂ) :
eval (restrictCumBand (2 * m + 2) t)
(horizontalContractionMinorPolynomial m) =
(horizontalContractionMinorMatrix m t).det := by
rw [horizontalContractionMinorPolynomial, RingHom.map_det]
congr 1
ext i b
refine Fin.cases ?_ (fun a => ?_) i
· simp [horizontalContractionMinorMatrixPolynomial,
horizontalContractionMinorMatrix, restrictCumBand, retainedCumCoordOf]
· simp [horizontalContractionMinorMatrixPolynomial,
horizontalContractionMinorMatrix, restrictCumBand, retainedCumCoordOf]
theorem horizontalContractionMinorPolynomial_reverse_vanishes
Proves the stated mathematical property of horizontal Contraction Minor Polynomial reverse vanishes.
Formal statement
hypotheses
m :
ℕ
eta :
ParamSpace ℂ m
conclusion
eval (restrictCumBand (2 * m + 2) (reverseCumulantMap m (2 * m + 2) eta)) (horizontalContractionMinorPolynomial m)
= 0
Proof (Lean source)
lemma horizontalContractionMinorPolynomial_reverse_vanishes (m : ℕ)
(eta : ParamSpace ℂ m) :
eval
(restrictCumBand (2 * m + 2)
(reverseCumulantMap m (2 * m + 2) eta))
(horizontalContractionMinorPolynomial m) = 0 := by
rw [eval_horizontalContractionMinorPolynomial,
horizontalContractionMinorMatrix_eq_mul_reverse, Matrix.det_mul]
have hzero : (horizontalDirectionEvaluationMatrix m
(reverseLoading m eta.1 eta.2.1)).det = 0 := by
apply Matrix.det_eq_zero_of_row_eq_zero (0 : Fin (m + 2))
intro b
simp [horizontalDirectionEvaluationMatrix, reverseLoading]
rw [hzero, mul_zero]
theorem horizontalContractionMinorPolynomial_forwardCommonAxis_vanishes
Proves the stated mathematical property of horizontal Contraction Minor Polynomial forward Common Axis vanishes.
Formal statement
hypotheses
conclusion
eval (restrictCumBand (2 * m + 2) (forwardCumulantMap m (2 * m + 2) theta)) (horizontalContractionMinorPolynomial m)
= 0
Proof (Lean source)
lemma horizontalContractionMinorPolynomial_forwardCommonAxis_vanishes
{m : ℕ} (hm : 1 ≤ m) {theta : ParamSpace ℂ m}
(haxis : theta.2.1 ⟨0, hm⟩ = 0) :
eval
(restrictCumBand (2 * m + 2)
(forwardCumulantMap m (2 * m + 2) theta))
(horizontalContractionMinorPolynomial m) = 0 := by
rw [eval_horizontalContractionMinorPolynomial,
horizontalContractionMinorMatrix_eq_mul_forward, Matrix.det_mul]
have hzero : (horizontalDirectionEvaluationMatrix m
(forwardLoading m theta.1 theta.2.1)).det = 0 := by
apply Matrix.det_eq_zero_of_row_eq_zero ⟨1, by omega⟩
intro b
have hm0 : m ≠ 0 := by omega
simp [horizontalDirectionEvaluationMatrix, forwardLoading, haxis, hm0]
rw [hzero, mul_zero]
theorem horizontalContractionMinorPolynomial_reverseVariety_vanishes
The observable horizontal-axis contraction minor vanishes on the entire reverse arrow-image variety, not only on its parameterized range.
Formal statement
hypotheses
conclusion
= 0
Proof (Lean source)
lemma horizontalContractionMinorPolynomial_reverseVariety_vanishes (m : ℕ)
{t : CumVec ℂ}
(ht : t ∈ cumulantImageVariety (reverseCumulantMap m (2 * m + 2))) :
eval (restrictCumBand (2 * m + 2) t)
(horizontalContractionMinorPolynomial m) = 0 := by
have htband : t ∈ bandSupportedCumulants (2 * m + 2) := by
apply zariskiClosure_subset_band
(A := range (reverseCumulantMap m (2 * m + 2)))
· rintro _ ⟨eta, rfl⟩
exact reverseCumulantMap_mem_bandSupportedCumulants m (2 * m + 2) eta
· exact ht
rw [← eval_extendCumPolynomial (2 * m + 2)
(restrictCumBand (2 * m + 2) t) (horizontalContractionMinorPolynomial m)]
rw [extend_restrictCumBand htband]
apply ht (extendCumPolynomial (2 * m + 2)
(horizontalContractionMinorPolynomial m))
rintro _ ⟨eta, rfl⟩
rw [← extend_restrictCumBand
(reverseCumulantMap_mem_bandSupportedCumulants m (2 * m + 2) eta)]
rw [eval_extendCumPolynomial]
exact horizontalContractionMinorPolynomial_reverse_vanishes m eta
theorem horizontalContractionMinorPolynomial_forwardCommonAxisClosure_vanishes
The same observable minor vanishes on the Zariski closure of the explicit forward common-axis image family.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
t :
CumVec ℂ
ht :
t ∈ zariskiClosure ((forwardCumulantMap m (2 * m + 2)) '' {theta : ParamSpace ℂ m | theta ∈ genericParameterLocus m (2 * m + 2) ∧ theta.2.1 ⟨0, hm⟩ = 0})
conclusion
= 0
Proof (Lean source)
lemma horizontalContractionMinorPolynomial_forwardCommonAxisClosure_vanishes
{m : ℕ} (hm : 1 ≤ m) {t : CumVec ℂ}
(ht : t ∈ zariskiClosure
((forwardCumulantMap m (2 * m + 2)) ''
{theta : ParamSpace ℂ m |
theta ∈ genericParameterLocus m (2 * m + 2) ∧
theta.2.1 ⟨0, hm⟩ = 0})) :
eval (restrictCumBand (2 * m + 2) t)
(horizontalContractionMinorPolynomial m) = 0 := by
have hsourceBand :
(forwardCumulantMap m (2 * m + 2)) ''
{theta : ParamSpace ℂ m |
theta ∈ genericParameterLocus m (2 * m + 2) ∧
theta.2.1 ⟨0, hm⟩ = 0} ⊆
bandSupportedCumulants (2 * m + 2) := by
rintro _ ⟨theta, _, rfl⟩
exact forwardCumulantMap_mem_bandSupportedCumulants m (2 * m + 2) theta
have htband : t ∈ bandSupportedCumulants (2 * m + 2) :=
zariskiClosure_subset_band hsourceBand ht
rw [← eval_extendCumPolynomial (2 * m + 2)
(restrictCumBand (2 * m + 2) t) (horizontalContractionMinorPolynomial m)]
rw [extend_restrictCumBand htband]
apply ht (extendCumPolynomial (2 * m + 2)
(horizontalContractionMinorPolynomial m))
rintro _ ⟨theta, htheta, rfl⟩
rw [← extend_restrictCumBand
(forwardCumulantMap_mem_bandSupportedCumulants m (2 * m + 2) theta)]
rw [eval_extendCumPolynomial]
exact horizontalContractionMinorPolynomial_forwardCommonAxis_vanishes hm htheta.2
theorem horizontalContractionMinorPolynomial_forwardWitness_ne_zero
Nonvanishing of the observable minor at the explicit forward block-Vandermonde witness.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
eval (restrictCumBand (2 * m + 2) (forwardCumulantMap m (2 * m + 2) (forwardContractionMinorWitnessParameter m))) (horizontalContractionMinorPolynomial m)
≠ 0
Proof (Lean source)
lemma horizontalContractionMinorPolynomial_forwardWitness_ne_zero
(m : ℕ) (hm : 1 ≤ m) :
eval
(restrictCumBand (2 * m + 2)
(forwardCumulantMap m (2 * m + 2)
(forwardContractionMinorWitnessParameter m)))
(horizontalContractionMinorPolynomial m) ≠ 0 := by
rw [eval_horizontalContractionMinorPolynomial,
horizontalContractionMinorMatrix_eq_mul_forward, Matrix.det_mul]
apply mul_ne_zero
· have heq : selectedContractionWeightMatrix m
(forwardContractionMinorWitnessParameter m).2.2
(forwardLoading m (forwardContractionMinorWitnessParameter m).1
(forwardContractionMinorWitnessParameter m).2.1) =
forwardSelectedContractionMatrix m
(forwardContractionMinorWitnessParameter m) := by
ext i j
refine Fin.cases ?_ (fun a => ?_) i
· rfl
· dsimp [selectedContractionWeightMatrix,
forwardSelectedContractionMatrix]
ring
rw [heq]
exact forwardContractionMinorWitness_det_ne_zero m hm
· exact horizontalDirectionEvaluationMatrix_witness_det_ne_zero m
theorem horizontalContractionMinorPolynomial_ne_zero
The observable contraction minor is a nonzero polynomial.
Formal statement
Proof (Lean source)
lemma horizontalContractionMinorPolynomial_ne_zero (m : ℕ) (hm : 1 ≤ m) :
horizontalContractionMinorPolynomial m ≠ 0 := by
intro hzero
exact (horizontalContractionMinorPolynomial_forwardWitness_ne_zero m hm)
(by rw [hzero, map_zero])
Helpers.BandDimensionTransfer 4 declarations
theorem encodeBandParam_closed_iff
Proves the stated closedness property for encode Band Param closed iff.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma encodeBandParam_closed_iff {m L : ℕ} (hL : 2 ≤ L)
{Z : Set (ParamSpace ℂ m)} (hZ : Z ⊆ bandSupportedParams m L) :
zariskiClosureParamIn L Z = Z ↔
affineZariskiClosure ((encodeBandParam (L := L)) '' Z) =
(encodeBandParam (L := L)) '' Z := by
constructor
· intro hc
rw [← encodeBandParam_zariskiClosureParamIn hL hZ, hc]
· intro hc
apply eq_of_image_eq_of_injOn (encodeBandParam_injectiveOn hL)
· intro θ hθ
exact hθ.1
· exact hZ
rw [encodeBandParam_zariskiClosureParamIn hL hZ, hc]
theorem decodeBandParam_closed
Proves the stated closedness property for decode Band Param closed.
Formal statement
hypotheses
conclusion
zariskiClosureParamIn L ((decodeBandParam (L := L)) '' W)
= (decodeBandParam (L := L)) '' W
Proof (Lean source)
lemma decodeBandParam_closed {m L : ℕ} (hL : 2 ≤ L)
{W : Set (BandParamCoord m L → ℂ)}
(hW : affineZariskiClosure W = W) :
zariskiClosureParamIn L ((decodeBandParam (L := L)) '' W) =
(decodeBandParam (L := L)) '' W := by
have hs : (decodeBandParam (L := L)) '' W ⊆ bandSupportedParams m L := by
rintro _ ⟨x, _, rfl⟩
exact decodeBandParam_supported x
apply (encodeBandParam_closed_iff hL hs).mpr
rw [image_decodeBandParam hL, hW]
theorem irreducibleParamIn_iff_irreducibleBand
Irreducibility is unchanged by passage to finite retained-band coordinates.
Formal statement
hypotheses
conclusion
↔ IsIrreducibleAffineClosed ((encodeBandParam (L := L)) '' Z)
Proof (Lean source)
theorem irreducibleParamIn_iff_irreducibleBand {m L : ℕ} (hL : 2 ≤ L)
{Z : Set (ParamSpace ℂ m)} (hZ : Z ⊆ bandSupportedParams m L) :
IsIrreducibleZariskiClosedParamIn L Z ↔
IsIrreducibleAffineClosed ((encodeBandParam (L := L)) '' Z) := by
constructor
· rintro ⟨hclosed, hne, hirr⟩
refine ⟨(encodeBandParam_closed_iff hL hZ).mp hclosed,
hne.image _, ?_⟩
intro A B hA hB hAB
let A' := (decodeBandParam (L := L)) '' A
let B' := (decodeBandParam (L := L)) '' B
have hA' := decodeBandParam_closed hL hA
have hB' := decodeBandParam_closed hL hB
have hZAB : Z = A' ∪ B' := by
rw [← decodeBandParam_image hL hZ, hAB, Set.image_union]
rcases hirr A' B' hA' hB' hZAB with h | h
· left
simpa [h, A', image_decodeBandParam hL]
· right
simpa [h, B', image_decodeBandParam hL]
· rintro ⟨hclosed, hne, hirr⟩
refine ⟨(encodeBandParam_closed_iff hL hZ).mpr hclosed, ?_, ?_⟩
· obtain ⟨_, ⟨z, hz, rfl⟩⟩ := hne
exact ⟨z, hz⟩
· intro A B hA hB hZAB
have hAs : A ⊆ bandSupportedParams m L := by
rw [← hA]
intro x hx
exact hx.1
have hBs : B ⊆ bandSupportedParams m L := by
rw [← hB]
intro x hx
exact hx.1
have hiA := (encodeBandParam_closed_iff hL hAs).mp hA
have hiB := (encodeBandParam_closed_iff hL hBs).mp hB
have hiUnion : (encodeBandParam (L := L)) '' Z =
(encodeBandParam (L := L)) '' A ∪
(encodeBandParam (L := L)) '' B := by
rw [hZAB, Set.image_union]
rcases hirr _ _ hiA hiB hiUnion with hi | hi
· left
exact eq_of_image_eq_of_injOn (encodeBandParam_injectiveOn hL) hZ hAs hi
· right
exact eq_of_image_eq_of_injOn (encodeBandParam_injectiveOn hL) hZ hBs hi
theorem relativeDimension_iff_bandDimension
The paper's relative chain dimension is literally the affine chain dimension of the encoded finite-band set.
Formal statement
hypotheses
conclusion
↔ HasAffineZariskiDimension d ((encodeBandParam (L := L)) '' Z)
Proof (Lean source)
theorem relativeDimension_iff_bandDimension {m L d : ℕ} (hL : 2 ≤ L)
{Z : Set (ParamSpace ℂ m)} (hZ : Z ⊆ bandSupportedParams m L) :
HasRelativeZariskiDimension L d Z ↔
HasAffineZariskiDimension d ((encodeBandParam (L := L)) '' Z) := by
let f := encodeBandParam (m := m) (L := L)
have hf : InjOn f (bandSupportedParams m L) := encodeBandParam_injectiveOn hL
constructor
· rintro ⟨⟨chain, hmono, hirr, hsub⟩, hmax⟩
constructor
· refine ⟨fun i => f '' chain i,
image_strictMono f hf hmono (fun i => (hsub i).trans hZ), ?_, ?_⟩
· intro i
apply (irreducibleParamIn_iff_irreducibleBand hL
((hsub i).trans hZ)).mp
exact hirr i
· intro i
exact Set.image_mono (hsub i)
· rintro ⟨c, hcmono, hcirr, hcsub⟩
let c' := fun i => (decodeBandParam (m := m) (L := L)) '' c i
apply hmax
refine ⟨c', ?_, ?_, ?_⟩
· intro i j hij
have hs := hcmono hij
exact image_strictMono (decodeBandParam (m := m) (L := L))
(fun _ _ _ _ h => congrArg (encodeBandParam (L := L)) h |>
(by simpa [encode_decodeBandParam hL] using ·)) hcmono
(fun _ => Set.subset_univ _) hij
· intro i
have hs : c' i ⊆ bandSupportedParams m L := by
rintro _ ⟨x, _, rfl⟩
exact decodeBandParam_supported x
apply (irreducibleParamIn_iff_irreducibleBand hL hs).mpr
simpa [c', image_decodeBandParam hL] using hcirr i
· intro i _ hx
rcases hx with ⟨x, hxc, rfl⟩
have := hcsub i hxc
rcases this with ⟨z, hz, heq⟩
rw [← heq, decode_encodeBandParam hL (hZ hz)]
exact hz
· rintro ⟨⟨chain, hmono, hirr, hsub⟩, hmax⟩
constructor
· let c := fun i => (decodeBandParam (m := m) (L := L)) '' chain i
refine ⟨c, ?_, ?_, ?_⟩
· exact image_strictMono _ (fun _ _ _ _ heq => by
simpa [encode_decodeBandParam hL] using
congrArg (encodeBandParam (L := L)) heq) hmono
(fun _ => Set.subset_univ _)
· intro i
have hs : c i ⊆ bandSupportedParams m L := by
rintro _ ⟨x, _, rfl⟩
exact decodeBandParam_supported x
apply (irreducibleParamIn_iff_irreducibleBand hL hs).mpr
simpa [c, image_decodeBandParam hL] using hirr i
· intro i _ hx
rcases hx with ⟨x, hxc, rfl⟩
rcases hsub i hxc with ⟨z, hz, heq⟩
rw [← heq, decode_encodeBandParam hL (hZ hz)]
exact hz
· rintro ⟨c, hcmono, hcirr, hcsub⟩
apply hmax
refine ⟨fun i => f '' c i,
image_strictMono f hf hcmono (fun i => (hcsub i).trans hZ), ?_, ?_⟩
· intro i
exact (irreducibleParamIn_iff_irreducibleBand hL
((hcsub i).trans hZ)).mp (hcirr i)
· intro i
exact Set.image_mono (hcsub i)
Helpers.BandParameterCoordinates 13 declarations
def BandParamCoord
Coordinates of the finite retained-band parameter space. The last Fin (L-1) coordinate represents orders 2, ..., L.
Definition (Lean source)
def encodeBandParam
Read retained coordinates from a function-valued parameter.
Definition (Lean source)
def encodeBandParam {m L : ℕ} (θ : ParamSpace ℂ m) : BandParamCoord m L → ℂ
| inl _ => θ.1
| inr (inl i) => θ.2.1 i
| inr (inr jk) => θ.2.2 jk.1 (jk.2.val + 2)
def decodeBandParam
Put a finite coordinate vector back into the function-valued parameter space, setting every off-band weight to zero.
Definition (Lean source)
def decodeBandParam {m L : ℕ} (x : BandParamCoord m L → ℂ) : ParamSpace ℂ m :=
(x (inl ()),
fun i => x (inr (inl i)),
fun j r => if h : 2 ≤ r ∧ r ≤ L then
x (inr (inr (j, ⟨r - 2, by omega⟩))) else 0)
theorem decodeBandParam_supported
A parameter point read off from a finite vector of retained coordinates is always band supported: every source weight of an order below two or above L vanishes.
Formal statement
hypotheses
m L :
ℕ
x :
BandParamCoord m L → ℂ
conclusion
decodeBandParam x ∈ bandSupportedParams m L
Proof (Lean source)
lemma decodeBandParam_supported {m L : ℕ} (x : BandParamCoord m L → ℂ) :
decodeBandParam x ∈ bandSupportedParams m L := by
intro j r hr
simp only [decodeBandParam]
split
· rename_i h
omega
· rfl
theorem encode_decodeBandParam
Proves the stated mathematical property of encode decode Band Param.
Formal statement
hypotheses
conclusion
encodeBandParam (L := L) (decodeBandParam (L := L) x) = x
Proof (Lean source)
lemma encode_decodeBandParam {m L : ℕ} (hL : 2 ≤ L)
(x : BandParamCoord m L → ℂ) :
encodeBandParam (L := L) (decodeBandParam (L := L) x) = x := by
funext c
rcases c with _ | (i | ⟨j, k⟩)
· rfl
· rfl
· simp only [encodeBandParam, decodeBandParam]
split
· rename_i h
congr 2
· rename_i h
exfalso
omega
theorem decode_encodeBandParam
Proves the stated mathematical property of decode encode Band Param.
Formal statement
hypotheses
conclusion
decodeBandParam (L := L) (encodeBandParam (L := L) θ) = θ
Proof (Lean source)
lemma decode_encodeBandParam {m L : ℕ} (hL : 2 ≤ L)
{θ : ParamSpace ℂ m} (hθ : θ ∈ bandSupportedParams m L) :
decodeBandParam (L := L) (encodeBandParam (L := L) θ) = θ := by
rcases θ with ⟨γ, ρ, w⟩
apply Prod.ext
· rfl
apply Prod.ext
· rfl
funext j r
simp only [decodeBandParam, encodeBandParam]
split
· rename_i h
congr 1
omega
· rename_i h
symm
apply hθ j r
omega
def bandParamEquiv
The actual retained-band subtype is equivalent to an ordinary finite complex affine space.
Definition (Lean source)
def bandParamEquiv {m L : ℕ} (hL : 2 ≤ L) :
{θ : ParamSpace ℂ m // θ ∈ bandSupportedParams m L} ≃
(BandParamCoord m L → ℂ) where
toFun θ := encodeBandParam θ
invFun x := ⟨decodeBandParam x, decodeBandParam_supported x⟩
left_inv θ := Subtype.ext (decode_encodeBandParam hL θ.property)
right_inv := encode_decodeBandParam hL
def bandCoordEmbedding
Embed a finite band coordinate among the original natural-number-indexed polynomial variables.
Definition (Lean source)
def bandCoordEmbedding {m L : ℕ} : BandParamCoord m L → ParamCoord m
| inl u => inl u
| inr (inl i) => inr (inl i)
| inr (inr jk) => inr (inr (jk.1, jk.2.val + 2))
theorem bandCoordEmbedding_injective
Distinct retained coordinates name distinct parameter variables: for a truncation order of at least two, the embedding of the finite band coordinates into the original parameter coordinates is injective.
Formal statement
hypotheses
m L :
ℕ
hL :
2 ≤ L
conclusion
Proof (Lean source)
lemma bandCoordEmbedding_injective {m L : ℕ} (hL : 2 ≤ L) :
Injective (bandCoordEmbedding : BandParamCoord m L → ParamCoord m) := by
intro a b hab
rcases a with _ | (i | ⟨j, k⟩) <;>
rcases b with _ | (i' | ⟨j', k'⟩) <;>
simp [bandCoordEmbedding, Fin.ext_iff] at hab ⊢
all_goals exact hab
def restrictParamPolynomial
Restrict an original parameter polynomial to the retained band by setting all off-band weight variables to zero.
Definition (Lean source)
def restrictParamPolynomial {m L : ℕ}
(P : MvPolynomial (ParamCoord m) ℂ) : MvPolynomial (BandParamCoord m L) ℂ :=
MvPolynomial.eval₂Hom C (fun c =>
match c with
| inl u => X (inl u)
| inr (inl i) => X (inr (inl i))
| inr (inr jr) =>
if h : 2 ≤ jr.2 ∧ jr.2 ≤ L then
X (inr (inr
(jr.1, ⟨jr.2 - 2, by omega⟩))) else 0) P
theorem eval_restrictParamPolynomial
Restricting a parameter polynomial to the retained band and evaluating it at a finite coordinate vector gives the same number as evaluating the original polynomial at the parameter point those coordinates decode to. Killing the off-band weight variables therefore loses no information, provided the truncation order is at least two.
Formal statement
hypotheses
conclusion
eval x (restrictParamPolynomial P)
Proof (Lean source)
lemma eval_restrictParamPolynomial {m L : ℕ} (hL : 2 ≤ L)
(x : BandParamCoord m L → ℂ) (P : MvPolynomial (ParamCoord m) ℂ) :
eval x (restrictParamPolynomial P) =
eval (paramEval (decodeBandParam x)) P := by
change eval x (eval₂ C _ P) = _
rw [MvPolynomial.eval_eval₂]
have hC : (eval x).comp C = id ℂ := by
ext z
simp
rw [hC, MvPolynomial.eval₂_id]
apply MvPolynomial.eval₂_congr
intro c _ _
rcases c with _ | (i | ⟨j, r⟩)
· simp [paramEval, decodeBandParam]
· simp [paramEval, decodeBandParam]
· by_cases hr : 2 ≤ r ∧ r ≤ L
· simp [hr, paramEval, decodeBandParam, encodeBandParam]
· simp [hr, paramEval, decodeBandParam]
theorem eval_rename_bandCoordEmbedding
Gives the stated evaluation formula for eval rename band Coord Embedding.
Formal statement
hypotheses
conclusion
= eval (encodeBandParam θ) Q
Proof (Lean source)
lemma eval_rename_bandCoordEmbedding {m L : ℕ}
(θ : ParamSpace ℂ m) (Q : MvPolynomial (BandParamCoord m L) ℂ) :
eval (paramEval θ) (rename bandCoordEmbedding Q) =
eval (encodeBandParam θ) Q := by
rw [MvPolynomial.eval_rename]
apply congrArg (fun f => eval f Q)
funext c
rcases c with _ | (i | ⟨j, k⟩) <;> rfl
theorem encodeBandParam_zariskiClosureParamIn
Relative closure in the paper's retained-band ambient becomes ordinary affine algebraic closure under finite-coordinate encoding.
Formal statement
hypotheses
conclusion
(encodeBandParam (L := L)) '' zariskiClosureParamIn L A
= affineZariskiClosure ((encodeBandParam (L := L)) '' A)
Proof (Lean source)
theorem encodeBandParam_zariskiClosureParamIn {m L : ℕ} (hL : 2 ≤ L)
{A : Set (ParamSpace ℂ m)} (hA : A ⊆ bandSupportedParams m L) :
(encodeBandParam (L := L)) '' zariskiClosureParamIn L A =
affineZariskiClosure ((encodeBandParam (L := L)) '' A) := by
ext x
constructor
· rintro ⟨θ, hθ, rfl⟩
change encodeBandParam θ ∈ zeroLocus ℂ
(vanishingIdeal ℂ (encodeBandParam '' A))
rw [MvPolynomial.mem_zeroLocus_iff]
simp only [MvPolynomial.aeval_def]
intro Q hQ
change eval (encodeBandParam θ) Q = 0
rw [← eval_rename_bandCoordEmbedding]
exact hθ.2 (rename bandCoordEmbedding Q) (by
intro s hs
rw [eval_rename_bandCoordEmbedding]
simpa [MvPolynomial.aeval_def, MvPolynomial.eval₂_id] using
hQ (encodeBandParam s) ⟨s, hs, rfl⟩)
· intro hx
change x ∈ zeroLocus ℂ
(vanishingIdeal ℂ (encodeBandParam '' A)) at hx
rw [MvPolynomial.mem_zeroLocus_iff] at hx
have hx' : ∀ p ∈ vanishingIdeal ℂ
((encodeBandParam (L := L)) '' A), eval x p = 0 := by
intro p hp
simpa [MvPolynomial.aeval_def, MvPolynomial.eval₂_id] using hx p hp
refine ⟨decodeBandParam (L := L) x, ?_, encode_decodeBandParam hL x⟩
refine ⟨decodeBandParam_supported x, ?_⟩
intro P hP
rw [← eval_restrictParamPolynomial hL]
exact hx' (restrictParamPolynomial P) (by
rintro y ⟨s, hs, rfl⟩
change eval (encodeBandParam s) (restrictParamPolynomial P) = 0
rw [eval_restrictParamPolynomial hL,
decode_encodeBandParam hL (hA hs)]
exact hP s hs)
Helpers.BandWeightKernelDimension 5 declarations
def bandWeightKernel
The tangent space obtained by fixing every loading slope and allowing each retained order's source weights to move in its synthesis kernel.
Definition (Lean source)
def bandWeightKernel (m L : ℕ) (s : Fin (m + 1) → ℂ) :
Submodule ℂ (BandParamCoord m L → ℂ) where
carrier := {x |
x (inl ()) = 0 ∧
(∀ i, x (inr (inl i)) = 0) ∧
∀ k : Fin (L - 1), endpointOrderSynthesis s (k.val + 2)
(fun j => x (inr (inr (j, k)))) = 0}
zero_mem' := by
refine ⟨rfl, fun _ => rfl, ?_⟩
intro k
change endpointOrderSynthesis s (k.val + 2) 0 = 0
exact (endpointOrderSynthesis s (k.val + 2)).map_zero
add_mem' {x y} hx hy := by
refine ⟨by simp [hx.1, hy.1], fun i => by simp [hx.2.1 i, hy.2.1 i], ?_⟩
intro k
change endpointOrderSynthesis s (k.val + 2)
((fun j => x (inr (inr (j, k)))) +
fun j => y (inr (inr (j, k)))) = 0
rw [map_add, hx.2.2 k, hy.2.2 k, add_zero]
smul_mem' c x hx := by
refine ⟨by simp [hx.1], fun i => by simp [hx.2.1 i], ?_⟩
intro k
change endpointOrderSynthesis s (k.val + 2)
(c • fun j => x (inr (inr (j, k)))) = 0
rw [map_smul, hx.2.2 k, smul_zero]
def bandWeightKernelEquiv
The retained-band kernel is the product of its independent order blocks.
Definition (Lean source)
def bandWeightKernelEquiv (m L : ℕ) (s : Fin (m + 1) → ℂ) :
bandWeightKernel m L s ≃ₗ[ℂ]
(∀ k : Fin (L - 1), ker (endpointOrderSynthesis s (k.val + 2))) where
toFun x k := ⟨fun j => x.1 (inr (inr (j, k))), x.2.2.2 k⟩
invFun z := ⟨fun c =>
match c with
| inl _ => 0
| inr (inl _) => 0
| inr (inr jk) => (z jk.2).1 jk.1,
by
refine ⟨rfl, fun _ => rfl, ?_⟩
intro k
exact (z k).property⟩
map_add' x y := by
funext k
apply Subtype.ext
funext j
rfl
map_smul' c x := by
funext k
apply Subtype.ext
funext j
rfl
left_inv x := by
apply Subtype.ext
funext c
rcases c with _ | (i | ⟨j, k⟩)
· exact x.2.1.symm
· exact (x.2.2.1 i).symm
· rfl
right_inv z := by
funext k
apply Subtype.ext
funext j
rfl
theorem bandWeightKernel_finrank
Establishes the stated dimension formula for band Weight Kernel.
Formal statement
hypotheses
conclusion
finrank ℂ (bandWeightKernel m L s)
= Finset.univ.sum (fun k : Fin (L - 1) => (m + 1) - (k.val + 2))
Proof (Lean source)
lemma bandWeightKernel_finrank (m L : ℕ) (s : Fin (m + 1) → ℂ)
(hs : Injective s) :
finrank ℂ (bandWeightKernel m L s) =
Finset.univ.sum (fun k : Fin (L - 1) => (m + 1) - (k.val + 2)) := by
rw [(bandWeightKernelEquiv m L s).finrank_eq,
Module.finrank_pi_fintype]
apply Finset.sum_congr rfl
intro k _
exact endpointOrderSynthesis_ker_finrank s hs
theorem retained_kernel_sum
Proves the stated mathematical property of retained kernel sum.
Formal statement
hypotheses
m :
ℕ
hm :
2 ≤ m
conclusion
Finset.univ.sum (fun k : Fin ((2 * m + 2) - 1) => (m + 1) - (k.val + 2)) = m * (m - 1) / 2
Proof (Lean source)
lemma retained_kernel_sum (m : ℕ) (hm : 2 ≤ m) :
Finset.univ.sum (fun k : Fin ((2 * m + 2) - 1) =>
(m + 1) - (k.val + 2)) =
m * (m - 1) / 2 := by
rw [Fin.sum_univ_eq_sum_range (fun k => (m + 1) - (k + 2))
((2 * m + 2) - 1)]
have hsplit :
(range ((2 * m + 2) - 1)).sum
(fun k => (m + 1) - (k + 2)) =
(range (m - 1)).sum (fun k => (m - 1) - k) := by
calc
_ = (range (m - 1)).sum
(fun k => (m + 1) - (k + 2)) := by
symm
apply Finset.sum_subset
· intro k hk
simp only [Finset.mem_range] at hk ⊢
omega
· intro k hkall hksmall
simp only [Finset.mem_range] at hkall hksmall
omega
_ = _ := by
apply Finset.sum_congr rfl
intro k hk
simp only [Finset.mem_range] at hk
omega
rw [hsplit]
have hreflect :
(range (m - 1)).sum (fun k => (m - 1) - k) =
(range (m - 1)).sum (fun k => k + 1) := by
calc
_ = (range (m - 1)).sum
(fun k => (m - 1 - 1 - k) + 1) := by
apply Finset.sum_congr rfl
intro k hk
simp only [Finset.mem_range] at hk
omega
_ = _ := Finset.sum_range_reflect (fun k => k + 1) (m - 1)
rw [hreflect]
have hshift :
(range (m - 1)).sum (fun k => k + 1) =
(range m).sum (fun k => k) := by
simpa [Nat.sub_add_cancel (by omega : 1 ≤ m)] using
(Finset.sum_range_succ' (fun k : ℕ => k) (m - 1)).symm
rw [hshift, Finset.sum_range_id]
theorem bandWeightKernel_finrank_flagship
At the flagship retained order, the independent low-order weight kernels have total dimension m(m-1)/2.
Formal statement
hypotheses
conclusion
finrank ℂ (bandWeightKernel m (2 * m + 2) s) = m * (m - 1) / 2
Proof (Lean source)
theorem bandWeightKernel_finrank_flagship (m : ℕ) (s : Fin (m + 1) → ℂ)
(hs : Injective s) (hm : 2 ≤ m) :
finrank ℂ (bandWeightKernel m (2 * m + 2) s) =
m * (m - 1) / 2 := by
rw [bandWeightKernel_finrank m (2 * m + 2) s hs,
retained_kernel_sum m hm]
Helpers.CAD.CADInterface 46 declarations Semialgebraic subsets of ℝ^r
Semialgebraic subsets of ℝ^r
def CADSpace
The affine space ℝ^r the cited decomposition lives in.
A basic semialgebraic subset of ℝ^r: the common solution set of finitely many polynomial equations, finitely many non-strict polynomial inequalities and finitely many strict polynomial inequalities. These are the sets the cells are cut out by.
Definition (Lean source)
def IsBasicSemialgebraic {r : ℕ} (S : Set (CADSpace r)) : Prop :=
∃ equations nonnegative positive : Finset (MvPolynomial (Fin r) ℝ),
S = { x | (∀ P ∈ equations, eval x P = 0) ∧
(∀ P ∈ nonnegative, 0 ≤ eval x P) ∧
(∀ P ∈ positive, 0 < eval x P) }
A semialgebraic subset of ℝ^r: a finite union of basic semialgebraic sets.
Definition (Lean source)
def IsSemialgebraicSet {r : ℕ} (S : Set (CADSpace r)) : Prop :=
∃ (ι : Type) (_ : Fintype ι) (piece : ι → Set (CADSpace r)),
(∀ i, IsBasicSemialgebraic (piece i)) ∧ S = ⋃ i, piece i
def cadAsUnivariate
Regard a multivariate polynomial as a univariate polynomial in the selected CAD lifting variable, with all other variables retained in its coefficient ring.
Definition (Lean source)
def cadAsUnivariate {σ : Type} [DecidableEq σ] (x : σ)
(P : MvPolynomial σ ℝ) : Polynomial (MvPolynomial σ ℝ) :=
MvPolynomial.eval₂Hom (Polynomial.C.comp C)
(fun y => if y = x then Polynomial.X else Polynomial.C (X y)) P
def cadReductum
Delete the current leading term when P is regarded as a polynomial in x. Iterating this operation gives BPR's successive truncations/reducta.
Definition (Lean source)
def cadReductum {σ : Type} [DecidableEq σ] (x : σ)
(P : MvPolynomial σ ℝ) : MvPolynomial σ ℝ :=
let univariate := cadAsUnivariate x P
P - univariate.coeff univariate.natDegree *
X x ^ univariate.natDegree
A coefficient lies in the real ground field, rather than depending on any remaining variable. Using empty variable support makes the predicate decidable for the finite projection algorithm; over MvPolynomial σ ℝ it is equivalent to being a constant polynomial.
Definition (Lean source)
def IsCADGroundCoefficient {σ : Type} (C : MvPolynomial σ ℝ) : Prop :=
C.vars = ∅
A nonzero member of the real ground field.
Definition (Lean source)
def IsCADNonzeroGroundCoefficient {σ : Type} (C : MvPolynomial σ ℝ) : Prop :=
C ≠ 0 ∧ IsCADGroundCoefficient C
def cadLeadingCoefficient
The leading coefficient in the selected lifting variable.
Definition (Lean source)
def cadLeadingCoefficient {σ : Type} [DecidableEq σ] (x : σ)
(P : MvPolynomial σ ℝ) : MvPolynomial σ ℝ :=
(cadAsUnivariate x P).coeff (cadAsUnivariate x P).natDegree
def cadReductaAux
Successive BPR truncations with their exact stopping rule. A nonzero current reductum is retained. Recursion continues only when its leading coefficient is not a nonzero ground-field constant; zero terminates immediately. The fuel is the original x-degree plus one.
Definition (Lean source)
def cadReductaAux {σ : Type} [DecidableEq σ] (x : σ) :
ℕ → MvPolynomial σ ℝ → Finset (MvPolynomial σ ℝ)
| 0, _ => ∅
| fuel + 1, P =>
if P = 0 then ∅
else insert P (if IsCADNonzeroGroundCoefficient (cadLeadingCoefficient x P) then ∅
else cadReductaAux x fuel (cadReductum x P))
def cadReducta
Every relevant nonzero truncation/reductum of P in the selected variable, exactly stopping at a nonzero ground-field leading coefficient as in BPR's Tru(P).
Definition (Lean source)
def cadReducta {σ : Type} [DecidableEq σ] (x : σ)
(P : MvPolynomial σ ℝ) : Finset (MvPolynomial σ ℝ) :=
cadReductaAux x ((cadAsUnivariate x P).natDegree + 1) P
def cadReductaFamily
The nonzero reducta of every polynomial in a finite stage family.
Definition (Lean source)
def cadReductaFamily {σ : Type} [DecidableEq σ] (x : σ)
(family : Finset (MvPolynomial σ ℝ)) : Finset (MvPolynomial σ ℝ) :=
family.biUnion (cadReducta x)
theorem mem_cadReducta_ne_zero
Every generated reductum is nonzero.
Formal statement
Proof (Lean source)
theorem mem_cadReducta_ne_zero {σ : Type} [DecidableEq σ] {x : σ}
{P R : MvPolynomial σ ℝ} (hR : R ∈ cadReducta x P) : R ≠ 0 := by
simp only [cadReducta] at hR
generalize (cadAsUnivariate x P).natDegree + 1 = fuel at hR
induction fuel generalizing P with
| zero => simp [cadReductaAux] at hR
| succ fuel ih =>
simp only [cadReductaAux] at hR
split at hR
· simp_all
· simp only [Finset.mem_insert] at hR
rcases hR with rfl | hR
· assumption
· split at hR
· simp_all
· exact ih hR
theorem self_mem_cadReducta
A nonzero polynomial occurs as the zeroth member of its own reducta family.
Formal statement
hypotheses
conclusion
P ∈ cadReducta x P
Proof (Lean source)
theorem self_mem_cadReducta {σ : Type} [DecidableEq σ] (x : σ)
{P : MvPolynomial σ ℝ} (hP : P ≠ 0) : P ∈ cadReducta x P := by
simp [cadReducta, cadReductaAux, hP]
theorem cadReducta_zero
The zero polynomial contributes no reductum.
Formal statement
Proof (Lean source)
@[simp] theorem cadReducta_zero {σ : Type} [DecidableEq σ] (x : σ) :
cadReducta x (0 : MvPolynomial σ ℝ) = ∅ := by
simp [cadReducta, cadReductaAux, cadAsUnivariate]
theorem cadReductaFamily_empty
The empty stage has no reducta.
Formal statement
hypotheses
σ :
Type
x :
σ
conclusion
Proof (Lean source)
@[simp] theorem cadReductaFamily_empty {σ : Type} [DecidableEq σ] (x : σ) :
cadReductaFamily x (∅ : Finset (MvPolynomial σ ℝ)) = ∅ := by
simp [cadReductaFamily]
theorem cadReductaFamily_singleton_zero
Focused zero-polynomial receipt: filtering is preserved after taking a family union.
Formal statement
hypotheses
σ :
Type
x :
σ
conclusion
Proof (Lean source)
@[simp] theorem cadReductaFamily_singleton_zero {σ : Type} [DecidableEq σ] (x : σ) :
cadReductaFamily x ({0} : Finset (MvPolynomial σ ℝ)) = ∅ := by
simp [cadReductaFamily]
def cadCoefficients
The coefficient projection operation in variable x.
Definition (Lean source)
def cadCoefficients {σ : Type} [DecidableEq σ] (x : σ)
(family : Finset (MvPolynomial σ ℝ)) : Finset (MvPolynomial σ ℝ) :=
family.biUnion fun P =>
(range ((cadAsUnivariate x P).natDegree + 1)).image
fun k => (cadAsUnivariate x P).coeff k
def cadDiscriminants
The discriminant projection operation in variable x.
Definition (Lean source)
def cadDiscriminants {σ : Type} [DecidableEq σ] (x : σ)
(family : Finset (MvPolynomial σ ℝ)) : Finset (MvPolynomial σ ℝ) :=
family.image fun P => (cadAsUnivariate x P).discr
def cadPrincipalSubresultantMatrix
The square leading block of the Sylvester--Habicht matrix at index j. Its rows are the coefficient vectors of X^(q-j-1) P, ..., P, Q, ..., X^(p-j-1) Q in the descending monomial basis; the first p+q-2j columns give the principal subresultant coefficient.
Definition (Lean source)
def cadPrincipalSubresultantMatrix {R : Type} [CommRing R]
(P Q : Polynomial R) (p q j : ℕ) :
Matrix (Fin (p + q - 2 * j)) (Fin (p + q - 2 * j)) R :=
fun row column =>
let targetDegree := p + q - j - 1 - column.val
if hrow : row.val < q - j then
let shift := q - j - 1 - row.val
if shift ≤ targetDegree then P.coeff (targetDegree - shift) else 0
else
let shift := row.val - (q - j)
if shift ≤ targetDegree then Q.coeff (targetDegree - shift) else 0
def cadPrincipalSubresultantCoefficient
The unsigned principal subresultant coefficient at index j. BPR uses the signed normalization sRes_j; the two differ by a fixed unit ±1, so they have identical zero loci and constant-sign partitions. This determinant is the actual Sylvester--Habicht principal minor, not Polynomial.resultant with artificially reduced degree parameters.
Definition (Lean source)
def cadPrincipalSubresultantCoefficient {σ : Type} [DecidableEq σ] (x : σ)
(P Q : MvPolynomial σ ℝ) (j : ℕ) : MvPolynomial σ ℝ :=
let univariateP := cadAsUnivariate x P
let univariateQ := cadAsUnivariate x Q
(cadPrincipalSubresultantMatrix univariateP univariateQ
univariateP.natDegree univariateQ.natDegree j).det
def cadEqualDegreeCombination
In BPR's equal-degree branch, replace R by lcof(S) R - lcof(R) S, whose leading term cancels.
Definition (Lean source)
def cadEqualDegreeCombination {σ : Type} [DecidableEq σ] (x : σ)
(R S : MvPolynomial σ ℝ) : MvPolynomial σ ℝ :=
cadLeadingCoefficient x S * R - cadLeadingCoefficient x R * S
def cadDerivativePrincipalSubresultants
Derivative principal subresultants of every reductum, with BPR's exact range j = 0, ..., degree(R)-2.
Definition (Lean source)
def cadDerivativePrincipalSubresultants {σ : Type} [DecidableEq σ] (x : σ)
(family : Finset (MvPolynomial σ ℝ)) : Finset (MvPolynomial σ ℝ) :=
family.biUnion fun R =>
(range ((cadAsUnivariate x R).natDegree - 1)).image fun j =>
cadPrincipalSubresultantCoefficient x R (pderiv x R) j
def cadPairPrincipalSubresultants
Pair principal subresultants of all reducta. Unequal degrees put the larger-degree polynomial first and use indices below the smaller degree. Equal degrees use BPR's leading-term-cancelling combination before taking the principal subresultants.
Definition (Lean source)
def cadPairPrincipalSubresultants {σ : Type} [DecidableEq σ] (x : σ)
(family : Finset (MvPolynomial σ ℝ)) : Finset (MvPolynomial σ ℝ) :=
family.biUnion fun R => family.biUnion fun S =>
let degreeR := (cadAsUnivariate x R).natDegree
let degreeS := (cadAsUnivariate x S).natDegree
if degreeS < degreeR then
(range degreeS).image fun j => cadPrincipalSubresultantCoefficient x R S j
else if degreeR < degreeS then
(range degreeR).image fun j => cadPrincipalSubresultantCoefficient x S R j
else
let reducedR := cadEqualDegreeCombination x R S
(range (cadAsUnivariate x reducedR).natDegree).image fun j =>
cadPrincipalSubresultantCoefficient x S reducedR j
def cadPrincipalSubresultants
The derivative and pair principal subresultant coefficients required by BPR Notation 5.15. Ground-field constants are omitted, since their signs are already globally constant.
Definition (Lean source)
def cadPrincipalSubresultants {σ : Type} [DecidableEq σ] (x : σ)
(family : Finset (MvPolynomial σ ℝ)) : Finset (MvPolynomial σ ℝ) :=
(cadDerivativePrincipalSubresultants x family ∪
cadPairPrincipalSubresultants x family).filter fun C => ¬ IsCADGroundCoefficient C
def cadProjectionStep
One projection step (BPR Notation 5.15): coefficients and discriminants of every nonzero reductum, and all derivative/pair principal subresultants of those reducta.
Definition (Lean source)
def cadProjectionStep {σ : Type} [DecidableEq σ] (x : σ)
(family : Finset (MvPolynomial σ ℝ)) : Finset (MvPolynomial σ ℝ) :=
cadCoefficients x (cadReductaFamily x family) ∪
cadDiscriminants x (cadReductaFamily x family) ∪
cadPrincipalSubresultants x (cadReductaFamily x family)
def generatedCADProjectionFamily
The cylindrifying family generated along the supplied order (BPR §11.1): at every round, retain the family computed so far and adjoin its complete BPR elimination family. Thus the next round starts from fam ∪ cadProjectionStep x fam, and the final result contains the input, every nonzero truncation/reductum projection stage, and every later projection of the accumulated family. The foldl shape is load-bearing: replacing the family at each round would leave only the last constants and make lifting vacuous.
Definition (Lean source)
def generatedCADProjectionFamily {σ : Type} [DecidableEq σ]
(order : List σ) (family : Finset (MvPolynomial σ ℝ)) : Finset (MvPolynomial σ ℝ) :=
order.foldl (fun fam x => fam ∪ cadProjectionStep x fam) family
def cadEraseCoordinate
Erase the current lifting coordinate before consulting the recursively constructed base cell.
Definition (Lean source)
The specialization of P at the base point a, leaving only the lifting coordinate x, is not the zero univariate polynomial. This is deliberately stronger than the global condition P ≠ 0: a globally nonzero polynomial can nullify after the base coordinates are fixed.
Definition (Lean source)
def CADSpecializationNonzeroAt {σ : Type} [DecidableEq σ] (x : σ) (a : σ → ℝ)
(P : MvPolynomial σ ℝ) : Prop :=
∃ y : ℝ, eval (update a x y) P ≠ 0
def cadRealRootsAt
The union of the real roots, in the current lifting coordinate, of every polynomial whose specialization at the current base point is nonzero. A polynomial that specializes identically to zero in the lifting variable is ignored, as in standard CAD lifting. This excludes both a globally zero input and a globally nonzero input nullified on the current base cell; without the latter guard, {X₁} lifted first in X₀ would contribute all of ℝ above the base X₁ = 0, contradicting the finiteness required of algebraic sections. Sections are selected from this whole ordered root stack, rather than being required to be the unique root of one polynomial.
Definition (Lean source)
def cadRealRootsAt {σ : Type} [DecidableEq σ] (x : σ) (family : Finset (MvPolynomial σ ℝ)) (a : σ → ℝ) : Set ℝ :=
{ z | ∃ P ∈ family, CADSpecializationNonzeroAt x a P ∧
eval (update a x z) P = 0 }
theorem cadRealRootsAt_eq_empty_of_specializes_zero
If every member of the stage family specializes to the zero univariate polynomial over a base point, then that base point has no CAD lifting roots.
Formal statement
hypotheses
conclusion
cadRealRootsAt x family a = ∅
Proof (Lean source)
theorem cadRealRootsAt_eq_empty_of_specializes_zero {σ : Type} [DecidableEq σ] (x : σ)
(family : Finset (MvPolynomial σ ℝ)) (a : σ → ℝ)
(hzero : ∀ P ∈ family, ∀ z : ℝ, eval (update a x z) P = 0) :
cadRealRootsAt x family a = ∅ := by
ext z
simp only [cadRealRootsAt, Set.mem_setOf_eq, Set.mem_empty_iff_false, iff_false]
rintro ⟨P, hP, ⟨y, hy⟩, -⟩
exact hy (hzero P hP y)
theorem cadRealRootsAt_singleton_other_variable_eq_empty
Nullified-specialization non-vacuity receipt. The globally nonzero polynomial X₁ specializes identically to zero in the first lifting coordinate over a base point with X₁ = 0, so it contributes no roots there. This is the two-variable counterexample that a merely global P ≠ 0 guard failed to exclude.
Formal statement
Proof (Lean source)
theorem cadRealRootsAt_singleton_other_variable_eq_empty (a : Fin 2 → ℝ) (ha : a 1 = 0) :
cadRealRootsAt (0 : Fin 2) ({X 1} : Finset (MvPolynomial (Fin 2) ℝ)) a = ∅ := by
apply cadRealRootsAt_eq_empty_of_specializes_zero
intro P hP z
have hP' : P = X (1 : Fin 2) := by simpa using hP
subst P
simp [update, ha]
An indexed continuous real-algebraic section of the projection family. rootIndex is its zero-based position in the ordered set of real roots at every point of the recursively lifted base, so an ordinary selected root of a polynomial with several real roots is permitted; no uniqueness hypothesis is made.
Definition (Lean source)
def IsCADAlgebraicRoot {σ : Type} [DecidableEq σ] (x : σ) (base : Set (σ → ℝ)) (rootIndex : ℕ)
(root : (σ → ℝ) → ℝ) (family : Finset (MvPolynomial σ ℝ)) : Prop :=
ContinuousOn root base ∧
∀ a ∈ base,
(cadRealRootsAt x family a).Finite ∧
root a ∈ cadRealRootsAt x family a ∧
ncard { z ∈ cadRealRootsAt x family a | z < root a } = rootIndex
The selected section is the greatest root in the complete ordered root stack — the boundary of the upper-unbounded sector.
Definition (Lean source)
def IsCADLastAlgebraicRoot {σ : Type} [DecidableEq σ] (x : σ) (base : Set (σ → ℝ)) (rootIndex : ℕ)
(root : (σ → ℝ) → ℝ) (family : Finset (MvPolynomial σ ℝ)) : Prop :=
IsCADAlgebraicRoot x base rootIndex root family ∧
∀ a ∈ base, ∀ z ∈ cadRealRootsAt x family a, z ≤ root a
def IsRecursivelyLiftedCADCell
Recursive cylindrical section/sector geometry in the declared variable order — the output of the section/sector lifting of BPR Def. 5.1 + Thm 5.16. Over a cell of the base decomposition the polynomials of the stage family have finitely many real roots ξ_1 < … < ξ_ℓ in the lifting coordinate, and the cells above it are exactly: the whole fibre when ℓ = 0; otherwise the graph of an indexed root (a section), the sector below the first root, a sector between two consecutive indexed roots, or the sector above the last root.
Definition (Lean source)
def IsRecursivelyLiftedCADCell {σ : Type} [DecidableEq σ] :
Finset (MvPolynomial σ ℝ) → List σ → Set (σ → ℝ) → Prop
| _, [], cell => cell = { a | ∀ x, a x = 0 }
| family, x :: xs, cell =>
∃ base, IsRecursivelyLiftedCADCell (cadProjectionStep x family) xs base ∧
(((∀ a ∈ base, cadRealRootsAt x family a = ∅) ∧
cell = { a | cadEraseCoordinate x a ∈ base }) ∨
(∃ rootIndex root, IsCADAlgebraicRoot x base rootIndex root family ∧
cell = { a | cadEraseCoordinate x a ∈ base ∧
a x = root (cadEraseCoordinate x a) }) ∨
(∃ upper, IsCADAlgebraicRoot x base 0 upper family ∧
cell = { a | cadEraseCoordinate x a ∈ base ∧
a x < upper (cadEraseCoordinate x a) }) ∨
(∃ lowerIndex lower upper,
IsCADAlgebraicRoot x base lowerIndex lower family ∧
IsCADAlgebraicRoot x base (lowerIndex + 1) upper family ∧
(∀ a ∈ base, lower a < upper a) ∧
cell = { a | cadEraseCoordinate x a ∈ base ∧
lower (cadEraseCoordinate x a) < a x ∧
a x < upper (cadEraseCoordinate x a) }) ∨
(∃ lowerIndex lower, IsCADLastAlgebraicRoot x base lowerIndex lower family ∧
cell = { a | cadEraseCoordinate x a ∈ base ∧
lower (cadEraseCoordinate x a) < a x }))
theorem isRecursivelyLiftedCADCell_univ_of_empty
Non-vacuity receipt. With the empty family in one variable the cited theorem supplies the single cell ℝ, and the cell language now contains it: this is exactly the point at which the earlier encoding (no ℓ = 0 case, one fully projected family at every stage) was unsatisfiable, which would have made the cited Prop False.
Formal statement
conclusion
Proof (Lean source)
theorem isRecursivelyLiftedCADCell_univ_of_empty :
IsRecursivelyLiftedCADCell (∅ : Finset (MvPolynomial (Fin 1) ℝ)) [0] univ := by
refine ⟨{ a | ∀ x, a x = 0 }, rfl, inl ⟨?_, ?_⟩⟩
· intro a _
simp [cadRealRootsAt]
· ext a
have hmem : cadEraseCoordinate (0 : Fin 1) a ∈ { b : Fin 1 → ℝ | ∀ x, b x = 0 } := by
intro x
fin_cases x
simp [cadEraseCoordinate]
simp [hmem]
simp [cadEraseCoordinate]
theorem isRecursivelyLiftedCADCell_univ_of_singleton_zero
Singleton-zero non-vacuity receipt. The identically zero polynomial contributes no section roots, so the one-variable CAD for the family {0} consists of the same root-free whole-fibre cell as the empty-family decomposition. This rules out the former counterexample in which {0} made the root stack equal to all of ℝ.
Formal statement
conclusion
Proof (Lean source)
theorem isRecursivelyLiftedCADCell_univ_of_singleton_zero :
IsRecursivelyLiftedCADCell ({0} : Finset (MvPolynomial (Fin 1) ℝ)) [0] univ := by
refine ⟨{ a | ∀ x, a x = 0 }, rfl, inl ⟨?_, ?_⟩⟩
· intro a _
apply cadRealRootsAt_eq_empty_of_specializes_zero
simp
· ext a
have hmem : cadEraseCoordinate (0 : Fin 1) a ∈ { b : Fin 1 → ℝ | ∀ x, b x = 0 } := by
intro x
fin_cases x
simp [cadEraseCoordinate]
simp [hmem]
simp [cadEraseCoordinate]
def cadOrderTruncate
Project onto the coordinates still live at a given depth of the lifting order: every coordinate outside live is zeroed.
Definition (Lean source)
def cadOrderTruncate {σ : Type} [DecidableEq σ] (live : List σ) (a : σ → ℝ) : σ → ℝ :=
fun i => if i ∈ live then a i else 0
Cylindrical arrangement (the cylindricity condition of BPR Def. 5.1), relative to the lifting order. At every depth k of the order, the projections of any two cells onto the coordinates still live there (order.drop k) are either identical or disjoint — i.e. the cells are stacked in cylinders over the cells of the induced decomposition of every stage.
Definition (Lean source)
def IsCylindricallyArranged {σ : Type} [DecidableEq σ] {ι : Type}
(order : List σ) (cell : ι → Set (σ → ℝ)) : Prop :=
∀ (k : ℕ) (i j : ι),
cadOrderTruncate (order.drop k) '' cell i = cadOrderTruncate (order.drop k) '' cell j ∨
Disjoint (cadOrderTruncate (order.drop k) '' cell i)
(cadOrderTruncate (order.drop k) '' cell j)
The polynomial P has constant sign on S.
Definition (Lean source)
def HasConstantSignOn {r : ℕ} (S : Set (CADSpace r)) (P : MvPolynomial (Fin r) ℝ) : Prop :=
∀ x ∈ S, ∀ y ∈ S,
polynomialSign (eval x P) = polynomialSign (eval y P)
def signConditionSet
The solution set of a finite system of polynomial sign conditions.
Definition (Lean source)
def signConditionSet {r : ℕ} (equations nonnegative positive : Finset (MvPolynomial (Fin r) ℝ)) :
Set (CADSpace r) :=
{ x | (∀ P ∈ equations, eval x P = 0) ∧
(∀ P ∈ nonnegative, 0 ≤ eval x P) ∧
(∀ P ∈ positive, 0 < eval x P) }
A cylindrical algebraic decomposition adapted to the finite family A in the variable order order (BPR Def. 5.1 + Def. 5.5): finitely many nonempty, pairwise disjoint, cylindrically arranged semialgebraic cells covering ℝ^r, obtained by recursive lifting of the generated projection family, on each of which every polynomial of A and of the projection family has constant sign, and which therefore decide every sign condition built from A.
Definition (Lean source)
parameters
fields
The decomposition has finitely many cells.
finite_cells :
Finite ι
Every cell is nonempty.
nonempty_cell :
∀ i, (cell i).Nonempty
Every cell is a basic semialgebraic set.
semialgebraic_cell :
∀ i, IsBasicSemialgebraic (cell i)
Distinct cells are disjoint.
The cells cover the whole space.
covers :
(⋃ i, cell i) = univ
The cells are cylindrically arranged in the coordinate order.
cylindrical :
IsCylindricallyArranged order cell
**Projection.** Every polynomial of the input family *and* of the family the projection
operator generates from it has constant sign on every cell (BPR Notation 5.15 + Thm 5.16).
sign_invariant :
∀ P ∈ A ∪ generatedCADProjectionFamily order A, ∀ i, HasConstantSignOn (cell i) P
**Section / sector lifting.** Every cell is a recursively lifted section/sector cell, in the
declared variable order (BPR Def. 5.1 + Thm 5.16). The recursion starts from the *input* family
`A` and projects it (`cadProjectionStep`) on each descent, so each stage is decomposed by the
family that still involves that stage's lifting variable — BPR's `C_i(A)`.
recursively_lifted :
∀ i, IsRecursivelyLiftedCADCell A order (cell i)
**Decision.** Every polynomial sign condition built from `A` is decided by the cell: each cell
is either contained in the condition's solution set or disjoint from it, so the condition's truth
value is read off the cell's sign vector, and the solution set is a union of cells.
decides :
if
and
and
then
∀ i,
cell i ⊆ signConditionSet equations nonnegative positive ∨ Disjoint (cell i) (signConditionSet equations nonnegative positive)
theorem isAdaptedCAD_univ_of_empty
Non-vacuity of the whole IsAdaptedCAD record. At the trivial instance the cited theorem supplies the single cell ℝ, and every field of the record is satisfied by it simultaneously.
Formal statement
conclusion
Proof (Lean source)
theorem isAdaptedCAD_univ_of_empty :
IsAdaptedCAD (∅ : Finset (MvPolynomial (Fin 1) ℝ)) [0] (fun _ : Unit => univ) where
finite_cells := inferInstance
nonempty_cell := fun _ => Set.univ_nonempty
semialgebraic_cell := fun _ => ⟨∅, ∅, ∅, by ext a; simp⟩
disjoint_cells := by
intro i j hij
exact absurd (Subsingleton.elim i j) hij
covers := Set.iUnion_const _
cylindrical := fun _ _ _ => inl rfl
sign_invariant := by
intro P hP
simp [generatedCADProjectionFamily, cadProjectionStep, cadCoefficients, cadDiscriminants,
cadPrincipalSubresultants, cadDerivativePrincipalSubresultants,
cadPairPrincipalSubresultants, cadReductaFamily] at hP
recursively_lifted := fun _ => isRecursivelyLiftedCADCell_univ_of_empty
decides := by
intro equations nonnegative positive he hn hp _
refine inl ?_
intro a _
refine ⟨fun P hPmem => ?_, fun P hPmem => ?_, fun P hPmem => ?_⟩
· exact absurd (he hPmem) (by simp)
· exact absurd (hn hPmem) (by simp)
· exact absurd (hp hPmem) (by simp)
theorem isAdaptedCAD_univ_of_singleton_zero
Non-vacuity of the full adapted-CAD record for {0}. Ignoring an identically zero polynomial in the lifting root stack is compatible with every other field of IsAdaptedCAD: the single cell ℝ is semialgebraic, cylindrical, sign-invariant for the generated family, recursively root-free, and decides every sign condition built from {0}.
Formal statement
conclusion
Proof (Lean source)
theorem isAdaptedCAD_univ_of_singleton_zero :
IsAdaptedCAD ({0} : Finset (MvPolynomial (Fin 1) ℝ)) [0] (fun _ : Unit => univ) where
finite_cells := inferInstance
nonempty_cell := fun _ => Set.univ_nonempty
semialgebraic_cell := fun _ => ⟨∅, ∅, ∅, by ext a; simp⟩
disjoint_cells := by
intro i j hij
exact absurd (Subsingleton.elim i j) hij
covers := Set.iUnion_const _
cylindrical := fun _ _ _ => inl rfl
sign_invariant := by
intro P hP _
simp [generatedCADProjectionFamily, cadProjectionStep, cadCoefficients, cadDiscriminants,
cadPrincipalSubresultants, cadDerivativePrincipalSubresultants,
cadPairPrincipalSubresultants, cadReductaFamily, cadAsUnivariate] at hP
subst P
simp [HasConstantSignOn]
recursively_lifted := fun _ => isRecursivelyLiftedCADCell_univ_of_singleton_zero
decides := by
intro equations nonnegative positive he hn hp _
by_cases hzero : (0 : MvPolynomial (Fin 1) ℝ) ∈ positive
· refine inr (Set.disjoint_left.2 ?_)
intro a _ ha
have hpositive := ha.2.2 0 hzero
simpa using hpositive
· refine inl ?_
intro a _
refine ⟨?_, ?_, ?_⟩
· intro P hPmem
have hPzero : P = 0 := by simpa using he hPmem
subst P
simp
· intro P hPmem
have hPzero : P = 0 := by simpa using hn hPmem
subst P
simp
· intro P hPmem
have hPzero : P = 0 := by simpa using hp hPmem
exact (hzero (hPzero ▸ hPmem)).elim
Cylindrical algebraic decomposition adapted to a finite polynomial family — BPR Thm 5.6 (with Def. 5.1, Def. 5.5, Notation 5.15, Thm 5.16); BCR §2.3.
Definition (Lean source)
def AdaptedCADConstruction : Prop :=
∀ (r : ℕ) (A : Finset (MvPolynomial (Fin r) ℝ)) (order : List (Fin r)),
order.Nodup → (∀ x : Fin r, x ∈ order) →
∃ (ι : Type) (cell : ι → Set (CADSpace r)), IsAdaptedCAD A order cell
Tarski–Seidenberg projection theorem — BCR Thm 2.2.1; BPR Ch. 2 (Projection Theorem for Semi-Algebraic Sets).
Definition (Lean source)
def TarskiSeidenbergProjection : Prop :=
∀ (r : ℕ) (S : Set (CADSpace (r + 1))),
IsSemialgebraicSet S →
IsSemialgebraicSet { x : CADSpace r | ∃ z : ℝ, (Fin.snoc x z : CADSpace (r + 1)) ∈ S }
The cited external real-closed-field interface in full (cite:bcr-bpr-cad): the cylindrical algebraic decomposition adapted to an arbitrary finite real-polynomial family (BPR Thm 5.6; BCR §2.3), together with the Tarski–Seidenberg projection theorem (BCR Thm 2.2.1). Both conjuncts are general theorems about arbitrary finite real-polynomial families in arbitrary dimension; neither mentions this paper's objects, and neither asserts effectivity.
Definition (Lean source)
def RealClosedFieldCADInterface : Prop :=
AdaptedCADConstruction ∧ TarskiSeidenbergProjection
Helpers.CAD.EffectiveRationalGroebnerCADInterface 172 declarations
def rationalPolynomialDecidableEq
Provides a procedure that decides whether two values of this data type are equal.
Definition (Lean source)
local instance rationalPolynomialDecidableEq (r : ℕ) :
DecidableEq (MvPolynomial (Fin r) ℚ) := Classical.decEq _
def realPolynomialDecidableEq
Provides a procedure that decides whether two values of this data type are equal.
Definition (Lean source)
local instance realPolynomialDecidableEq (r : ℕ) :
DecidableEq (MvPolynomial (Fin r) ℝ) := Classical.decEq _
Finite rational syntax for a multivariate polynomial.
Definition (Lean source)
structure EffectivePolynomialCode (r : ℕ) where
terms : List (ℚ × List (Fin r × ℕ))
deriving Encodable
instance instEncodableEffectivePolynomialCode
Every finite syntactic code for a multivariate polynomial with rational coefficients has an effective numerical encoding and decoding, so such codes can be listed one by one.
Definition (Lean source)
deriving Encodable
def toPolynomial
Interpretation of rational polynomial syntax.
Definition (Lean source)
def EffectivePolynomialCode.toPolynomial {r : ℕ} (code : EffectivePolynomialCode r) :
MvPolynomial (Fin r) ℚ :=
code.terms.foldl (fun P term =>
P + monomial
(term.2.foldl (fun exponents xe => exponents + Finsupp.single xe.1 xe.2) 0)
term.1) 0
def effectiveZeroPolynomialCode
Canonical code for the zero polynomial.
Definition (Lean source)
def effectiveZeroPolynomialCode (r : ℕ) : EffectivePolynomialCode r :=
⟨[]⟩
def effectiveOnePolynomialCode
Canonical code for the constant polynomial one.
Definition (Lean source)
def effectiveOnePolynomialCode (r : ℕ) : EffectivePolynomialCode r :=
⟨[(1, [])]⟩
def effectiveVariablePolynomialCode
Canonical code for one coordinate variable.
Definition (Lean source)
def effectiveVariablePolynomialCode {r : ℕ} (i : Fin r) : EffectivePolynomialCode r :=
⟨[(1, [(i, 1)])]⟩
def effectiveCanonicalPolynomialPool
The fixed finite machine substrate containing 0, 1, and every coordinate variable. These codes are available to primitive arithmetic, but are not registered as algorithm input families.
Definition (Lean source)
def effectiveCanonicalPolynomialPool (r : ℕ) : List (EffectivePolynomialCode r) :=
effectiveZeroPolynomialCode r :: effectiveOnePolynomialCode r ::
List.ofFn effectiveVariablePolynomialCode
theorem effectiveZeroPolynomialCode_toPolynomial
The canonical code for zero denotes the zero polynomial.
Formal statement
Proof (Lean source)
@[simp] theorem effectiveZeroPolynomialCode_toPolynomial (r : ℕ) :
(effectiveZeroPolynomialCode r).toPolynomial = 0 := by
simp [effectiveZeroPolynomialCode, EffectivePolynomialCode.toPolynomial]
theorem effectiveOnePolynomialCode_toPolynomial
The canonical code for one denotes the constant polynomial one.
Formal statement
Proof (Lean source)
@[simp] theorem effectiveOnePolynomialCode_toPolynomial (r : ℕ) :
(effectiveOnePolynomialCode r).toPolynomial = 1 := by
simp [effectiveOnePolynomialCode, EffectivePolynomialCode.toPolynomial]
theorem effectiveVariablePolynomialCode_toPolynomial
The canonical code for a coordinate variable denotes exactly that coordinate variable.
Formal statement
Proof (Lean source)
@[simp] theorem effectiveVariablePolynomialCode_toPolynomial {r : ℕ} (i : Fin r) :
(effectiveVariablePolynomialCode i).toPolynomial = X i := by
simp [effectiveVariablePolynomialCode, EffectivePolynomialCode.toPolynomial,
X]
A displayed list of rational codes realizes exactly a finite polynomial family.
Definition (Lean source)
def EffectivePolynomialCodesRealize {r : ℕ} (codes : List (EffectivePolynomialCode r))
(family : Finset (MvPolynomial (Fin r) ℚ)) : Prop :=
codes.Nodup ∧ (codes.map EffectivePolynomialCode.toPolynomial).toFinset = family
def GaussianRational
The Gaussian rational field ℚ(i), presented by the relation i² = -1.
Definition (Lean source)
abbrev GaussianRational := QuadraticAlgebra ℚ (-1) 0
theorem gaussianRationalIrreducible
No rational number satisfies the defining quadratic relation of the adjoined imaginary unit, that is, no rational number squares to minus one. Registering this fact is what makes the presented quadratic extension of the rationals a field.
Formal statement
Fact (∀ (q : ℚ), q ^ 2 ≠ -1 + 0 * q)
def gaussianRationalEncodable
The Gaussian rationals have an effective numerical encoding and decoding, obtained from the pair consisting of their rational real and imaginary parts.
Definition (Lean source)
noncomputable local instance gaussianRationalEncodable : Encodable GaussianRational :=
Encodable.ofEquiv (ℚ × ℚ) (QuadraticAlgebra.equivProd (-1) 0)
Finite syntax for a polynomial over an arbitrary encodable coefficient field. This is used only by the paper-independent Gröbner interface; the real CAD specialization below remains over ℚ, as required by the cited algorithms.
Definition (Lean source)
structure EffectivePolynomialCodeOver (K : Type) (r : ℕ) where
terms : List (K × List (Fin r × ℕ))
deriving Encodable
instance instEncodableEffectivePolynomialCodeOver
Every finite syntactic code for a polynomial over an effectively encodable coefficient field has an effective numerical encoding and decoding, obtained from the encoding of the coefficients.
Definition (Lean source)
deriving Encodable
def toPolynomial
Interpretation of finite polynomial syntax over its coefficient field.
Definition (Lean source)
def EffectivePolynomialCodeOver.toPolynomial {K : Type} [Field K] {r : ℕ}
(code : EffectivePolynomialCodeOver K r) : MvPolynomial (Fin r) K :=
code.terms.foldl (fun P term =>
P + monomial
(term.2.foldl (fun exponents xe => exponents + Finsupp.single xe.1 xe.2) 0)
term.1) 0
def EffectivePolynomialCodesRealizeOver Definition aux_EffectivePolynomialCodesRealizeOver in the paper ↗
A displayed list of coefficient-field codes realizes exactly a finite polynomial family.
Definition (Lean source)
def EffectivePolynomialCodesRealizeOver {K : Type} [Field K] [DecidableEq K] {r : ℕ}
(codes : List (EffectivePolynomialCodeOver K r))
(family : Finset (MvPolynomial (Fin r) K)) : Prop :=
codes.Nodup ∧
(codes.map EffectivePolynomialCodeOver.toPolynomial).toFinset = family
A finite, machine-readable presentation of a supplied semantic monomial order. The comparison program is part of the input to the uniform Buchberger machine; Realizes below prevents an arbitrary code from being passed off as the requested order.
Definition (Lean source)
instance instEncodableEffectiveMonomialOrderCode
Every finite machine presentation of a monomial order has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
def Realizes
Exact total comparison semantics for a finite presentation of a monomial order. Terminating comparison is required on every pair of exponents, and the Boolean answer is exactly strict comparison in the supplied admissible Mathlib MonomialOrder.
Definition (Lean source)
def EffectiveMonomialOrderCode.Realizes {r : ℕ} (code : EffectiveMonomialOrderCode r)
(monomialOrder : MonomialOrder.{0, 0} (Fin r)) : Prop :=
∀ left right : Fin r →₀ ℕ, ∃ fuel : ℕ,
code.comparison.evaln fuel (Encodable.encode (left, right)) =
some (Encodable.encode (decide
(monomialOrder.toSyn left < monomialOrder.toSyn right)))
A polynomial over K uses only the retained variables of an elimination block.
Definition (Lean source)
def UsesOnlyEffectiveVariablesOver {K : Type} [Field K] {r : ℕ}
(keep : Finset (Fin r)) (P : MvPolynomial (Fin r) K) : Prop :=
P.vars ⊆ keep
def IsEffectiveEliminationMonomialOrder Definition aux_IsEffectiveEliminationMonomialOrder in the paper ↗
An admissible monomial order is an elimination order for keep when every monomial using an eliminated variable is strictly larger than every monomial supported on keep. This is a condition on the supplied order, not a claim that every MonomialOrder is an elimination order.
Definition (Lean source)
def IsEffectiveEliminationMonomialOrder {r : ℕ}
(monomialOrder : MonomialOrder.{0, 0} (Fin r)) (keep : Finset (Fin r)) : Prop :=
∀ eliminated retained : Fin r →₀ ℕ,
retained.support ⊆ keep → ¬eliminated.support ⊆ keep →
monomialOrder.toSyn retained < monomialOrder.toSyn eliminated
def StandardFiniteBlockEliminationOrderInterface Definition aux_StandardFiniteBlockEliminationOrderInterface in the paper ↗
The standard finite block-elimination order is effectively presentable for every concrete retained coordinate block. This is an existence statement for the cited construction's canonical block order, not the false assertion that every abstract MonomialOrder is effectively presentable.
Definition (Lean source)
def StandardFiniteBlockEliminationOrderInterface : Prop :=
∀ (r : ℕ) (keep : Finset (Fin r)),
∃ monomialOrder : MonomialOrder.{0, 0} (Fin r),
∃ suppliedOrder : EffectiveMonomialOrderCode r,
suppliedOrder.Realizes monomialOrder ∧
IsEffectiveEliminationMonomialOrder monomialOrder keep
def IsExactGroebnerBasisForMonomialOrder Definition aux_IsExactGroebnerBasisForMonomialOrder in the paper ↗
Exact Gröbner-basis semantics for an arbitrary admissible monomial order. Mathlib's MonomialOrder already packages well-foundedness, compatibility with addition, and 0 as the least monomial, so no lexicographic restriction is hidden in this interface.
Definition (Lean source)
def IsExactGroebnerBasisForMonomialOrder {K : Type} [Field K] [DecidableEq K] {r : ℕ}
(monomialOrder : MonomialOrder.{0, 0} (Fin r))
(input basis : Finset (MvPolynomial (Fin r) K))
(normalForm : MvPolynomial (Fin r) K → MvPolynomial (Fin r) K) : Prop :=
(∀ G ∈ basis, G ≠ 0) ∧
span (input : Set (MvPolynomial (Fin r) K)) =
span (basis : Set (MvPolynomial (Fin r) K)) ∧
(∀ P ∈ span (input : Set (MvPolynomial (Fin r) K)), P ≠ 0 →
∃ G ∈ basis, G ≠ 0 ∧ monomialOrder.degree G ≤ monomialOrder.degree P) ∧
∀ P,
(normalForm P = 0 ↔ P ∈ span (input : Set (MvPolynomial (Fin r) K))) ∧
∃ quotients : basis → MvPolynomial (Fin r) K,
P = normalForm P + ∑ Q : basis, quotients Q * Q.1 ∧
∀ exponent ∈ (normalForm P).support, ∀ G ∈ basis,
¬monomialOrder.degree G ≤ exponent
Exact elimination-ideal output over an arbitrary coefficient field. Its use with the Gröbner output below is conditional on the supplied monomial order satisfying IsEffectiveEliminationMonomialOrder.
Definition (Lean source)
def IsExactEliminationBasisOver {K : Type} [Field K] [DecidableEq K] {r : ℕ}
(input : Finset (MvPolynomial (Fin r) K)) (keep : Finset (Fin r))
(output : Finset (MvPolynomial (Fin r) K)) : Prop :=
(∀ P ∈ output, UsesOnlyEffectiveVariablesOver keep P) ∧
∀ P, UsesOnlyEffectiveVariablesOver keep P →
(P ∈ span (output : Set (MvPolynomial (Fin r) K)) ↔
P ∈ span (input : Set (MvPolynomial (Fin r) K)))
def IsExactIdealIntersectionBasisOver Definition aux_IsExactIdealIntersectionBasisOver in the paper ↗
Exact ideal-intersection output over an arbitrary coefficient field.
Definition (Lean source)
def IsExactIdealIntersectionBasisOver {K : Type} [Field K] [DecidableEq K] {r : ℕ}
(left right output : Finset (MvPolynomial (Fin r) K)) : Prop :=
span (output : Set (MvPolynomial (Fin r) K)) =
span (left : Set (MvPolynomial (Fin r) K)) ⊓
span (right : Set (MvPolynomial (Fin r) K))
Exact saturation output over an arbitrary coefficient field, characterized by membership after multiplication by a power of the saturating polynomial.
Definition (Lean source)
def IsExactSaturationBasisOver {K : Type} [Field K] [DecidableEq K] {r : ℕ}
(input : Finset (MvPolynomial (Fin r) K))
(saturating : MvPolynomial (Fin r) K)
(output : Finset (MvPolynomial (Fin r) K)) : Prop :=
∀ P, P ∈ span (output : Set (MvPolynomial (Fin r) K)) ↔
∃ k : ℕ, saturating ^ k * P ∈ span (input : Set (MvPolynomial (Fin r) K))
inductive EffectiveGroebnerTraceOperation
High-level stages in a coefficient-polymorphic exact algebra trace.
Definition (Lean source)
inductive EffectiveGroebnerTraceOperation
| buchberger
| elimination
| idealIntersection
| saturation
deriving DecidableEq, Encodable
instance instDecidableEqEffectiveGroebnerTraceOperation
Provides a procedure that decides whether two high-level stages of a coefficient-polymorphic exact algebra trace are equal.
Definition (Lean source)
deriving DecidableEq, Encodable
instance instEncodableEffectiveGroebnerTraceOperation
Every high-level stage of a coefficient-polymorphic exact algebra trace has an effective numerical encoding and decoding.
Definition (Lean source)
deriving DecidableEq, Encodable
inductive EffectiveGroebnerPrimitiveOperation
Primitive charged field operations used by the exact algebra trace.
Definition (Lean source)
inductive EffectiveGroebnerPrimitiveOperation
| coefficientAddition
| coefficientMultiplication
| coefficientInversion
deriving DecidableEq, Encodable
instance instDecidableEqEffectiveGroebnerPrimitiveOperation
Provides a procedure that decides whether two primitive charged field operations of the exact algebra trace are equal.
Definition (Lean source)
deriving DecidableEq, Encodable
instance instEncodableEffectiveGroebnerPrimitiveOperation
Every primitive charged field operation used by the exact algebra trace has an effective numerical encoding and decoding.
Definition (Lean source)
deriving DecidableEq, Encodable
One state of a continuous coefficient-polymorphic symbolic execution.
Definition (Lean source)
parameters
K :
Type
r :
ℕ
fields
polynomialPool :
familyRegisters :
def AvailableIn
Extensional availability of a coefficient-field polynomial code in the computed pool.
Definition (Lean source)
def EffectivePolynomialCodeOver.AvailableIn {K : Type} [Field K] {r : ℕ}
(required : EffectivePolynomialCodeOver K r)
(pool : List (EffectivePolynomialCodeOver K r)) : Prop :=
∃ computed ∈ pool, computed.toPolynomial = required.toPolynomial
def EffectiveGroebnerPrimitiveTransition
Exact transition semantics for one charged field operation.
Definition (Lean source)
def EffectiveGroebnerPrimitiveTransition {K : Type} [Field K] {r : ℕ} :
EffectiveGroebnerPrimitiveOperation → EffectiveGroebnerMachineState K r →
EffectiveGroebnerMachineState K r → Prop
| .coefficientAddition, before, after =>
∃ left ∈ before.polynomialPool, ∃ right ∈ before.polynomialPool, ∃ result,
result.toPolynomial = left.toPolynomial + right.toPolynomial ∧
after = { before with polynomialPool := before.polynomialPool ++ [result] }
| .coefficientMultiplication, before, after =>
∃ left ∈ before.polynomialPool, ∃ right ∈ before.polynomialPool, ∃ result,
result.toPolynomial = left.toPolynomial * right.toPolynomial ∧
after = { before with polynomialPool := before.polynomialPool ++ [result] }
| .coefficientInversion, before, after =>
∃ source ∈ before.polynomialPool, ∃ exponent,
source.toPolynomial.coeff exponent ≠ 0 ∧ ∃ result,
result.toPolynomial =
C (source.toPolynomial.coeff exponent)⁻¹ * source.toPolynomial ∧
after = { before with polynomialPool := before.polynomialPool ++ [result] }
def EffectiveGroebnerPrimitiveProgramRuns
Continuous execution of a list of charged coefficient-field operations.
Definition (Lean source)
def EffectiveGroebnerPrimitiveProgramRuns {K : Type} [Field K] {r : ℕ} :
List EffectiveGroebnerPrimitiveOperation → EffectiveGroebnerMachineState K r →
EffectiveGroebnerMachineState K r → Prop
| [], initial, final => final = initial
| operation :: operations, initial, final =>
∃ next, EffectiveGroebnerPrimitiveTransition operation initial next ∧
EffectiveGroebnerPrimitiveProgramRuns operations next final
One supplied-input high-level algebra step and its exact charged primitive program.
Definition (Lean source)
structure EffectiveGroebnerTraceStep (K : Type) (r : ℕ) where
operation : EffectiveGroebnerTraceOperation
inputFamilies : List (List (EffectivePolynomialCodeOver K r))
outputFamilies : List (List (EffectivePolynomialCodeOver K r))
primitiveOperations : List EffectiveGroebnerPrimitiveOperation
deriving Encodable
instance instEncodableEffectiveGroebnerTraceStep
Every high-level algebra step, together with its supplied input families, its displayed output families, and its charged primitive program, has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
def operationCount
Exact operation count of a coefficient-polymorphic trace step.
Definition (Lean source)
def EffectiveGroebnerTraceStep.operationCount {K : Type} {r : ℕ}
(step : EffectiveGroebnerTraceStep K r) : ℕ :=
step.primitiveOperations.length
def EffectiveGroebnerFamilyAvailable
Extensional availability of a displayed family register.
Definition (Lean source)
def EffectiveGroebnerFamilyAvailable {K : Type} [Field K] [DecidableEq K] {r : ℕ}
(required : List (EffectivePolynomialCodeOver K r))
(registers : List (List (EffectivePolynomialCodeOver K r))) : Prop :=
∃ registered ∈ registers,
(registered.map EffectivePolynomialCodeOver.toPolynomial).toFinset =
(required.map EffectivePolynomialCodeOver.toPolynomial).toFinset
def Runs
A high-level algebra step consumes only registered families and computes every displayed output during this step's charged suffix, before registering those outputs for later steps.
Definition (Lean source)
def EffectiveGroebnerTraceStep.Runs {K : Type} [Field K] [DecidableEq K] {r : ℕ}
(step : EffectiveGroebnerTraceStep K r)
(before after : EffectiveGroebnerMachineState K r) : Prop :=
(∀ family ∈ step.inputFamilies,
EffectiveGroebnerFamilyAvailable family before.familyRegisters) ∧
∃ primitiveFinal,
EffectiveGroebnerPrimitiveProgramRuns step.primitiveOperations before primitiveFinal ∧
(∀ output ∈ step.outputFamilies.flatten,
output.AvailableIn
(primitiveFinal.polynomialPool.drop before.polynomialPool.length)) ∧
after = { primitiveFinal with
familyRegisters := before.familyRegisters ++ step.outputFamilies }
def EffectiveGroebnerTraceRuns
The complete coefficient-polymorphic trace is one continuous execution; no step is reset with a fresh polynomial pool.
Definition (Lean source)
def EffectiveGroebnerTraceRuns {K : Type} [Field K] [DecidableEq K] {r : ℕ} :
List (EffectiveGroebnerTraceStep K r) → EffectiveGroebnerMachineState K r →
EffectiveGroebnerMachineState K r → Prop
| [], initial, final => final = initial
| step :: steps, initial, final =>
∃ next, step.Runs initial next ∧ EffectiveGroebnerTraceRuns steps next final
def effectiveGroebnerCanonicalPolynomialPool
Canonical zero, one, negative one, and coordinate-variable codes available before every coefficient-polymorphic algebra run. The -1 code makes exact negation and subtraction expressible by the charged multiplication transition.
Definition (Lean source)
def effectiveGroebnerCanonicalPolynomialPool (K : Type) [Field K] (r : ℕ) :
List (EffectivePolynomialCodeOver K r) :=
⟨[]⟩ :: ⟨[(1, [])]⟩ :: ⟨[(-1, [])]⟩ ::
List.ofFn fun i : Fin r => ⟨[(1, [(i, 1)])]⟩
Finite machine output for one Gröbner computation over an encodable coefficient field. Its input presentation fields are required below to equal the presentations supplied before the output existential.
Definition (Lean source)
structure EffectiveGroebnerPayloadOver (K : Type) (r : ℕ) where
input : List (EffectivePolynomialCodeOver K r)
secondInput : List (EffectivePolynomialCodeOver K r)
saturatingPolynomial : EffectivePolynomialCodeOver K r
groebnerBasis : List (EffectivePolynomialCodeOver K r)
eliminationBasis : List (EffectivePolynomialCodeOver K r)
intersectionBasis : List (EffectivePolynomialCodeOver K r)
saturationBasis : List (EffectivePolynomialCodeOver K r)
saturatedGroebnerBasis : List (EffectivePolynomialCodeOver K r)
saturatedEliminationBasis : List (EffectivePolynomialCodeOver K r)
trace : List (EffectiveGroebnerTraceStep K r)
deriving Encodable
instance instEncodableEffectiveGroebnerPayloadOver
Every finite machine output of one Gröbner computation over an effectively encodable coefficient field — its input presentations, its computed bases, and its trace — has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
def symbolicOperationCount
The exact charged operation count is definitionally the length sum of the continuous coefficient-polymorphic execution.
Definition (Lean source)
def EffectiveGroebnerPayloadOver.symbolicOperationCount {K : Type} {r : ℕ}
(payload : EffectiveGroebnerPayloadOver K r) : ℕ :=
(payload.trace.map EffectiveGroebnerTraceStep.operationCount).sum
A terminating exact Gröbner/elimination/intersection/saturation computation for one supplied finite presentation and one effectively supplied admissible monomial order.
Definition (Lean source)
parameters
K :
r :
ℕ
input secondInput :
monomialOrder :
MonomialOrder.{0, 0} (Fin r)
saturating :
MvPolynomial (Fin r) K
suppliedInput suppliedSecondInput :
suppliedSaturating :
suppliedOrder :
fields
groebnerBasis :
eliminationBasis :
intersectionBasis :
saturationBasis :
saturatedGroebnerBasis :
saturatedEliminationBasis :
normalForm :
saturatedNormalForm :
groebner_exact :
IsExactGroebnerBasisForMonomialOrder monomialOrder input groebnerBasis normalForm
elimination_exact :
IsEffectiveEliminationMonomialOrder monomialOrder keep → IsExactEliminationBasisOver input keep eliminationBasis
intersection_exact :
IsExactIdealIntersectionBasisOver input secondInput intersectionBasis
saturation_exact :
IsExactSaturationBasisOver input saturating saturationBasis
saturated_groebner_exact :
IsExactGroebnerBasisForMonomialOrder monomialOrder saturationBasis saturatedGroebnerBasis saturatedNormalForm
saturated_elimination_exact :
IsEffectiveEliminationMonomialOrder monomialOrder keep → IsExactEliminationBasisOver saturationBasis keep saturatedEliminationBasis
payload :
payload_uses_supplied_input :
payload.input = suppliedInput
payload_uses_supplied_second_input :
payload.secondInput = suppliedSecondInput
payload_uses_supplied_saturating :
payload.saturatingPolynomial = suppliedSaturating
encoded_input :
EffectivePolynomialCodesRealizeOver payload.input input
encoded_second_input :
EffectivePolynomialCodesRealizeOver payload.secondInput secondInput
encoded_saturating :
payload.saturatingPolynomial.toPolynomial = saturating
encoded_groebner :
EffectivePolynomialCodesRealizeOver payload.groebnerBasis groebnerBasis
encoded_elimination :
EffectivePolynomialCodesRealizeOver payload.eliminationBasis eliminationBasis
encoded_intersection :
EffectivePolynomialCodesRealizeOver payload.intersectionBasis intersectionBasis
encoded_saturation :
EffectivePolynomialCodesRealizeOver payload.saturationBasis saturationBasis
encoded_saturated_groebner :
EffectivePolynomialCodesRealizeOver payload.saturatedGroebnerBasis saturatedGroebnerBasis
encoded_saturated_elimination :
EffectivePolynomialCodesRealizeOver payload.saturatedEliminationBasis saturatedEliminationBasis
trace_buchberger :
∃ step ∈ payload.trace,
step.operation = .buchberger ∧
step.inputFamilies = [payload.input] ∧
step.outputFamilies = [payload.groebnerBasis]
trace_elimination :
∃ step ∈ payload.trace,
step.operation = .elimination ∧
step.inputFamilies = [payload.groebnerBasis] ∧
step.outputFamilies = [payload.eliminationBasis]
trace_intersection :
∃ step ∈ payload.trace,
step.operation = .idealIntersection ∧
step.inputFamilies = [payload.input, payload.secondInput] ∧
step.outputFamilies = [payload.intersectionBasis]
trace_saturation :
∃ step ∈ payload.trace,
step.operation = .saturation ∧
step.inputFamilies = [payload.input, [payload.saturatingPolynomial]] ∧
step.outputFamilies = [payload.saturationBasis]
trace_saturated_buchberger :
∃ step ∈ payload.trace,
step.operation = .buchberger ∧
step.inputFamilies = [payload.saturationBasis] ∧
step.outputFamilies = [payload.saturatedGroebnerBasis]
trace_saturated_elimination :
∃ step ∈ payload.trace,
step.operation = .elimination ∧
step.inputFamilies = [payload.saturatedGroebnerBasis] ∧
step.outputFamilies = [payload.saturatedEliminationBasis]
trace_execution_exact :
∃ finalState,
EffectiveGroebnerTraceRuns payload.trace ⟨effectiveGroebnerCanonicalPolynomialPool K r ++ payload.input ++ payload.secondInput ++ [payload.saturatingPolynomial], [payload.input, payload.secondInput, [payload.saturatingPolynomial]]⟩ finalState ∧
(∀ required ∈ payload.groebnerBasis ++ payload.eliminationBasis ++ payload.intersectionBasis ++ payload.saturationBasis ++ payload.saturatedGroebnerBasis ++ payload.saturatedEliminationBasis, required.AvailableIn finalState.polynomialPool) ∧
finalState.familyRegisters
= [payload.input, payload.secondInput, [payload.saturatingPolynomial]] ++ (payload.trace.flatMap fun step => step.outputFamilies)
trace_steps_nonempty :
∀ step ∈ payload.trace, step.primitiveOperations ≠ []
machineCode :
machineFuel :
ℕ
machine_halts :
machineCode.evaln machineFuel (Encodable.encode (r, suppliedOrder, suppliedInput, suppliedSecondInput, suppliedSaturating, suppliedRetainedVariables))
= some (Encodable.encode payload)
Buchberger's terminating exact algorithm and its standard elimination, ideal-intersection, and saturation constructions over every effectively supplied admissible monomial order. One machine code is fixed before the dimension, order presentation, or any polynomial presentation; the input code lists are supplied and realized before the output existential.
Definition (Lean source)
def EffectiveGroebnerAlgorithmOver (K : Type) [Field K] [DecidableEq K] [Encodable K] : Prop :=
∃ machineCode : Code,
∀ (r : ℕ) (monomialOrder : MonomialOrder.{0, 0} (Fin r))
(suppliedOrder : EffectiveMonomialOrderCode r)
(suppliedInput suppliedSecondInput : List (EffectivePolynomialCodeOver K r))
(suppliedSaturating : EffectivePolynomialCodeOver K r)
(suppliedRetainedVariables : List (Fin r))
(input secondInput : Finset (MvPolynomial (Fin r) K)) (keep : Finset (Fin r))
(saturating : MvPolynomial (Fin r) K),
suppliedOrder.Realizes monomialOrder →
EffectivePolynomialCodesRealizeOver suppliedInput input →
EffectivePolynomialCodesRealizeOver suppliedSecondInput secondInput →
suppliedSaturating.toPolynomial = saturating →
suppliedRetainedVariables.Nodup → suppliedRetainedVariables.toFinset = keep →
∃ result : EffectiveGroebnerResultOver input secondInput monomialOrder keep saturating
suppliedInput suppliedSecondInput suppliedSaturating suppliedOrder
suppliedRetainedVariables,
result.machineCode = machineCode
One fully supplied coefficient-field algebra job. All semantic input, presentation, and monomial-order obligations are fixed before its output is chosen.
Definition (Lean source)
parameters
K :
fields
r :
ℕ
monomialOrder :
MonomialOrder.{0, 0} (Fin r)
suppliedOrder :
suppliedInput :
suppliedSecondInput :
suppliedSaturating :
input :
secondInput :
saturating :
MvPolynomial (Fin r) K
order_realizes :
suppliedOrder.Realizes monomialOrder
input_realizes :
EffectivePolynomialCodesRealizeOver suppliedInput input
second_input_realizes :
EffectivePolynomialCodesRealizeOver suppliedSecondInput secondInput
saturating_realizes :
suppliedSaturating.toPolynomial = saturating
retained_nodup :
suppliedRetainedVariables.Nodup
retained_realizes :
suppliedRetainedVariables.toFinset = keep
def sourcePolynomialCount
Input size charged to one coefficient-field algebra job.
Definition (Lean source)
def EffectiveGroebnerJobOver.sourcePolynomialCount {K : Type} [Field K]
[DecidableEq K] (job : EffectiveGroebnerJobOver K) : ℕ :=
job.input.card + job.secondInput.card + 1
def DegreeBoundedBy
A uniform degree bound for one coefficient-field algebra job.
Definition (Lean source)
def EffectiveGroebnerJobOver.DegreeBoundedBy {K : Type} [Field K]
[DecidableEq K] (job : EffectiveGroebnerJobOver K) (D : ℕ) : Prop :=
∀ P ∈ job.input ∪ job.secondInput ∪ {job.saturating}, P.totalDegree ≤ D
def EffectivePolynomialFamilyDegreeBoundedBy
A common degree envelope for a concrete finite polynomial family. Unlike EffectiveGroebnerJobOver.DegreeBoundedBy, this predicate can be applied to families produced by a completed exact computation, after those outputs have been chosen.
Definition (Lean source)
def EffectivePolynomialFamilyDegreeBoundedBy {K : Type} [CommSemiring K] {r : ℕ}
(family : Finset (MvPolynomial (Fin r) K)) (D : ℕ) : Prop :=
∀ P ∈ family, P.totalDegree ≤ D
structure EffectiveGroebnerCompletedJobOver Definition aux_EffectiveGroebnerCompletedJobOver in the paper ↗
The exact output of one supplied algebra job, tied to a machine code fixed before every job in its batch.
Definition (Lean source)
parameters
fields
result :
EffectiveGroebnerResultOver job.input job.secondInput job.monomialOrder job.keep job.saturating job.suppliedInput job.suppliedSecondInput job.suppliedSaturating job.suppliedOrder job.suppliedRetainedVariables
machine_code_eq :
result.machineCode = machineCode
def effectiveRenameRationalFamily
Rename a finite rational polynomial family between two supplied finite coordinate presentations. The map is data: the dependent pipeline below does not silently identify the retained variables of two different jobs.
Definition (Lean source)
def effectiveRenameRationalFamily {r s : ℕ} (coordinateMap : Fin r → Fin s)
(family : Finset (MvPolynomial (Fin r) ℚ)) :
Finset (MvPolynomial (Fin s) ℚ) :=
family.image (rename coordinateMap)
structure EffectiveDependentRationalEliminationPipeline Definition aux_EffectiveDependentRationalEliminationPipeline in the paper ↗
A source-matched dependent rational-algebra execution. The two supplied incidence jobs run first. Only after their exact elimination outputs exist is the intersection job supplied, and its two semantic inputs are exactly the renamed elimination outputs. The caller fixes which cross-source coordinates are shared before this pipeline is returned; the two coordinate maps realize exactly that relation while remaining injective within each source. Thus the third job cannot be an unrelated member of a preselected batch.
Definition (Lean source)
parameters
machineCode :
forwardJob reverseJob :
fields
forwardResult :
EffectiveGroebnerCompletedJobOver ℚ machineCode forwardJob
reverseResult :
EffectiveGroebnerCompletedJobOver ℚ machineCode reverseJob
intersectionJob :
forwardToIntersection_injective :
Injective forwardToIntersection
reverseToIntersection_injective :
Injective reverseToIntersection
forward_reverse_eq_iff :
∀ i j, forwardToIntersection i = reverseToIntersection j ↔ sharedCoordinateRelation i j
intersection_input_from_forward :
intersectionJob.input
= effectiveRenameRationalFamily forwardToIntersection forwardResult.result.saturatedEliminationBasis
intersection_input_from_reverse :
intersectionJob.secondInput
= effectiveRenameRationalFamily reverseToIntersection reverseResult.result.saturatedEliminationBasis
intersectionResult :
EffectiveGroebnerCompletedJobOver ℚ machineCode intersectionJob
def symbolicOperationCount
Exact charged operation count of the dependent two-eliminations-then- intersection execution.
Definition (Lean source)
def EffectiveDependentRationalEliminationPipeline.symbolicOperationCount
{machineCode : Code}
{forwardJob reverseJob : EffectiveGroebnerJobOver ℚ}
{sharedCoordinateRelation : Fin forwardJob.r → Fin reverseJob.r → Prop}
(pipeline : EffectiveDependentRationalEliminationPipeline machineCode
forwardJob reverseJob sharedCoordinateRelation) : ℕ :=
pipeline.forwardResult.result.payload.symbolicOperationCount +
pipeline.reverseResult.result.payload.symbolicOperationCount +
pipeline.intersectionResult.result.payload.symbolicOperationCount
def DegreeBoundedBy
A post-elimination degree envelope for one concrete dependent execution. It bounds the two supplied source jobs, their actual saturated elimination outputs, the dependent intersection job built from those outputs, and its actual intersection basis. In particular, this predicate is evaluated only after pipeline has been returned; it does not assert that elimination preserves a source-only degree bound.
Definition (Lean source)
def EffectiveDependentRationalEliminationPipeline.DegreeBoundedBy
{machineCode : Code}
{forwardJob reverseJob : EffectiveGroebnerJobOver ℚ}
{sharedCoordinateRelation : Fin forwardJob.r → Fin reverseJob.r → Prop}
(pipeline : EffectiveDependentRationalEliminationPipeline machineCode
forwardJob reverseJob sharedCoordinateRelation) (D : ℕ) : Prop :=
forwardJob.DegreeBoundedBy D ∧
reverseJob.DegreeBoundedBy D ∧
EffectivePolynomialFamilyDegreeBoundedBy
pipeline.forwardResult.result.saturatedEliminationBasis D ∧
EffectivePolynomialFamilyDegreeBoundedBy
pipeline.reverseResult.result.saturatedEliminationBasis D ∧
pipeline.intersectionJob.DegreeBoundedBy D ∧
EffectivePolynomialFamilyDegreeBoundedBy
pipeline.intersectionResult.result.intersectionBasis D
inductive EffectiveGroebnerBatchResultsOver
Results for a finite batch of supplied algebra jobs over one coefficient field.
Definition (Lean source)
inductive EffectiveGroebnerBatchResultsOver (K : Type) [Field K] [DecidableEq K]
[Encodable K] (machineCode : Code) :
List (EffectiveGroebnerJobOver K) → Type 2
| nil : EffectiveGroebnerBatchResultsOver K machineCode []
| cons {job jobs} (head : EffectiveGroebnerCompletedJobOver K machineCode job)
(tail : EffectiveGroebnerBatchResultsOver K machineCode jobs) :
EffectiveGroebnerBatchResultsOver K machineCode (job :: jobs)
def symbolicOperationCount
Sum of the exact charged symbolic traces in a coefficient-field batch.
Definition (Lean source)
def EffectiveGroebnerBatchResultsOver.symbolicOperationCount
{K : Type} [Field K] [DecidableEq K] [Encodable K]
{machineCode : Code} :
{jobs : List (EffectiveGroebnerJobOver K)} →
EffectiveGroebnerBatchResultsOver K machineCode jobs → ℕ
| [], .nil => 0
| _ :: _, .cons head tail =>
head.result.payload.symbolicOperationCount + tail.symbolicOperationCount
def effectiveGroebnerBatchSourcePolynomialCount
Aggregate supplied input size of a finite algebra batch.
Definition (Lean source)
def effectiveGroebnerBatchSourcePolynomialCount {K : Type} [Field K]
[DecidableEq K] : List (EffectiveGroebnerJobOver K) → ℕ
| [] => 0
| job :: jobs => job.sourcePolynomialCount +
effectiveGroebnerBatchSourcePolynomialCount jobs
def EffectiveGroebnerBatchInputsBounded
Every job in a finite batch lies in the common ambient-dimension and degree envelope used by the single combined complexity bound.
Definition (Lean source)
def EffectiveGroebnerBatchInputsBounded {K : Type} [Field K] [DecidableEq K] :
List (EffectiveGroebnerJobOver K) → ℕ → ℕ → Prop
| [], _, _ => True
| job :: jobs, N, D =>
job.r ≤ N ∧ job.DegreeBoundedBy D ∧
EffectiveGroebnerBatchInputsBounded jobs N D
def rationalPolynomialFamilyToReal
Coefficient extension of a rational family to the real closed field.
Definition (Lean source)
def rationalPolynomialFamilyToReal {r : ℕ} (family : Finset (MvPolynomial (Fin r) ℚ)) :
Finset (MvPolynomial (Fin r) ℝ) :=
family.image (map (Rat.castHom ℝ))
def rationalPolynomialFamilyToComplex
Coefficient extension of a rational family to the algebraically closed field used by the elimination-closure theorem.
Definition (Lean source)
def rationalPolynomialFamilyToComplex {r : ℕ}
(family : Finset (MvPolynomial (Fin r) ℚ)) :
Finset (MvPolynomial (Fin r) ℂ) :=
family.image (map (Rat.castHom ℂ))
def effectiveComplexZeroSet
Common complex zero set of a finite rational polynomial family.
Definition (Lean source)
def effectiveComplexZeroSet {r : ℕ}
(family : Finset (MvPolynomial (Fin r) ℚ)) : Set (Fin r → ℂ) :=
{x | ∀ P ∈ family,
eval x (map (Rat.castHom ℂ) P) = 0}
def effectiveComplexZariskiClosure
Zariski closure in a finite complex affine space, written directly as the zero set of every complex polynomial vanishing on the supplied set.
Definition (Lean source)
def effectiveComplexZariskiClosure {r : ℕ} (S : Set (Fin r → ℂ)) :
Set (Fin r → ℂ) :=
{x | ∀ P : MvPolynomial (Fin r) ℂ,
(∀ y ∈ S, eval y P = 0) → eval x P = 0}
def effectiveComplexProjectionCylinder
Cylinder over the coordinate projection of a complex affine set onto a retained variable block.
The algebraically closed elimination-closure theorem for a displayed rational elimination basis. This is the exact geometric conclusion used after Groebner elimination: the output zero set is the Zariski closure of the input projection, not the projection itself.
Definition (Lean source)
def IsExactComplexProjectionClosure {r : ℕ}
(input : Finset (MvPolynomial (Fin r) ℚ)) (keep : Finset (Fin r))
(output : Finset (MvPolynomial (Fin r) ℚ)) : Prop :=
effectiveComplexZeroSet output =
effectiveComplexZariskiClosure
(effectiveComplexProjectionCylinder keep (effectiveComplexZeroSet input))
A polynomial uses only the retained variables of an elimination block.
Definition (Lean source)
def UsesOnlyEffectiveVariables {r : ℕ} (keep : Finset (Fin r))
(P : MvPolynomial (Fin r) ℚ) : Prop :=
P.vars ⊆ keep
def effectiveLexMonomialLT
Lexicographic comparison of monomials in the explicitly supplied variable order.
def IsEffectiveEliminationVariableOrder Definition aux_IsEffectiveEliminationVariableOrder in the paper ↗
The specified variable order is complete, duplicate-free, and is an elimination order for the retained block: every eliminated variable precedes every retained variable.
Definition (Lean source)
def IsEffectiveEliminationVariableOrder {r : ℕ} (order : List (Fin r))
(keep : Finset (Fin r)) : Prop :=
∃ eliminated retained : List (Fin r),
order = eliminated ++ retained ∧
eliminated.Nodup ∧ retained.Nodup ∧ Disjoint eliminated.toFinset retained.toFinset ∧
eliminated.toFinset = univ \ keep ∧ retained.toFinset = keep
exponent is the leading exponent of P for the displayed lexicographic order.
Definition (Lean source)
def IsEffectiveLeadingExponent {r : ℕ} (order : List (Fin r))
(P : MvPolynomial (Fin r) ℚ) (exponent : Fin r →₀ ℕ) : Prop :=
exponent ∈ P.support ∧
∀ other ∈ P.support,
other = exponent ∨ effectiveLexMonomialLT order other exponent
An exact Gröbner-basis certificate for the specified monomial order. Besides ideal equality and exact normal-form division, every leading monomial in the input ideal is divisible by a leading monomial of the displayed basis, and the normal form contains no reducible monomial.
Definition (Lean source)
def IsExactGroebnerBasis {r : ℕ} (order : List (Fin r))
(input basis : Finset (MvPolynomial (Fin r) ℚ))
(normalForm : MvPolynomial (Fin r) ℚ → MvPolynomial (Fin r) ℚ) : Prop :=
(∀ G ∈ basis, G ≠ 0) ∧
span (input : Set (MvPolynomial (Fin r) ℚ)) =
span (basis : Set (MvPolynomial (Fin r) ℚ)) ∧
(∀ P ∈ span (input : Set (MvPolynomial (Fin r) ℚ)), P ≠ 0 →
∀ leadingP, IsEffectiveLeadingExponent order P leadingP →
∃ G ∈ basis, ∃ leadingG,
IsEffectiveLeadingExponent order G leadingG ∧ leadingG ≤ leadingP) ∧
∀ P,
(normalForm P = 0 ↔ P ∈ span (input : Set (MvPolynomial (Fin r) ℚ))) ∧
∃ quotients : basis → MvPolynomial (Fin r) ℚ,
P = normalForm P + ∑ Q : basis, quotients Q * Q.1 ∧
∀ exponent ∈ (normalForm P).support, ∀ G ∈ basis, ∀ leadingG,
IsEffectiveLeadingExponent order G leadingG → ¬leadingG ≤ exponent
Exact elimination-ideal output on the retained variable block.
Definition (Lean source)
def IsExactEliminationBasis {r : ℕ} (input : Finset (MvPolynomial (Fin r) ℚ))
(keep : Finset (Fin r)) (output : Finset (MvPolynomial (Fin r) ℚ)) : Prop :=
(∀ P ∈ output, UsesOnlyEffectiveVariables keep P) ∧
∀ P, UsesOnlyEffectiveVariables keep P →
(P ∈ span (output : Set (MvPolynomial (Fin r) ℚ)) ↔
P ∈ span (input : Set (MvPolynomial (Fin r) ℚ)))
Exact ideal-intersection output.
Definition (Lean source)
def IsExactIdealIntersectionBasis {r : ℕ}
(left right output : Finset (MvPolynomial (Fin r) ℚ)) : Prop :=
span (output : Set (MvPolynomial (Fin r) ℚ)) =
span (left : Set (MvPolynomial (Fin r) ℚ)) ⊓
span (right : Set (MvPolynomial (Fin r) ℚ))
Exact saturation output, characterized by membership after multiplication by a power.
Definition (Lean source)
def IsExactSaturationBasis {r : ℕ} (input : Finset (MvPolynomial (Fin r) ℚ))
(saturating : MvPolynomial (Fin r) ℚ)
(output : Finset (MvPolynomial (Fin r) ℚ)) : Prop :=
∀ P, P ∈ span (output : Set (MvPolynomial (Fin r) ℚ)) ↔
∃ k : ℕ, saturating ^ k * P ∈ span (input : Set (MvPolynomial (Fin r) ℚ))
inductive EffectivePolynomialSign
The three-valued exact sign alphabet emitted by the effective CAD algorithm.
Definition (Lean source)
instance instDecidableEqEffectivePolynomialSign
Provides a procedure that decides whether two exact signs from the three-valued alphabet (negative, zero, positive) are equal.
Definition (Lean source)
deriving DecidableEq, Encodable
instance instEncodableEffectivePolynomialSign
Every exact sign from the three-valued alphabet emitted by the effective CAD algorithm has an effective numerical encoding and decoding.
Definition (Lean source)
deriving DecidableEq, Encodable
def Realizes
Exact interpretation of an encoded sign.
Definition (Lean source)
def EffectivePolynomialSign.Realizes : EffectivePolynomialSign → ℝ → Prop
| .negative, x => x < 0
| .zero, x => x = 0
| .positive, x => 0 < x
def effectiveIteratedPDeriv
Iterated differentiation in one CAD lifting variable.
Definition (Lean source)
def effectiveIteratedPDeriv {σ : Type} [DecidableEq σ] (x : σ) :
ℕ → MvPolynomial σ ℝ → MvPolynomial σ ℝ
| 0, P => P
| k + 1, P => effectiveIteratedPDeriv x k (pderiv x P)
structure EffectiveAlgebraicRootCertificate
Finite exact algebraic-root data: a defining rational polynomial, its index in the complete ordered root stack, and its complete Thom-sign row.
Definition (Lean source)
structure EffectiveAlgebraicRootCertificate (r : ℕ) where
definingPolynomial : EffectivePolynomialCode r
rootIndex : ℕ
thomSigns : List EffectivePolynomialSign
deriving Encodable
instance instEncodableEffectiveAlgebraicRootCertificate
Every finite exact algebraic-root certificate — its defining rational polynomial, its index in the ordered root stack, and its Thom-sign row — has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
def Realizes
A root certificate denotes the indexed CAD root and gives the exact signs of every iterated derivative of its displayed defining polynomial along the section.
Definition (Lean source)
def EffectiveAlgebraicRootCertificate.Realizes {r : ℕ}
(certificate : EffectiveAlgebraicRootCertificate r) (x : Fin r)
(base : Set (CADSpace r)) (root : CADSpace r → ℝ)
(family : Finset (MvPolynomial (Fin r) ℝ)) : Prop :=
let P := map (Rat.castHom ℝ) certificate.definingPolynomial.toPolynomial
P ∈ family ∧
IsCADAlgebraicRoot x base certificate.rootIndex root family ∧
(∀ a ∈ base, eval (update a x (root a)) P = 0) ∧
certificate.thomSigns.length = P.totalDegree + 1 ∧
∀ k (sign : EffectivePolynomialSign), certificate.thomSigns[k]? = some sign → ∀ a ∈ base,
EffectivePolynomialSign.Realizes sign (eval (update a x (root a))
(effectiveIteratedPDeriv x k P))
inductive EffectiveCADCellCertificate
Finite syntax for recursive CAD lifting, enriched at every section/sector boundary by exact algebraic-root and Thom-sign certificates.
Definition (Lean source)
inductive EffectiveCADCellCertificate (r : ℕ)
| point
| wholeFiber (base : EffectiveCADCellCertificate r)
| section (root : EffectiveAlgebraicRootCertificate r)
(base : EffectiveCADCellCertificate r)
| lowerSector (upper : EffectiveAlgebraicRootCertificate r)
(base : EffectiveCADCellCertificate r)
| boundedSector (lower upper : EffectiveAlgebraicRootCertificate r)
(base : EffectiveCADCellCertificate r)
| upperSector (lower : EffectiveAlgebraicRootCertificate r)
(base : EffectiveCADCellCertificate r)
deriving Encodable
instance instEncodableEffectiveCADCellCertificate
Every recursive finite syntax tree describing a lifted CAD cell geometry has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
def Realizes
Exact interpretation of an algebraic-root-certified CAD cell.
Definition (Lean source)
def EffectiveCADCellCertificate.Realizes {r : ℕ} :
Finset (MvPolynomial (Fin r) ℝ) → List (Fin r) → EffectiveCADCellCertificate r →
Set (CADSpace r) → Prop
| _, [], .point, cell => cell = { a | ∀ x, a x = 0 }
| family, x :: xs, .wholeFiber baseCertificate, cell =>
∃ base, Realizes (cadProjectionStep x family) xs baseCertificate base ∧
(∀ a ∈ base, cadRealRootsAt x family a = ∅) ∧
cell = { a | cadEraseCoordinate x a ∈ base }
| family, x :: xs, .section rootCertificate baseCertificate, cell =>
∃ base, Realizes (cadProjectionStep x family) xs baseCertificate base ∧
∃ root, rootCertificate.Realizes x base root family ∧
cell = { a | cadEraseCoordinate x a ∈ base ∧
a x = root (cadEraseCoordinate x a) }
| family, x :: xs, .lowerSector upperCertificate baseCertificate, cell =>
∃ base, Realizes (cadProjectionStep x family) xs baseCertificate base ∧
∃ upper, upperCertificate.rootIndex = 0 ∧
upperCertificate.Realizes x base upper family ∧
cell = { a | cadEraseCoordinate x a ∈ base ∧
a x < upper (cadEraseCoordinate x a) }
| family, x :: xs, .boundedSector lowerCertificate upperCertificate baseCertificate, cell =>
∃ base, Realizes (cadProjectionStep x family) xs baseCertificate base ∧
∃ lower upper,
upperCertificate.rootIndex = lowerCertificate.rootIndex + 1 ∧
lowerCertificate.Realizes x base lower family ∧
upperCertificate.Realizes x base upper family ∧
(∀ a ∈ base, lower a < upper a) ∧
cell = { a | cadEraseCoordinate x a ∈ base ∧
lower (cadEraseCoordinate x a) < a x ∧
a x < upper (cadEraseCoordinate x a) }
| family, x :: xs, .upperSector lowerCertificate baseCertificate, cell =>
∃ base, Realizes (cadProjectionStep x family) xs baseCertificate base ∧
∃ lower, lowerCertificate.Realizes x base lower family ∧
IsCADLastAlgebraicRoot x base lowerCertificate.rootIndex lower family ∧
cell = { a | cadEraseCoordinate x a ∈ base ∧
lower (cadEraseCoordinate x a) < a x }
| _, _, _, _ => False
def signOperationCount
Number of exact algebraic-sign answers explicitly stored in a recursive cell certificate.
Definition (Lean source)
def EffectiveCADCellCertificate.signOperationCount {r : ℕ} :
EffectiveCADCellCertificate r → ℕ
| .point => 0
| .wholeFiber base => base.signOperationCount
| .section root base => root.thomSigns.length + base.signOperationCount
| .lowerSector upper base => upper.thomSigns.length + base.signOperationCount
| .boundedSector lower upper base =>
lower.thomSigns.length + upper.thomSigns.length + base.signOperationCount
| .upperSector lower base => lower.thomSigns.length + base.signOperationCount
A cell's encoded geometry together with an exhaustive exact sign row for the input and generated projection polynomials.
Definition (Lean source)
structure EffectiveCertifiedCADCell (r : ℕ) where
geometry : EffectiveCADCellCertificate r
signs : List (EffectivePolynomialCode r × EffectivePolynomialSign)
deriving Encodable
instance instEncodableEffectiveCertifiedCADCell
Every complete CAD cell certificate, consisting of its encoded geometry together with its exhaustive constant-sign row, has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
def Realizes
The encoded cell certificate realizes both its recursive algebraic-root geometry and its complete constant-sign table.
Definition (Lean source)
def EffectiveCertifiedCADCell.Realizes {r : ℕ} (certificate : EffectiveCertifiedCADCell r)
(family signFamily : Finset (MvPolynomial (Fin r) ℚ)) (order : List (Fin r))
(cell : Set (CADSpace r)) : Prop :=
certificate.geometry.Realizes (rationalPolynomialFamilyToReal family) order cell ∧
EffectivePolynomialCodesRealize (certificate.signs.map fst) signFamily ∧
∀ code (sign : EffectivePolynomialSign), (code, sign) ∈ certificate.signs →
∀ a ∈ cell, EffectivePolynomialSign.Realizes sign (eval a
(map (Rat.castHom ℝ) code.toPolynomial))
def signOperationCount
Number of exact root/Thom/cell-sign answers carried by one complete cell certificate.
Definition (Lean source)
def EffectiveCertifiedCADCell.signOperationCount {r : ℕ}
(certificate : EffectiveCertifiedCADCell r) : ℕ :=
certificate.geometry.signOperationCount + certificate.signs.length
def polynomialCodes
Every polynomial presentation contained in one exact algebraic-root certificate.
Definition (Lean source)
def EffectiveAlgebraicRootCertificate.polynomialCodes {r : ℕ}
(certificate : EffectiveAlgebraicRootCertificate r) : List (EffectivePolynomialCode r) :=
[certificate.definingPolynomial]
def polynomialCodes
Recursive extraction of every defining polynomial used by a CAD cell certificate.
Definition (Lean source)
def EffectiveCADCellCertificate.polynomialCodes {r : ℕ} :
EffectiveCADCellCertificate r → List (EffectivePolynomialCode r)
| .point => []
| .wholeFiber base => base.polynomialCodes
| .section root base => root.polynomialCodes ++ base.polynomialCodes
| .lowerSector upper base => upper.polynomialCodes ++ base.polynomialCodes
| .boundedSector lower upper base =>
lower.polynomialCodes ++ upper.polynomialCodes ++ base.polynomialCodes
| .upperSector lower base => lower.polynomialCodes ++ base.polynomialCodes
def RequiresRootIsolation
A recursive cell geometry requires an algebraic-root isolation stage exactly when it has a nontrivial lifting layer. A wholeFiber still requires certifying that the root stack is empty.
Definition (Lean source)
def EffectiveCADCellCertificate.RequiresRootIsolation {r : ℕ} :
EffectiveCADCellCertificate r → Prop
| .point => False
| .wholeFiber _ | .section _ _ | .lowerSector _ _ | .boundedSector _ _ _ |
.upperSector _ _ => True
def ContainsSection
A recursive cell geometry contains a section-lifting layer.
Definition (Lean source)
def EffectiveCADCellCertificate.ContainsSection {r : ℕ} :
EffectiveCADCellCertificate r → Prop
| .point => False
| .wholeFiber base => base.ContainsSection
| .section _ _ => True
| .lowerSector _ base | .boundedSector _ _ base | .upperSector _ base =>
base.ContainsSection
def ContainsSector
A recursive cell geometry contains a sector-lifting layer.
Definition (Lean source)
def EffectiveCADCellCertificate.ContainsSector {r : ℕ} :
EffectiveCADCellCertificate r → Prop
| .point => False
| .wholeFiber base | .section _ base => base.ContainsSector
| .lowerSector _ _ | .boundedSector _ _ _ | .upperSector _ _ => True
def polynomialCodes
Every polynomial presentation on which a certified CAD cell depends: recursive root-defining polynomials together with the complete displayed constant-sign family.
Definition (Lean source)
def EffectiveCertifiedCADCell.polynomialCodes {r : ℕ}
(certificate : EffectiveCertifiedCADCell r) : List (EffectivePolynomialCode r) :=
certificate.geometry.polynomialCodes ++ certificate.signs.map fst
A finite encoded sign-condition query.
Definition (Lean source)
structure EffectiveCADSignQuery (r : ℕ) where
equations : List (EffectivePolynomialCode r)
nonnegative : List (EffectivePolynomialCode r)
positive : List (EffectivePolynomialCode r)
deriving Encodable
instance instEncodableEffectiveCADSignQuery
Every finite encoded sign-condition query — its equations together with its nonnegativity and positivity requirements — has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
def polynomialCodes
Every polynomial presentation read by a sign-condition query.
Definition (Lean source)
def EffectiveCADSignQuery.polynomialCodes {r : ℕ}
(query : EffectiveCADSignQuery r) : List (EffectivePolynomialCode r) :=
query.equations ++ query.nonnegative ++ query.positive
def Realizes
Exact decoding of a sign-condition query.
Definition (Lean source)
def EffectiveCADSignQuery.Realizes {r : ℕ} (query : EffectiveCADSignQuery r)
(equations nonnegative positive : Finset (MvPolynomial (Fin r) ℚ)) : Prop :=
EffectivePolynomialCodesRealize query.equations equations ∧
EffectivePolynomialCodesRealize query.nonnegative nonnegative ∧
EffectivePolynomialCodesRealize query.positive positive
One exhaustive encoded cellwise truth row.
Definition (Lean source)
structure EffectiveCADTruthRow (r : ℕ) where
query : EffectiveCADSignQuery r
cellIndex : ℕ
truth : Bool
deriving Encodable
instance instEncodableEffectiveCADTruthRow
Every encoded cellwise truth row has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
def polynomialCodes
Every polynomial presentation read to produce a truth row.
Definition (Lean source)
def EffectiveCADTruthRow.polynomialCodes {r : ℕ}
(row : EffectiveCADTruthRow r) : List (EffectivePolynomialCode r) :=
row.query.polynomialCodes
One exhaustive encoded witness-retention row.
Definition (Lean source)
structure EffectiveCADRetentionRow (r : ℕ) where
query : EffectiveCADSignQuery r
retainedCellIndices : List ℕ
deriving Encodable
instance instEncodableEffectiveCADRetentionRow
Every encoded witness-retention row has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
def polynomialCodes
Every polynomial presentation read to produce a witness-retention row.
Definition (Lean source)
def EffectiveCADRetentionRow.polynomialCodes {r : ℕ}
(row : EffectiveCADRetentionRow r) : List (EffectivePolynomialCode r) :=
row.query.polynomialCodes
def effectiveCADErasePrefix
Erase a supplied prefix of lifting coordinates. This is the geometric projection naturally paired with IsRecursivelyLiftedCADCell: the recursive cell language peels the head of the lifting order and applies cadEraseCoordinate at every dropped layer.
Definition (Lean source)
def effectiveCADErasePrefix {r : ℕ} (eliminated : List (Fin r))
(point : CADSpace r) : CADSpace r :=
eliminated.foldl (fun projected x => cadEraseCoordinate x projected) point
def effectiveCADFamilyAfterPrefix
The recursion-varying BPR family after dropping a prefix of lifting layers. Unlike the public accumulated generatedCADProjectionFamily, this is the stage family consumed by the recursive cell certificate over the retained suffix.
Definition (Lean source)
def effectiveCADFamilyAfterPrefix {r : ℕ} (eliminated : List (Fin r))
(family : Finset (MvPolynomial (Fin r) ℝ)) : Finset (MvPolynomial (Fin r) ℝ) :=
eliminated.foldl (fun projected x => cadProjectionStep x projected) family
structure EffectiveCADBasicSignCondition Definition aux_EffectiveCADBasicSignCondition in the paper ↗
Finite exact sign-vector syntax for one basic CAD cell presentation. Negative signs are kept explicitly, rather than encoding them by silently adjoining negated polynomials to the supplied family.
Definition (Lean source)
structure EffectiveCADBasicSignCondition (r : ℕ) where
conditions : List (EffectivePolynomialCode r × EffectivePolynomialSign)
deriving Encodable
instance instEncodableEffectiveCADBasicSignCondition
Every finite exact sign-vector presentation of a basic CAD cell has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
def set
The subset of the erased-prefix affine slice cut out by an encoded exact sign vector. The explicit zero-coordinate guard is part of the ambient representation: projected cells still use CADSpace r, so their eliminated coordinates must not be left as free cylindrical directions.
Definition (Lean source)
def EffectiveCADBasicSignCondition.set {r : ℕ} (eliminated : List (Fin r))
(condition : EffectiveCADBasicSignCondition r) : Set (CADSpace r) :=
{ point | (∀ x ∈ eliminated, point x = 0) ∧
∀ code sign, (code, sign) ∈ condition.conditions →
EffectivePolynomialSign.Realizes sign
(eval point
(map (Rat.castHom ℝ) code.toPolynomial)) }
def Realizes
An encoded sign vector lists every polynomial in the displayed rational family, uses no polynomial outside that family, and cuts out exactly the displayed cell. The coverage direction is required by prefix-projected CAD consumers: soundness for the signs that happen to be listed does not by itself make the list an exact sign vector for the displayed family.
Definition (Lean source)
def EffectiveCADBasicSignCondition.Realizes {r : ℕ}
(condition : EffectiveCADBasicSignCondition r)
(eliminated retained : List (Fin r))
(family : Finset (MvPolynomial (Fin r) ℝ)) (cell : Set (CADSpace r)) : Prop :=
((∀ code sign, (code, sign) ∈ condition.conditions →
map (Rat.castHom ℝ) code.toPolynomial ∈ family ∧
code.toPolynomial.vars ⊆ retained.toFinset) ∧
(∀ P ∈ family, ∃ code sign, (code, sign) ∈ condition.conditions ∧
map (Rat.castHom ℝ) code.toPolynomial = P)) ∧
cell = condition.set eliminated
def polynomialCodes
Every polynomial presentation read by a basic sign-condition certificate.
Definition (Lean source)
def EffectiveCADBasicSignCondition.polynomialCodes {r : ℕ}
(condition : EffectiveCADBasicSignCondition r) : List (EffectivePolynomialCode r) :=
condition.conditions.map fst
structure EffectiveCADPrefixProjectionCertificate Definition aux_EffectiveCADPrefixProjectionCertificate in the paper ↗
One fully encoded prefix-projected CAD cell certificate. The source-cell code and the exact truth/retention-row code lists link the projected cell back to all of the finite decision data emitted for its source cell.
Definition (Lean source)
structure EffectiveCADPrefixProjectionCertificate (r : ℕ) where
eliminatedVariables : List (Fin r)
retainedVariables : List (Fin r)
sourceCellIndex : ℕ
sourceCellCertificateCode : ℕ
projectedGeometry : EffectiveCADCellCertificate r
projectedGeometryCode : ℕ
basicSignCondition : EffectiveCADBasicSignCondition r
truthRowCodes : List ℕ
retentionRowCodes : List ℕ
deriving Encodable
instance instEncodableEffectiveCADPrefixProjectionCertificate
Every fully encoded prefix-projected CAD cell certificate — its eliminated and retained variables, its source-cell links, its projected geometry, its basic sign presentation, and its truth- and retention-row links — has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
def polynomialCodes
Every polynomial presentation required by a prefix-projected cell artifact.
Definition (Lean source)
def EffectiveCADPrefixProjectionCertificate.polynomialCodes {r : ℕ}
(certificate : EffectiveCADPrefixProjectionCertificate r) :
List (EffectivePolynomialCode r) :=
certificate.projectedGeometry.polynomialCodes ++
certificate.basicSignCondition.polynomialCodes
def signOperationCount
Exact root/Thom and basic-cell sign answers stored in one prefix projection artifact.
Definition (Lean source)
def EffectiveCADPrefixProjectionCertificate.signOperationCount {r : ℕ}
(certificate : EffectiveCADPrefixProjectionCertificate r) : ℕ :=
certificate.projectedGeometry.signOperationCount +
certificate.basicSignCondition.conditions.length
structure EffectiveReductumCertificate
Exact finite data for one charged member of a BPR reducta family. The source code and iteration number are retained so the primitive trace records how the output code was obtained, rather than merely asserting that an extensionally equal polynomial eventually appeared.
Definition (Lean source)
structure EffectiveReductumCertificate (r : ℕ) where
sourcePolynomial : EffectivePolynomialCode r
reductumVariable : Fin r
reductumIteration : ℕ
outputPolynomial : EffectivePolynomialCode r
deriving Encodable
instance instEncodableEffectiveReductumCertificate
Every finite certificate for one charged member of a reducta family — its source polynomial, the reduction variable and iteration number, and the output polynomial — has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
def Realizes
A reductum certificate denotes exactly the displayed nonzero iterate, within the finite degree range used by cadReducta. Coefficient extension to ℝ is injective, so this equality also fixes the underlying rational output polynomial.
Definition (Lean source)
def EffectiveReductumCertificate.Realizes {r : ℕ}
(certificate : EffectiveReductumCertificate r) : Prop :=
let sourceReal :=
map (Rat.castHom ℝ) certificate.sourcePolynomial.toPolynomial
let outputReal :=
map (Rat.castHom ℝ) certificate.outputPolynomial.toPolynomial
certificate.reductumIteration <
(cadAsUnivariate certificate.reductumVariable sourceReal).natDegree + 1 ∧
outputReal =
(cadReductum certificate.reductumVariable)^[certificate.reductumIteration] sourceReal ∧
outputReal ∈ cadReducta certificate.reductumVariable sourceReal
inductive EffectiveAlgebraTraceOperation
General symbolic operations supplied by the cited rational algebra and CAD algorithms.
Definition (Lean source)
inductive EffectiveAlgebraTraceOperation
| buchberger
| elimination
| idealIntersection
| saturation
| reductaGeneration
| coefficientProjection
| discriminantProjection
| principalSubresultantProjection
| projectionClosure
| rootIsolation
| sectionLifting
| sectorLifting
| prefixCellProjection
| signConditionTruth
| witnessCellRetention
deriving DecidableEq, Encodable
instance instDecidableEqEffectiveAlgebraTraceOperation
General effective-algebra trace operations have a decidable equality test: any two operations can be effectively determined to be the same or different.
Definition (Lean source)
deriving DecidableEq, Encodable
instance instEncodableEffectiveAlgebraTraceOperation
Every general effective-algebra trace operation has an effective numerical encoding and decoding.
Definition (Lean source)
deriving DecidableEq, Encodable
inductive EffectiveRealAlgebraicPrimitiveOperation
Primitive operations in the real-algebraic cost model. Exact algebraic-sign queries are primitive here; this does not claim Turing-computable comparison of arbitrary real numbers.
Definition (Lean source)
inductive EffectiveRealAlgebraicPrimitiveOperation
| rationalAddition
| rationalMultiplication
| rationalInversion
| emitReductumCertificate (code : ℕ)
| exactAlgebraicSign
| emitCellCertificate (code : ℕ)
| emitPrefixProjectionCertificate (code : ℕ)
| emitTruthRow (code : ℕ)
| emitRetentionRow (code : ℕ)
deriving DecidableEq, Encodable
instance instDecidableEqEffectiveRealAlgebraicPrimitiveOperation
Provides a procedure that decides whether two primitive operations of the real-algebraic cost model are equal.
Definition (Lean source)
deriving DecidableEq, Encodable
instance instEncodableEffectiveRealAlgebraicPrimitiveOperation
Every primitive operation of the real-algebraic cost model has an effective numerical encoding and decoding.
Definition (Lean source)
deriving DecidableEq, Encodable
One certified high-level trace step, including the polynomial families it reads and emits, the injective encodings of any CAD certificates/truth rows/retention rows it produces, and the complete list of primitive real-algebraic operations charged to that step. The artifact fields use Nat solely to avoid a circular datatype dependency; result-level equalities below identify them extensionally with the actual typed payload objects.
Definition (Lean source)
structure EffectiveAlgebraTraceStep (r : ℕ) where
operation : EffectiveAlgebraTraceOperation
inputFamilies : List (List (EffectivePolynomialCode r))
outputFamilies : List (List (EffectivePolynomialCode r))
producedReductumCertificateCodes : List ℕ
producedCellCertificateCodes : List ℕ
producedPrefixProjectionCertificateCodes : List ℕ
producedTruthRowCodes : List ℕ
producedRetentionRowCodes : List ℕ
variableOrder : List (Fin r)
activeVariable : Option (Fin r)
retainedVariables : List (Fin r)
primitiveOperations : List EffectiveRealAlgebraicPrimitiveOperation
deriving Encodable
instance instEncodableEffectiveAlgebraTraceStep
Every certified effective-algebra trace step, including its input, output, certificate, and primitive-operation data, has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
def operationCount
Exact real-algebraic cost of one trace step.
Definition (Lean source)
def EffectiveAlgebraTraceStep.operationCount {r : ℕ}
(step : EffectiveAlgebraTraceStep r) : ℕ :=
step.primitiveOperations.length
def ArtifactOutputsCharged
Every typed output artifact attributed to a trace step consumes a charged exact-sign event. The stronger result-level bound below additionally charges every Thom/cell sign stored inside the produced cell certificates.
Definition (Lean source)
def EffectiveAlgebraTraceStep.ArtifactOutputsCharged {r : ℕ}
(step : EffectiveAlgebraTraceStep r) : Prop :=
step.producedCellCertificateCodes.length +
step.producedPrefixProjectionCertificateCodes.length +
step.producedTruthRowCodes.length + step.producedRetentionRowCodes.length ≤
step.primitiveOperations.count .exactAlgebraicSign
def ArtifactKindsCorrect
Artifact outputs occur only at the corresponding CAD/QE stages.
Definition (Lean source)
def EffectiveAlgebraTraceStep.ArtifactKindsCorrect {r : ℕ}
(step : EffectiveAlgebraTraceStep r) : Prop :=
(step.producedReductumCertificateCodes ≠ [] →
step.operation = .reductaGeneration) ∧
(step.producedCellCertificateCodes ≠ [] →
step.operation ∈ [.rootIsolation, .sectionLifting, .sectorLifting]) ∧
(step.producedPrefixProjectionCertificateCodes ≠ [] →
step.operation = .prefixCellProjection) ∧
(step.producedTruthRowCodes ≠ [] → step.operation = .signConditionTruth) ∧
(step.producedRetentionRowCodes ≠ [] → step.operation = .witnessCellRetention)
def Links
A trace step is tied to a particular high-level operation and its displayed input/output polynomial families.
Definition (Lean source)
def EffectiveAlgebraTraceStep.Links {r : ℕ} (step : EffectiveAlgebraTraceStep r)
(operation : EffectiveAlgebraTraceOperation)
(inputs outputs : List (List (EffectivePolynomialCode r))) : Prop :=
step.operation = operation ∧ step.inputFamilies = inputs ∧ step.outputFamilies = outputs
def effectiveDecodedPolynomialFamily
The rational polynomial family decoded from one finite code list.
Definition (Lean source)
def effectiveDecodedPolynomialFamily {r : ℕ} (codes : List (EffectivePolynomialCode r)) :
Finset (MvPolynomial (Fin r) ℚ) :=
(codes.map EffectivePolynomialCode.toPolynomial).toFinset
def effectiveDecodedRealPolynomialFamily
The real interpretation of one displayed rational code family.
Definition (Lean source)
def effectiveDecodedRealPolynomialFamily {r : ℕ}
(codes : List (EffectivePolynomialCode r)) : Finset (MvPolynomial (Fin r) ℝ) :=
rationalPolynomialFamilyToReal (effectiveDecodedPolynomialFamily codes)
def reductumCertificateCode
The reductum-certificate code, when a primitive is a reductum-emission event.
Definition (Lean source)
def EffectiveRealAlgebraicPrimitiveOperation.reductumCertificateCode :
EffectiveRealAlgebraicPrimitiveOperation → Option ℕ
| .emitReductumCertificate code => some code
| _ => none
def ReductumPrimitiveCodesExact
The displayed reductum-certificate register is exactly the corresponding subsequence of the charged primitive program. Thus a reducta stage cannot list certificates beside an unrelated arithmetic trace.
Definition (Lean source)
def EffectiveAlgebraTraceStep.ReductumPrimitiveCodesExact {r : ℕ}
(step : EffectiveAlgebraTraceStep r) : Prop :=
step.primitiveOperations.filterMap
EffectiveRealAlgebraicPrimitiveOperation.reductumCertificateCode =
step.producedReductumCertificateCodes
def ReductaOutputsExactlyCharged
A reducta-generation step charges one exact certificate for every displayed output code. Each certificate starts from a code in the declared input family, uses the declared active variable, and realizes the indicated finite reductum iterate.
Definition (Lean source)
def EffectiveAlgebraTraceStep.ReductaOutputsExactlyCharged {r : ℕ}
(step : EffectiveAlgebraTraceStep r) (input output : List (EffectivePolynomialCode r))
(x : Fin r) : Prop :=
∃ certificates : List (EffectiveReductumCertificate r),
certificates.map Encodable.encode = step.producedReductumCertificateCodes ∧
certificates.map EffectiveReductumCertificate.outputPolynomial = output ∧
∀ certificate ∈ certificates,
certificate.sourcePolynomial ∈ input ∧
certificate.reductumVariable = x ∧ certificate.Realizes
structure EffectivePolynomialMachineState Definition aux_EffectivePolynomialMachineState in the paper ↗
One state of the primitive rational-arithmetic execution underlying a high-level trace step.
def AvailableIn
A required polynomial presentation is extensionally available in the computed register pool. The exact code need not be byte-identical, but it must denote the same rational polynomial.
Definition (Lean source)
def EffectivePolynomialCode.AvailableIn {r : ℕ} (required : EffectivePolynomialCode r)
(pool : List (EffectivePolynomialCode r)) : Prop :=
∃ computed ∈ pool, computed.toPolynomial = required.toPolynomial
def EffectivePrimitiveTransition
Exact transition semantics for every charged primitive operation. Polynomial arithmetic adds the computed rational polynomial to the register pool; artifact-emission steps append the exact encoded object to the corresponding output register. Hence typed CAD/QE output is generated by, not merely listed beside, the bounded primitive execution.
Definition (Lean source)
def EffectivePrimitiveTransition {r : ℕ} :
EffectiveRealAlgebraicPrimitiveOperation → EffectivePolynomialMachineState r →
EffectivePolynomialMachineState r → Prop
| .rationalAddition, before, after =>
∃ left ∈ before.polynomialPool, ∃ right ∈ before.polynomialPool, ∃ result,
result.toPolynomial = left.toPolynomial + right.toPolynomial ∧
after = { before with polynomialPool := before.polynomialPool ++ [result] }
| .rationalMultiplication, before, after =>
∃ left ∈ before.polynomialPool, ∃ right ∈ before.polynomialPool, ∃ result,
result.toPolynomial = left.toPolynomial * right.toPolynomial ∧
after = { before with polynomialPool := before.polynomialPool ++ [result] }
| .rationalInversion, before, after =>
∃ scalar : ℚ, scalar ≠ 0 ∧ ∃ source ∈ before.polynomialPool, ∃ result,
result.toPolynomial = C scalar⁻¹ * source.toPolynomial ∧
after = { before with polynomialPool := before.polynomialPool ++ [result] }
| .emitReductumCertificate code, before, after =>
∃ certificate : EffectiveReductumCertificate r,
Encodable.encode certificate = code ∧
certificate.sourcePolynomial ∈ before.polynomialPool ∧ certificate.Realizes ∧
after =
{ before with
polynomialPool := before.polynomialPool ++ [certificate.outputPolynomial]
reductumCertificateCodes := before.reductumCertificateCodes ++ [code] }
| .exactAlgebraicSign, before, after => after = before
| .emitCellCertificate code, before, after =>
∃ certificate : EffectiveCertifiedCADCell r,
Encodable.encode certificate = code ∧
(∀ required ∈ certificate.polynomialCodes,
required.AvailableIn before.polynomialPool) ∧
after =
{ before with cellCertificateCodes := before.cellCertificateCodes ++ [code] }
| .emitPrefixProjectionCertificate code, before, after =>
∃ certificate : EffectiveCADPrefixProjectionCertificate r,
Encodable.encode certificate = code ∧
(∀ required ∈ certificate.polynomialCodes,
required.AvailableIn before.polynomialPool) ∧
after =
{ before with prefixProjectionCertificateCodes :=
before.prefixProjectionCertificateCodes ++ [code] }
| .emitTruthRow code, before, after =>
∃ row : EffectiveCADTruthRow r,
Encodable.encode row = code ∧
(∀ required ∈ row.polynomialCodes,
required.AvailableIn before.polynomialPool) ∧
after = { before with truthRowCodes := before.truthRowCodes ++ [code] }
| .emitRetentionRow code, before, after =>
∃ row : EffectiveCADRetentionRow r,
Encodable.encode row = code ∧
(∀ required ∈ row.polynomialCodes,
required.AvailableIn before.polynomialPool) ∧
after = { before with retentionRowCodes := before.retentionRowCodes ++ [code] }
def EffectivePrimitiveProgramRuns
Execution of the displayed primitive-operation list, with no hidden uncharged transitions.
Definition (Lean source)
def EffectivePrimitiveProgramRuns {r : ℕ} :
List EffectiveRealAlgebraicPrimitiveOperation → EffectivePolynomialMachineState r →
EffectivePolynomialMachineState r → Prop
| [], initial, final => final = initial
| operation :: operations, initial, final =>
∃ next, EffectivePrimitiveTransition operation initial next ∧
EffectivePrimitiveProgramRuns operations next final
def EffectivePolynomialFamilyAvailable
A displayed polynomial family is already present, extensionally, in a family register created by the supplied input or by an earlier trace step.
Definition (Lean source)
def EffectivePolynomialFamilyAvailable {r : ℕ}
(required : List (EffectivePolynomialCode r))
(registers : List (List (EffectivePolynomialCode r))) : Prop :=
∃ registered ∈ registers,
effectiveDecodedPolynomialFamily registered = effectiveDecodedPolynomialFamily required
def SemanticallyCorrect
Operation-specific mathematical semantics for the input and output families of a high-level trace step. This connects the encoded trace to the exact Gröbner, elimination, projection, and CAD operations whose primitive execution is charged.
Definition (Lean source)
def EffectiveAlgebraTraceStep.SemanticallyCorrect {r : ℕ}
(step : EffectiveAlgebraTraceStep r) : Prop :=
match step.operation, step.inputFamilies, step.outputFamilies, step.activeVariable with
| .buchberger, [input], [output], _ =>
∃ normalForm, IsExactGroebnerBasis step.variableOrder
(effectiveDecodedPolynomialFamily input) (effectiveDecodedPolynomialFamily output)
normalForm
| .elimination, [input], [output], _ =>
IsEffectiveEliminationVariableOrder step.variableOrder
step.retainedVariables.toFinset ∧
IsExactEliminationBasis (effectiveDecodedPolynomialFamily input)
step.retainedVariables.toFinset (effectiveDecodedPolynomialFamily output)
| .idealIntersection, [left, right], [output], _ =>
IsExactIdealIntersectionBasis (effectiveDecodedPolynomialFamily left)
(effectiveDecodedPolynomialFamily right) (effectiveDecodedPolynomialFamily output)
| .saturation, [input, [saturating]], [output], _ =>
IsExactSaturationBasis (effectiveDecodedPolynomialFamily input) saturating.toPolynomial
(effectiveDecodedPolynomialFamily output)
| .reductaGeneration, [input], [output], some x =>
effectiveDecodedRealPolynomialFamily output =
cadReductaFamily x (effectiveDecodedRealPolynomialFamily input) ∧
step.ReductaOutputsExactlyCharged input output x
| .coefficientProjection, [input], [output], some x =>
effectiveDecodedRealPolynomialFamily output =
cadCoefficients x (effectiveDecodedRealPolynomialFamily input)
| .discriminantProjection, [input], [output], some x =>
effectiveDecodedRealPolynomialFamily output =
cadDiscriminants x (effectiveDecodedRealPolynomialFamily input)
| .principalSubresultantProjection, [input], [output], some x =>
effectiveDecodedRealPolynomialFamily output =
cadPrincipalSubresultants x (effectiveDecodedRealPolynomialFamily input)
| .projectionClosure, [current, coefficients, discriminants, subresultants], [output], some _ =>
effectiveDecodedRealPolynomialFamily output =
effectiveDecodedRealPolynomialFamily current ∪
effectiveDecodedRealPolynomialFamily coefficients ∪
effectiveDecodedRealPolynomialFamily discriminants ∪
effectiveDecodedRealPolynomialFamily subresultants
| .projectionClosure, [input], [output], none =>
effectiveDecodedRealPolynomialFamily output =
generatedCADProjectionFamily step.variableOrder
(effectiveDecodedRealPolynomialFamily input)
| .rootIsolation, [_], [], some _ =>
step.producedCellCertificateCodes ≠ []
| .sectionLifting, [_], [], some _ =>
step.producedCellCertificateCodes ≠ []
| .sectorLifting, [_], [], some _ =>
step.producedCellCertificateCodes ≠ []
| .prefixCellProjection, [_], [], _ =>
step.producedPrefixProjectionCertificateCodes ≠ []
| .signConditionTruth, [_], [], _ =>
step.producedTruthRowCodes ≠ []
| .witnessCellRetention, [_], [], _ =>
step.producedRetentionRowCodes ≠ []
| _, _, _, _ => False
def Runs
One high-level trace step runs from the previous global state. No step can introduce a fresh input family: every input must already be registered extensionally. Its named semantic operation is correct, its primitive program starts from that same state, and every displayed output is available in the resulting pool. The pool may additionally retain charged intermediate results.
Definition (Lean source)
def EffectiveAlgebraTraceStep.Runs {r : ℕ} (step : EffectiveAlgebraTraceStep r)
(before after : EffectivePolynomialMachineState r) : Prop :=
step.SemanticallyCorrect ∧
step.ReductumPrimitiveCodesExact ∧
(∀ family ∈ step.inputFamilies,
EffectivePolynomialFamilyAvailable family before.familyRegisters) ∧
∃ primitiveFinal,
EffectivePrimitiveProgramRuns step.primitiveOperations before primitiveFinal ∧
(∀ output ∈ step.outputFamilies.flatten,
output.AvailableIn primitiveFinal.polynomialPool) ∧
primitiveFinal.reductumCertificateCodes =
before.reductumCertificateCodes ++ step.producedReductumCertificateCodes ∧
primitiveFinal.cellCertificateCodes =
before.cellCertificateCodes ++ step.producedCellCertificateCodes ∧
primitiveFinal.prefixProjectionCertificateCodes =
before.prefixProjectionCertificateCodes ++
step.producedPrefixProjectionCertificateCodes ∧
primitiveFinal.truthRowCodes = before.truthRowCodes ++ step.producedTruthRowCodes ∧
primitiveFinal.retentionRowCodes =
before.retentionRowCodes ++ step.producedRetentionRowCodes ∧
after =
{ primitiveFinal with
familyRegisters := before.familyRegisters ++ step.outputFamilies }
def EffectiveAlgebraTraceRuns
The whole symbolic trace is one continuous bounded execution. Each step consumes exactly the state produced by its predecessor; in particular no per-step polynomial pool is reset or supplied afresh.
Definition (Lean source)
def EffectiveAlgebraTraceRuns {r : ℕ} :
List (EffectiveAlgebraTraceStep r) → EffectivePolynomialMachineState r →
EffectivePolynomialMachineState r → Prop
| [], initial, final => final = initial
| step :: steps, initial, final =>
∃ next, step.Runs initial next ∧ EffectiveAlgebraTraceRuns steps next final
def AtProjectionIndex
A trace step at the displayed position has the exact operation, code-family boundary, and active CAD variable required by one projection round.
Definition (Lean source)
def EffectiveAlgebraTraceStep.AtProjectionIndex {r : ℕ}
(steps : List (EffectiveAlgebraTraceStep r)) (index : ℕ)
(operation : EffectiveAlgebraTraceOperation)
(inputs outputs : List (List (EffectivePolynomialCode r)))
(x : Fin r) : Prop :=
∃ step, steps[index]? = some step ∧ step.Links operation inputs outputs ∧
step.activeVariable = some x
def EffectiveCADProjectionRoundChain
Exact ordered BPR projection rounds. Each round first registers all reducta of the current accumulated family, then computes coefficients, discriminants, and principal subresultants from that same registered reducta family, and finally registers the current family together with their union. The next round consumes that registered output directly, exactly matching the foldl defining generatedCADProjectionFamily; no fresh uncharged family is introduced between rounds.
Definition (Lean source)
def EffectiveCADProjectionRoundChain {r : ℕ}
(trace : List (EffectiveAlgebraTraceStep r)) :
List (Fin r) → List (EffectivePolynomialCode r) →
List (EffectivePolynomialCode r) → ℕ → Prop
| [], current, finalFamily, _ =>
effectiveDecodedRealPolynomialFamily finalFamily =
effectiveDecodedRealPolynomialFamily current
| x :: xs, current, finalFamily, startIndex =>
∃ reducta coefficients discriminants subresultants nextAccumulated,
∃ reductaIndex coefficientIndex discriminantIndex subresultantIndex assemblyIndex,
startIndex ≤ reductaIndex ∧ reductaIndex < coefficientIndex ∧
coefficientIndex < discriminantIndex ∧ discriminantIndex < subresultantIndex ∧
subresultantIndex < assemblyIndex ∧
EffectiveAlgebraTraceStep.AtProjectionIndex trace reductaIndex
.reductaGeneration [current] [reducta] x ∧
EffectiveAlgebraTraceStep.AtProjectionIndex trace coefficientIndex
.coefficientProjection [reducta] [coefficients] x ∧
EffectiveAlgebraTraceStep.AtProjectionIndex trace discriminantIndex
.discriminantProjection [reducta] [discriminants] x ∧
EffectiveAlgebraTraceStep.AtProjectionIndex trace subresultantIndex
.principalSubresultantProjection [reducta] [subresultants] x ∧
EffectiveAlgebraTraceStep.AtProjectionIndex trace assemblyIndex
.projectionClosure [current, coefficients, discriminants, subresultants]
[nextAccumulated] x ∧
effectiveDecodedRealPolynomialFamily reducta =
cadReductaFamily x (effectiveDecodedRealPolynomialFamily current) ∧
effectiveDecodedRealPolynomialFamily coefficients =
cadCoefficients x (effectiveDecodedRealPolynomialFamily reducta) ∧
effectiveDecodedRealPolynomialFamily discriminants =
cadDiscriminants x (effectiveDecodedRealPolynomialFamily reducta) ∧
effectiveDecodedRealPolynomialFamily subresultants =
cadPrincipalSubresultants x (effectiveDecodedRealPolynomialFamily reducta) ∧
effectiveDecodedRealPolynomialFamily nextAccumulated =
effectiveDecodedRealPolynomialFamily current ∪
cadProjectionStep x (effectiveDecodedRealPolynomialFamily current) ∧
EffectiveCADProjectionRoundChain trace xs nextAccumulated finalFamily
(assemblyIndex + 1)
structure EffectiveRationalGroebnerCADPayload Definition aux_EffectiveRationalGroebnerCADPayload in the paper ↗
Discrete output of one terminating general-purpose rational Gröbner/CAD run.
Definition (Lean source)
structure EffectiveRationalGroebnerCADPayload (r : ℕ) where
input : List (EffectivePolynomialCode r)
secondInput : List (EffectivePolynomialCode r)
saturatingPolynomial : EffectivePolynomialCode r
groebnerBasis : List (EffectivePolynomialCode r)
eliminationBasis : List (EffectivePolynomialCode r)
intersectionBasis : List (EffectivePolynomialCode r)
saturationBasis : List (EffectivePolynomialCode r)
projectionFamily : List (EffectivePolynomialCode r)
variableOrder : List (Fin r)
retainedVariables : List (Fin r)
cellCertificates : List (EffectiveCertifiedCADCell r)
prefixProjectionCertificates : List (EffectiveCADPrefixProjectionCertificate r)
signRows : List (EffectiveCADTruthRow r)
retainedCellRows : List (EffectiveCADRetentionRow r)
trace : List (EffectiveAlgebraTraceStep r)
deriving Encodable
instance instEncodableEffectiveRationalGroebnerCADPayload
Every finite payload produced by the effective rational Gröbner/CAD computation has an effective numerical encoding and decoding.
Definition (Lean source)
deriving Encodable
def symbolicOperationCount
The symbolic operation count is definitionally the sum of the primitive arithmetic/sign events recorded by the certified trace; it is not an independently chosen payload field.
Definition (Lean source)
def EffectiveRationalGroebnerCADPayload.symbolicOperationCount {r : ℕ}
(payload : EffectiveRationalGroebnerCADPayload r) : ℕ :=
(payload.trace.map EffectiveAlgebraTraceStep.operationCount).sum
def certifiedSignOperationCount
Number of exact root/Thom/cell-sign answers explicitly certified by the payload.
Definition (Lean source)
def EffectiveRationalGroebnerCADPayload.certifiedSignOperationCount {r : ℕ}
(payload : EffectiveRationalGroebnerCADPayload r) : ℕ :=
(payload.cellCertificates.map EffectiveCertifiedCADCell.signOperationCount).sum
def prefixProjectionSignOperationCount
Number of exact root/Thom/basic-cell signs stored in all prefix projection artifacts.
Definition (Lean source)
def EffectiveRationalGroebnerCADPayload.prefixProjectionSignOperationCount {r : ℕ}
(payload : EffectiveRationalGroebnerCADPayload r) : ℕ :=
(payload.prefixProjectionCertificates.map
EffectiveCADPrefixProjectionCertificate.signOperationCount).sum
Two assignments agree on the coordinates retained after witness elimination.
Definition (Lean source)
def SameOnEffectiveCoordinates {r : ℕ} (keep : Finset (Fin r))
(x y : CADSpace r) : Prop :=
∀ i ∈ keep, x i = y i
def effectiveRationalSignConditionSet
Real sign-condition set associated with rational polynomial input.
Definition (Lean source)
def effectiveRationalSignConditionSet {r : ℕ}
(equations nonnegative positive : Finset (MvPolynomial (Fin r) ℚ)) : Set (CADSpace r) :=
signConditionSet (rationalPolynomialFamilyToReal equations)
(rationalPolynomialFamilyToReal nonnegative) (rationalPolynomialFamilyToReal positive)
structure EffectiveRationalGroebnerCADResult Definition aux_EffectiveRationalGroebnerCADResult in the paper ↗
A complete semantically certified output of the general effective algorithms. The machine halts with the exact encoding of the displayed finite payload. Its fuel is deliberately unrelated to payload.symbolicOperationCount, which counts the primitive rational-arithmetic and exact algebraic-sign events recorded in the symbolic trace.
Definition (Lean source)
parameters
fields
groebnerBasis :
eliminationBasis :
intersectionBasis :
saturationBasis :
projectionFamily :
normalForm :
groebner_exact :
IsExactGroebnerBasis order (input ∪ secondInput) groebnerBasis normalForm
elimination_exact :
IsExactEliminationBasis (input ∪ secondInput) keep eliminationBasis
Cox--Little--O'Shea's Closure Theorem, after coefficient extension from
`ℚ` to `ℂ`. Ideal equality alone does not imply this geometric statement
without the algebraically closed elimination-closure argument.
complex_projection_closure_exact :
IsExactComplexProjectionClosure (input ∪ secondInput) keep eliminationBasis
intersection_exact :
IsExactIdealIntersectionBasis input secondInput intersectionBasis
saturation_exact :
IsExactSaturationBasis (input ∪ secondInput) saturating saturationBasis
projection_exact :
rationalPolynomialFamilyToReal projectionFamily
= generatedCADProjectionFamily order (rationalPolynomialFamilyToReal (input ∪ secondInput))
cellCount :
ℕ
cellCertificate :
Fin cellCount → EffectiveCertifiedCADCell r
adapted_cad :
IsAdaptedCAD (rationalPolynomialFamilyToReal (input ∪ secondInput)) order cell
cell_certificate_exact :
∀ i,
(cellCertificate i).Realizes (input ∪ secondInput) (input ∪ secondInput ∪ projectionFamily) order (cell i)
The exact cell obtained by erasing an arbitrary prefix of the supplied lifting order.
prefix_projected_cell_exact :
∀ eliminated retained
if
order = eliminated ++ retained
then
∀ i, prefixProjectedCell eliminated i = effectiveCADErasePrefix eliminated '' cell i
truthValue :
Finset (MvPolynomial (Fin r) ℚ) → Finset (MvPolynomial (Fin r) ℚ) → Finset (MvPolynomial (Fin r) ℚ) → Fin cellCount → Bool
truth_exact :
∀ equations nonnegative positive
if
equations ⊆ input ∪ secondInput
and
nonnegative ⊆ input ∪ secondInput
and
positive ⊆ input ∪ secondInput
then
∀ i,
(truthValue equations nonnegative positive i = true ↔ cell i ⊆ effectiveRationalSignConditionSet equations nonnegative positive)
retainedCells :
Finset (MvPolynomial (Fin r) ℚ) → Finset (MvPolynomial (Fin r) ℚ) → Finset (MvPolynomial (Fin r) ℚ) → Finset (Fin cellCount)
retained_exact :
∀ equations nonnegative positive
if
equations ⊆ input ∪ secondInput
and
nonnegative ⊆ input ∪ secondInput
and
positive ⊆ input ∪ secondInput
then
∀ i,
(i ∈ retainedCells equations nonnegative positive ↔ truthValue equations nonnegative positive i = true)
witness_projection_exact :
∀ equations nonnegative positive
if
equations ⊆ input ∪ secondInput
and
nonnegative ⊆ input ∪ secondInput
and
positive ⊆ input ∪ secondInput
then
∀ x,
((∃ y ∈ effectiveRationalSignConditionSet equations nonnegative positive, SameOnEffectiveCoordinates keep x y) ↔ ∃ i ∈ retainedCells equations nonnegative positive, ∃ y ∈ cell i, SameOnEffectiveCoordinates keep x y)
payload :
encoded_input :
EffectivePolynomialCodesRealize payload.input input
encoded_second_input :
EffectivePolynomialCodesRealize payload.secondInput secondInput
encoded_saturating :
payload.saturatingPolynomial.toPolynomial = saturating
encoded_groebner :
EffectivePolynomialCodesRealize payload.groebnerBasis groebnerBasis
encoded_elimination :
EffectivePolynomialCodesRealize payload.eliminationBasis eliminationBasis
encoded_intersection :
EffectivePolynomialCodesRealize payload.intersectionBasis intersectionBasis
encoded_saturation :
EffectivePolynomialCodesRealize payload.saturationBasis saturationBasis
encoded_projection :
EffectivePolynomialCodesRealize payload.projectionFamily projectionFamily
encoded_order :
payload.variableOrder = order
encoded_retained_variables :
payload.retainedVariables.Nodup ∧ payload.retainedVariables.toFinset = keep
encoded_cells :
payload.cellCertificates = List.ofFn cellCertificate
Every emitted prefix artifact is source-exact, realizes the dropped recursive geometry over
the corresponding stage family, presents the projected cell by signs from the decoded
input/generated family, and links exactly to all truth and retention rows for its source.
encoded_prefix_projection_certificates_sound :
∀ certificate ∈ payload.prefixProjectionCertificates,
∃ i : Fin cellCount,
order = certificate.eliminatedVariables ++ certificate.retainedVariables ∧
certificate.sourceCellIndex = i.val ∧
certificate.sourceCellCertificateCode = Encodable.encode (cellCertificate i) ∧
certificate.projectedGeometryCode = Encodable.encode certificate.projectedGeometry ∧
certificate.projectedGeometry.Realizes (effectiveCADFamilyAfterPrefix certificate.eliminatedVariables (rationalPolynomialFamilyToReal (input ∪ secondInput))) certificate.retainedVariables (prefixProjectedCell certificate.eliminatedVariables i) ∧
certificate.basicSignCondition.Realizes certificate.eliminatedVariables certificate.retainedVariables (effectiveCADFamilyAfterPrefix certificate.eliminatedVariables (rationalPolynomialFamilyToReal (input ∪ secondInput))) (prefixProjectedCell certificate.eliminatedVariables i) ∧
certificate.truthRowCodes
certificate.retentionRowCodes
Every split of the lifting order and every source cell has an emitted generic prefix
certificate.
encoded_prefix_projection_certificates_complete :
∀ eliminated retained
if
order = eliminated ++ retained
then
∀ i : Fin cellCount,
∃ certificate ∈ payload.prefixProjectionCertificates,
certificate.eliminatedVariables = eliminated ∧
certificate.retainedVariables = retained ∧
certificate.sourceCellIndex = i.val
encoded_truth_rows_sound :
∀ row ∈ payload.signRows,
∃ equations nonnegative positive,
row.query.Realizes equations nonnegative positive ∧
equations ⊆ input ∪ secondInput ∧
nonnegative ⊆ input ∪ secondInput ∧
positive ⊆ input ∪ secondInput ∧
∃ i : Fin cellCount,
row.cellIndex = i.val ∧ row.truth = truthValue equations nonnegative positive i
encoded_truth_rows_complete :
∀ equations nonnegative positive
if
equations ⊆ input ∪ secondInput
and
nonnegative ⊆ input ∪ secondInput
and
positive ⊆ input ∪ secondInput
then
∀ i,
∃ row ∈ payload.signRows,
row.query.Realizes equations nonnegative positive ∧
row.cellIndex = i.val ∧
row.truth = truthValue equations nonnegative positive i
encoded_retained_rows_sound :
∀ row ∈ payload.retainedCellRows,
∃ equations nonnegative positive,
row.query.Realizes equations nonnegative positive ∧
equations ⊆ input ∪ secondInput ∧
nonnegative ⊆ input ∪ secondInput ∧
positive ⊆ input ∪ secondInput ∧
row.retainedCellIndices.Nodup ∧
(∀ index ∈ row.retainedCellIndices, index < cellCount) ∧
∀ i : Fin cellCount,
(i.val ∈ row.retainedCellIndices ↔ i ∈ retainedCells equations nonnegative positive)
encoded_retained_rows_complete :
∀ equations nonnegative positive
if
equations ⊆ input ∪ secondInput
and
nonnegative ⊆ input ∪ secondInput
and
positive ⊆ input ∪ secondInput
trace_cell_outputs_exact :
(payload.trace.flatMap fun step => step.producedCellCertificateCodes)
= payload.cellCertificates.map Encodable.encode
trace_prefix_projection_outputs_exact :
(payload.trace.flatMap fun step => step.producedPrefixProjectionCertificateCodes)
= payload.prefixProjectionCertificates.map Encodable.encode
trace_prefix_projection_certificates_linked :
∀ certificate ∈ payload.prefixProjectionCertificates,
∃ step ∈ payload.trace,
step.Links .prefixCellProjection [payload.input ++ payload.secondInput ++ payload.projectionFamily] [] ∧
Encodable.encode certificate ∈ step.producedPrefixProjectionCertificateCodes
trace_truth_outputs_exact :
(payload.trace.flatMap fun step => step.producedTruthRowCodes)
= payload.signRows.map Encodable.encode
trace_retention_outputs_exact :
(payload.trace.flatMap fun step => step.producedRetentionRowCodes)
= payload.retainedCellRows.map Encodable.encode
trace_buchberger :
∃ step ∈ payload.trace,
step.Links .buchberger [payload.input ++ payload.secondInput] [payload.groebnerBasis]
trace_elimination :
∃ step ∈ payload.trace,
step.Links .elimination [payload.groebnerBasis] [payload.eliminationBasis]
trace_intersection :
∃ step ∈ payload.trace,
step.Links .idealIntersection [payload.input, payload.secondInput] [payload.intersectionBasis]
trace_saturation :
∃ step ∈ payload.trace,
step.Links .saturation [payload.input ++ payload.secondInput, [payload.saturatingPolynomial]] [payload.saturationBasis]
Every variable in the supplied CAD order is processed by one ordered, data-dependent
reducta/coefficient/discriminant/subresultant round. Each assembly step registers the
accumulated family consumed by the next round, and the final registered family is exactly the
payload projection family, so the closure cannot bypass the displayed rounds.
trace_projection_rounds :
EffectiveCADProjectionRoundChain payload.trace payload.variableOrder (payload.input ++ payload.secondInput) payload.projectionFamily 0
trace_projection :
∃ step ∈ payload.trace,
step.Links .projectionClosure [payload.input ++ payload.secondInput] [payload.projectionFamily]
trace_root_stage_present :
(∃ certificate ∈ payload.cellCertificates, certificate.geometry.RequiresRootIsolation) → ∃ step ∈ payload.trace, step.operation
= .rootIsolation
trace_section_stage_present :
(∃ certificate ∈ payload.cellCertificates, certificate.geometry.ContainsSection) → ∃ step ∈ payload.trace, step.operation
= .sectionLifting
trace_sector_stage_present :
(∃ certificate ∈ payload.cellCertificates, certificate.geometry.ContainsSector) → ∃ step ∈ payload.trace, step.operation
= .sectorLifting
trace_prefix_projection_stage_present :
payload.prefixProjectionCertificates
≠ [] → ∃ step ∈ payload.trace, step.operation = .prefixCellProjection
trace_truth_stage_present :
payload.signRows ≠ [] → ∃ step ∈ payload.trace, step.operation = .signConditionTruth
trace_retention_stage_present :
payload.retainedCellRows
≠ [] → ∃ step ∈ payload.trace, step.operation = .witnessCellRetention
trace_execution_exact :
∃ finalState,
EffectiveAlgebraTraceRuns payload.trace ⟨effectiveCanonicalPolynomialPool r ++ payload.input ++ payload.secondInput ++ [payload.saturatingPolynomial], [payload.input, payload.secondInput, payload.input ++ payload.secondInput, [payload.saturatingPolynomial]], [], [], [], [], []⟩ finalState ∧
(∀ required ∈ payload.input ++ payload.secondInput ++ [payload.saturatingPolynomial] ++ payload.groebnerBasis ++ payload.eliminationBasis ++ payload.intersectionBasis ++ payload.saturationBasis ++ payload.projectionFamily, required.AvailableIn finalState.polynomialPool) ∧
finalState.familyRegisters
= [payload.input, payload.secondInput, payload.input ++ payload.secondInput, [payload.saturatingPolynomial]] ++ (payload.trace.flatMap fun step => step.outputFamilies) ∧
finalState.reductumCertificateCodes
= payload.trace.flatMap (fun step => step.producedReductumCertificateCodes) ∧
finalState.cellCertificateCodes = payload.cellCertificates.map Encodable.encode ∧
finalState.prefixProjectionCertificateCodes
= payload.prefixProjectionCertificates.map Encodable.encode ∧
finalState.truthRowCodes = payload.signRows.map Encodable.encode ∧
finalState.retentionRowCodes = payload.retainedCellRows.map Encodable.encode
trace_artifact_outputs_charged :
∀ step ∈ payload.trace, step.ArtifactOutputsCharged
trace_artifact_kinds_correct :
∀ step ∈ payload.trace, step.ArtifactKindsCorrect
trace_sign_queries_charged :
∀ step ∈ payload.trace
if
step.operation ∈ [.rootIsolation, .prefixCellProjection, .signConditionTruth, .witnessCellRetention]
then
.exactAlgebraicSign ∈ step.primitiveOperations
trace_certified_sign_operations_charged :
payload.certifiedSignOperationCount
+ payload.prefixProjectionSignOperationCount
+ payload.signRows.length
+ payload.retainedCellRows.length
≤ (payload.trace.flatMap fun step => step.primitiveOperations).count .exactAlgebraicSign
trace_steps_nonempty :
∀ step ∈ payload.trace, step.primitiveOperations ≠ []
machineCode :
machineFuel :
ℕ
machine_halts :
machineCode.evaln machineFuel (Encodable.encode (r, payload.input, payload.secondInput, payload.saturatingPolynomial, payload.variableOrder, payload.retainedVariables))
= some (Encodable.encode payload)
One fully supplied rational real-CAD/QE job.
Definition (Lean source)
fields
r :
ℕ
suppliedInput :
suppliedSecondInput :
suppliedSaturating :
input :
secondInput :
saturating :
MvPolynomial (Fin r) ℚ
input_realizes :
EffectivePolynomialCodesRealize suppliedInput input
second_input_realizes :
EffectivePolynomialCodesRealize suppliedSecondInput secondInput
saturating_realizes :
suppliedSaturating.toPolynomial = saturating
retained_nodup :
suppliedRetainedVariables.Nodup
retained_realizes :
suppliedRetainedVariables.toFinset = keep
elimination_order :
IsEffectiveEliminationVariableOrder order keep
structure EffectiveDependentRationalCADJob Definition aux_EffectiveDependentRationalCADJob in the paper ↗
A rational CAD/QE job built from the exact ideal-intersection basis emitted by a completed dependent elimination pipeline. The CAD ambient may be larger than the observable-intersection ambient because later real source presentations can add witness and loading coordinates. intersectionToCAD is therefore an exact embedding, and input_from_intersection says that the first CAD input is precisely the computed basis after that injective rename, not an independently selected Groebner basis. The CAD job's secondInput remains available for the simultaneous real incidence and sign-query polynomials.
Definition (Lean source)
parameters
machineCode :
forwardJob reverseJob :
pipeline :
EffectiveDependentRationalEliminationPipeline machineCode forwardJob reverseJob sharedCoordinateRelation
fields
job :
input_from_intersection :
job.input
= effectiveRenameRationalFamily intersectionToCAD pipeline.intersectionResult.result.intersectionBasis
def sourcePolynomialCount
Input size charged to the rational CAD/QE job.
Definition (Lean source)
def EffectiveRationalCADJob.sourcePolynomialCount
(job : EffectiveRationalCADJob) : ℕ :=
job.input.card + job.secondInput.card + 1
def DegreeBoundedBy
A uniform degree bound for the rational CAD/QE job.
Definition (Lean source)
def EffectiveRationalCADJob.DegreeBoundedBy
(job : EffectiveRationalCADJob) (D : ℕ) : Prop :=
∀ P ∈ job.input ∪ job.secondInput ∪ {job.saturating}, P.totalDegree ≤ D
structure EffectiveRationalCADCompletedJob Definition aux_EffectiveRationalCADCompletedJob in the paper ↗
Exact rational CAD/QE output tied to the uniform machine code.
Definition (Lean source)
parameters
machineCode :
job :
fields
result :
EffectiveRationalGroebnerCADResult job.input job.secondInput job.order job.keep job.saturating
payload_uses_supplied_input :
result.payload.input = job.suppliedInput
payload_uses_supplied_second_input :
result.payload.secondInput = job.suppliedSecondInput
payload_uses_supplied_saturating :
result.payload.saturatingPolynomial = job.suppliedSaturating
payload_uses_supplied_order :
result.payload.variableOrder = job.order
payload_uses_supplied_retained_variables :
result.payload.retainedVariables = job.suppliedRetainedVariables
machine_code_eq :
result.machineCode = machineCode
def RationalComplexEliminationClosureTheorem Definition aux_RationalComplexEliminationClosureTheorem in the paper ↗
The general Cox--Little--O'Shea Closure Theorem after scalar extension to the algebraically closed field ℂ. It is stated for arbitrary rational input and retained coordinate blocks and contains no paper-specific object.
Definition (Lean source)
def RationalComplexEliminationClosureTheorem : Prop :=
∀ (r : ℕ) (input output : Finset (MvPolynomial (Fin r) ℚ))
(keep : Finset (Fin r)),
IsExactEliminationBasis input keep output →
IsExactComplexProjectionClosure input keep output
def UniversalEffectiveCombinedGroebnerCADBound Definition aux_UniversalEffectiveCombinedGroebnerCADBound in the paper ↗
Universal source-matched combined complexity certificate. The constants and all three uniform machine codes are fixed before every rational or Gaussian- rational algebra batch and before the rational CAD/QE input. In the dependent clause, the caller fixes the cross-source shared-coordinate relation before the two elimination results and their exact intersection result are returned; only then is a CAD/QE job consuming that pipeline's intersection basis quantified. The one displayed inequality charges the same returned pipeline and CAD/QE result together; partial-recursive fuel is deliberately absent from this cost statement.
Definition (Lean source)
def UniversalEffectiveCombinedGroebnerCADBound (a b : ℕ) : Prop :=
1 ≤ a ∧
∃ rationalAlgebraMachine gaussianAlgebraMachine rationalCADMachine :
Code,
(∀ (rationalJobs : List (EffectiveGroebnerJobOver ℚ))
(gaussianJobs : List (EffectiveGroebnerJobOver GaussianRational))
(cadJob : EffectiveRationalCADJob) (N s D : ℕ),
1 ≤ D →
effectiveGroebnerBatchSourcePolynomialCount rationalJobs +
effectiveGroebnerBatchSourcePolynomialCount gaussianJobs +
cadJob.sourcePolynomialCount ≤ s →
EffectiveGroebnerBatchInputsBounded rationalJobs N D →
EffectiveGroebnerBatchInputsBounded gaussianJobs N D →
cadJob.r ≤ N → cadJob.DegreeBoundedBy D →
∃ rationalResults : EffectiveGroebnerBatchResultsOver ℚ
rationalAlgebraMachine rationalJobs,
∃ gaussianResults : EffectiveGroebnerBatchResultsOver GaussianRational
gaussianAlgebraMachine gaussianJobs,
∃ cadResult : EffectiveRationalCADCompletedJob rationalCADMachine cadJob,
rationalResults.symbolicOperationCount +
gaussianResults.symbolicOperationCount +
cadResult.result.payload.symbolicOperationCount ≤
(max 2 (s * D)) ^ (2 ^ (a * N + b))) ∧
(∀ (forwardJob reverseJob : EffectiveGroebnerJobOver ℚ)
(sharedCoordinateRelation : Fin forwardJob.r → Fin reverseJob.r → Prop),
IsJointlyPresentableSharedCoordinateRelation sharedCoordinateRelation →
∃ pipeline : EffectiveDependentRationalEliminationPipeline
rationalAlgebraMachine forwardJob reverseJob sharedCoordinateRelation,
∀ (dependentCADJob : EffectiveDependentRationalCADJob pipeline)
(N s D : ℕ),
1 ≤ D →
forwardJob.sourcePolynomialCount + reverseJob.sourcePolynomialCount +
dependentCADJob.job.sourcePolynomialCount ≤ s →
forwardJob.r ≤ N → reverseJob.r ≤ N →
dependentCADJob.job.r ≤ N →
pipeline.DegreeBoundedBy D →
dependentCADJob.job.DegreeBoundedBy D →
∃ cadResult : EffectiveRationalCADCompletedJob rationalCADMachine
dependentCADJob.job,
pipeline.symbolicOperationCount +
cadResult.result.payload.symbolicOperationCount ≤
(max 2 (s * D)) ^ (2 ^ (a * N + b)))
def UniversalEffectiveRationalGroebnerCADBound Definition aux_UniversalEffectiveRationalGroebnerCADBound in the paper ↗
Backward-compatible public name used by atlas complexity certificates. It now denotes the single combined algebra-plus-CAD batch bound, not a separate rational-CAD-only inequality.
Definition (Lean source)
def UniversalEffectiveRationalGroebnerCADBound (a b : ℕ) : Prop :=
UniversalEffectiveCombinedGroebnerCADBound a b
def EffectiveRationalGroebnerCADInterface Definition aux_EffectiveRationalGroebnerCADInterface in the paper ↗
The complete general effective interface: uniform exact Gröbner algorithms on supplied presentations over ℚ and ℚ(i) and a rational specialization carrying both the algebraically closed elimination-closure theorem and real CAD, whose actual finite certificate/truth/retention outputs are produced by its bounded trace.
Definition (Lean source)
def EffectiveRationalGroebnerCADInterface : Prop :=
StandardFiniteBlockEliminationOrderInterface ∧
EffectiveGroebnerAlgorithmOver ℚ ∧
EffectiveGroebnerAlgorithmOver GaussianRational ∧
RationalComplexEliminationClosureTheorem ∧
∃ a b : ℕ, UniversalEffectiveRationalGroebnerCADBound a b
Effective rational Gröbner/CAD interface — cited external tool. For every finite polynomial presentation over ℚ or ℚ(i) and every effectively supplied admissible MonomialOrder, the interface supplies a terminating exact Buchberger/Gröbner computation, exact elimination output whenever the supplied order has the encoded elimination property, and exact ideal-intersection and saturation output, including a charged saturation–Gröbner–elimination chain. It also supplies a computably realized standard finite block-elimination order for every concrete retained block. For rational input it supplies the standard Closure Theorem after coefficient extension to ℂ: the elimination-basis zero set is exactly the Zariski closure of the input zero set's retained-coordinate projection. Its rational real-polynomial specialization additionally supplies an effective sign-invariant recursively section/sector CAD for the union of both supplied real sign families, with exact algebraic-root indices, cellwise sign truth, quantifier elimination by witness-cell retention, and, for every lifting-order prefix and source cell, an exact erased-prefix cell with dropped-layer recursive geometry, a finite basic sign presentation, and exact truth/retention-row links. All of these data are emitted by a finite certified symbolic trace. Polynomial and order presentations are supplied before output selection; the algorithm codes are fixed uniformly before those inputs, the supplied order code is required to realize the semantic monomial order, and injective encodings tie the bounded trace extensionally to every emitted cell certificate, root/sign row, truth row, and retained-witness row. An artifact-emission transition is permitted only after every polynomial presentation recursively contained in that artifact has already been computed extensionally in the trace's polynomial register.
Definition (Lean source)
-- @node: def:effective-rational-groebner-cad-interface
def effectiveRationalGroebnerCADOutput : Prop := EffectiveRationalGroebnerCADInterface
Helpers.CommonAxisImageGeometry 12 declarations General finite-affine image lemmas
General finite-affine image lemmas
def CommonAxisBandCoord
Proves the stated mathematical property of Common Axis Band Coord.
Definition (Lean source)
abbrev CommonAxisBandCoord (m L : ℕ) (hm : 1 ≤ m) :=
{c : BandParamCoord m L // c ≠ inr (inl (⟨0, hm⟩ : Fin m))}
def commonAxisBandInsert
Defines the mathematical object called the common Axis Band Insert.
Definition (Lean source)
def commonAxisBandInsert {m L : ℕ} (hm : 1 ≤ m)
(x : CommonAxisBandCoord m L hm → ℂ) : BandParamCoord m L → ℂ :=
fun c => if h : c = inr (inl (⟨0, hm⟩ : Fin m)) then 0 else x ⟨c, h⟩
def commonAxisParam
Defines the mathematical object called the common Axis Param.
Definition (Lean source)
def commonAxisParam {m L : ℕ} (hm : 1 ≤ m)
(x : CommonAxisBandCoord m L hm → ℂ) : ParamSpace ℂ m :=
decodeBandParam (commonAxisBandInsert hm x)
def commonAxisPolynomial
Defines the polynomial called the common Axis Polynomial.
Definition (Lean source)
def commonAxisPolynomial {m L : ℕ} (hm : 1 ≤ m)
(P : MvPolynomial (BandParamCoord m L) ℂ) :
MvPolynomial (CommonAxisBandCoord m L hm) ℂ :=
MvPolynomial.eval₂Hom C (fun c =>
if h : c = inr (inl (⟨0, hm⟩ : Fin m)) then 0
else X ⟨c, h⟩) P
theorem eval_commonAxisPolynomial
Proves that the map called the eval common Axis Polynomial is polynomial.
Formal statement
hypotheses
conclusion
eval x (commonAxisPolynomial hm P)
= eval (commonAxisBandInsert hm x) P
Proof (Lean source)
lemma eval_commonAxisPolynomial {m L : ℕ} (hm : 1 ≤ m)
(x : CommonAxisBandCoord m L hm → ℂ)
(P : MvPolynomial (BandParamCoord m L) ℂ) :
eval x (commonAxisPolynomial hm P) =
eval (commonAxisBandInsert hm x) P := by
change eval x (eval₂ C _ P) = _
rw [MvPolynomial.eval_eval₂]
have hC : (eval x).comp C = id ℂ := by
ext z
simp
rw [hC, MvPolynomial.eval₂_id]
apply congrArg (fun v => eval v P)
funext c
by_cases h : c = inr (inl (⟨0, hm⟩ : Fin m)) <;>
simp [commonAxisBandInsert, h]
def forwardCommonAxisFiniteMap
Defines the mathematical object called the forward Common Axis Finite Map.
Definition (Lean source)
def forwardCommonAxisFiniteMap (m L : ℕ) (hm : 1 ≤ m)
(x : CommonAxisBandCoord m L hm → ℂ) : RetainedCumCoord L → ℂ :=
restrictCumBand L (forwardCumulantMap m L (commonAxisParam hm x))
theorem forwardCommonAxisFiniteMap_isPolynomial
Proves that the map called the forward Common Axis Finite Map is Polynomial is polynomial.
Formal statement
hypotheses
m L :
ℕ
hm :
1 ≤ m
hL :
2 ≤ L
conclusion
Proof (Lean source)
lemma forwardCommonAxisFiniteMap_isPolynomial (m L : ℕ) (hm : 1 ≤ m)
(hL : 2 ≤ L) : IsPolynomialMap (forwardCommonAxisFiniteMap m L hm) := by
obtain ⟨coord, hcoord⟩ := forwardCumulantMap_isPolynomial m L
intro q
refine ⟨commonAxisParamPolynomial hm (coord (q.1.1, q.1.2.1)), ?_⟩
intro x
rw [eval_commonAxisParamPolynomial hL, hcoord]
rfl
def commonAxisSource
Defines the mathematical object called the common Axis Source.
Definition (Lean source)
def commonAxisSource (m L : ℕ) (hm : 1 ≤ m) :
Set (CommonAxisBandCoord m L hm → ℂ) :=
{x | eval x (commonAxisGenericPolynomial m L hm) ≠ 0}
theorem commonAxisSource_dense
Proves the stated mathematical property of common Axis Source dense.
Formal statement
hypotheses
m L :
ℕ
hm :
1 ≤ m
hL :
2 ≤ L
conclusion
Proof (Lean source)
lemma commonAxisSource_dense {m L : ℕ} (hm : 1 ≤ m) (hL : 2 ≤ L) :
affineZariskiClosure (commonAxisSource m L hm) = univ :=
affineZariskiClosure_nonvanishing_eq_univ _
(commonAxisGenericPolynomial_ne_zero hm hL)
theorem commonAxisFiniteImage_eq
Proves the stated equality or equivalence for common Axis Finite Image eq.
Formal statement
hypotheses
m L :
ℕ
hm :
1 ≤ m
hL :
2 ≤ L
conclusion
forwardCommonAxisFiniteMap m L hm '' commonAxisSource m L hm
= restrictCumBand L '' (forwardCumulantMap m L '' {θ | θ ∈ genericParameterLocus m L ∧ θ.2.1 ⟨0, hm⟩ = 0})
Proof (Lean source)
lemma commonAxisFiniteImage_eq (m L : ℕ) (hm : 1 ≤ m) (hL : 2 ≤ L) :
forwardCommonAxisFiniteMap m L hm '' commonAxisSource m L hm =
restrictCumBand L ''
(forwardCumulantMap m L ''
{θ | θ ∈ genericParameterLocus m L ∧ θ.2.1 ⟨0, hm⟩ = 0}) := by
ext y
constructor
· rintro ⟨x, hx, rfl⟩
refine ⟨forwardCumulantMap m L (commonAxisParam hm x), ?_, rfl⟩
refine ⟨commonAxisParam hm x, ⟨?_, commonAxisParam_axis hm x⟩, rfl⟩
rw [genericParameterLocus_eq_nonvanishing_poly]
refine ⟨commonAxisParam_supported hm x, ?_⟩
change eval x (commonAxisGenericPolynomial m L hm) ≠ 0 at hx
rw [commonAxisGenericPolynomial,
eval_commonAxisParamPolynomial hL] at hx
exact hx
· rintro ⟨_, ⟨θ, ⟨hgen, haxis⟩, rfl⟩, rfl⟩
let x : CommonAxisBandCoord m L hm → ℂ :=
commonAxisBandErase hm (encodeBandParam θ)
have hinsert : commonAxisBandInsert hm x = encodeBandParam θ := by
funext c
by_cases hc : c = inr (inl (⟨0, hm⟩ : Fin m))
· subst c
simp [x, commonAxisBandInsert, commonAxisBandErase,
encodeBandParam, haxis]
· simp [x, commonAxisBandInsert, commonAxisBandErase, hc]
have hparam : commonAxisParam hm x = θ := by
rw [commonAxisParam, hinsert,
decode_encodeBandParam hL (genericParameterLocus_bandSupported hgen)]
refine ⟨x, ?_, ?_⟩
· change eval x (commonAxisGenericPolynomial m L hm) ≠ 0
rw [commonAxisGenericPolynomial,
eval_commonAxisParamPolynomial hL, hparam,
eval_genericParameterPolynomial]
exact genericParameterLocus_prod_ne_zero hgen
· simp [forwardCommonAxisFiniteMap, hparam]
theorem restrictCumBand_image_zariskiClosure
Restriction to the retained band commutes with Zariski closure for a band-supported set.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma restrictCumBand_image_zariskiClosure {L : ℕ} {A : Set (CumVec ℂ)}
(hA : A ⊆ bandSupportedCumulants L) :
restrictCumBand L '' zariskiClosure A =
affineZariskiClosure (restrictCumBand L '' A) := by
ext x
constructor
· rintro ⟨t, ht, rfl⟩
exact (mem_zariskiClosure_iff_mem_affineZariskiClosure hA
(zariskiClosure_subset_band hA ht)).mp ht
· intro hx
let t := extendCumBand L x
have ht : t ∈ zariskiClosure A :=
(mem_zariskiClosure_iff_mem_affineZariskiClosure hA
(extendCumBand_mem_band L x)).mpr (by simpa [t] using hx)
exact ⟨t, ht, restrict_extendCumBand L x⟩
theorem restrict_forwardCommonAxisImageClosure_isIrreducible
The finite retained-coordinate closure of the explicit common-axis image is irreducible.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
Proof (Lean source)
theorem restrict_forwardCommonAxisImageClosure_isIrreducible
(m : ℕ) (hm : 1 ≤ m) :
IsIrreducibleAffineClosed
(restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) := by
let L := 2 * m + 2
let A : Set (CumVec ℂ) :=
forwardCumulantMap m L '' forwardCommonAxisDivisor m hm
have hA : A ⊆ bandSupportedCumulants L := by
rintro _ ⟨θ, _, rfl⟩
exact forwardCumulantMap_mem_bandSupportedCumulants m L θ
have himage : restrictCumBand L '' A =
forwardCommonAxisFiniteMap m L hm '' commonAxisSource m L hm := by
rw [commonAxisFiniteImage_eq m L hm (by omega)]
rfl
have hirr := irreducible_affineClosure_polynomial_image_of_dense
(forwardCommonAxisFiniteMap_isPolynomial m L hm (by omega))
(commonAxisSource_dense hm (by omega))
(commonAxisSource_nonempty hm (by omega))
change IsIrreducibleAffineClosed
(restrictCumBand L '' zariskiClosure A)
rw [restrictCumBand_image_zariskiClosure hA, himage]
exact hirr
Helpers.CommonAxisPrincipalEquations 4 declarations
theorem horizontalContractionMinor_mem_commonAxis_vanishingIdeal
The horizontal contraction minor is an actual equation of the finite common-axis image closure.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
horizontalContractionMinorPolynomial m ∈ vanishingIdeal ℂ (finiteCommonAxisImage m hm)
Proof (Lean source)
lemma horizontalContractionMinor_mem_commonAxis_vanishingIdeal
(m : ℕ) (hm : 1 ≤ m) :
horizontalContractionMinorPolynomial m ∈
vanishingIdeal ℂ (finiteCommonAxisImage m hm) := by
intro x hx
obtain ⟨t, ht, rfl⟩ := hx
exact forwardCommonAxisImageClosure_horizontalMinor_vanishes hm ht
theorem horizontalContractionMinor_not_mem_forward_vanishingIdeal
The same equation is nontrivial modulo the forward arrow-image ideal.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
horizontalContractionMinorPolynomial m ∉ vanishingIdeal ℂ (finiteForwardVariety m)
Proof (Lean source)
lemma horizontalContractionMinor_not_mem_forward_vanishingIdeal
(m : ℕ) (hm : 1 ≤ m) :
horizontalContractionMinorPolynomial m ∉
vanishingIdeal ℂ (finiteForwardVariety m) := by
intro hmem
let theta := forwardContractionMinorWitnessParameter m
let t := forwardCumulantMap m (2 * m + 2) theta
have ht : restrictCumBand (2 * m + 2) t ∈ finiteForwardVariety m :=
⟨t, subset_zariskiClosure _ ⟨theta, rfl⟩, rfl⟩
exact (horizontalContractionMinorPolynomial_forwardWitness_ne_zero m hm)
(hmem _ ht)
theorem verticalContractionMinor_mem_commonAxis_vanishingIdeal
Since the common-axis family lies in the exceptional locus and hence in the forward variety, the coordinate-reversed vertical minor is its second explicit principal equation.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
verticalContractionMinorPolynomial m ∈ vanishingIdeal ℂ (finiteCommonAxisImage m hm)
Proof (Lean source)
lemma verticalContractionMinor_mem_commonAxis_vanishingIdeal
(m : ℕ) (hm : 1 ≤ m) :
verticalContractionMinorPolynomial m ∈
vanishingIdeal ℂ (finiteCommonAxisImage m hm) := by
intro x hx
obtain ⟨t, ht, rfl⟩ := hx
apply verticalContractionMinorPolynomial_forwardVariety_vanishes m
exact genericCompatibilityClosure_subset_forwardVariety m
(forwardCommonAxisImageClosure_subset_exceptional hm ht)
theorem verticalContractionMinor_not_mem_reverse_vanishingIdeal
The vertical equation is nontrivial modulo the reverse arrow-image ideal, witnessed by the coordinate reversal of the forward block-Vandermonde point.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
verticalContractionMinorPolynomial m ∉ vanishingIdeal ℂ (finiteReverseVariety m)
Proof (Lean source)
lemma verticalContractionMinor_not_mem_reverse_vanishingIdeal
(m : ℕ) (hm : 1 ≤ m) :
verticalContractionMinorPolynomial m ∉
vanishingIdeal ℂ (finiteReverseVariety m) := by
intro hmem
let eta := axisReverseParameter m (forwardContractionMinorWitnessParameter m)
let t := reverseCumulantMap m (2 * m + 2) eta
have ht : restrictCumBand (2 * m + 2) t ∈ finiteReverseVariety m :=
⟨t, subset_zariskiClosure _ ⟨eta, rfl⟩, rfl⟩
exact (verticalContractionMinorPolynomial_reverseWitness_ne_zero m hm)
(hmem _ ht)
Helpers.CommonAxisReversal 11 declarations
def reverseRetainedCoordinates
Observable coordinate reversal on the finite retained affine space.
Definition (Lean source)
def reverseRetainedCoordinates {L : ℕ}
(x : RetainedCumCoord L → ℂ) : RetainedCumCoord L → ℂ :=
fun p => x (reverseRetainedCumCoord p)
theorem reverseRetainedCoordinates_involutive
Relabelling the retained cumulant coordinates by the observable coordinate exchange twice returns the original point of the retained affine space, so this relabelling is an involution there.
Formal statement
Proof (Lean source)
@[simp] lemma reverseRetainedCoordinates_involutive {L : ℕ}
(x : RetainedCumCoord L → ℂ) :
reverseRetainedCoordinates (reverseRetainedCoordinates x) = x := by
funext p
simp [reverseRetainedCoordinates]
theorem reverseRetainedCoordinates_isPolynomial
The observable coordinate exchange on the retained band is a polynomial map: each output coordinate is literally one of the input coordinates, hence a degree-one polynomial in them. This is what lets the exchange be pushed through Zariski closures.
Formal statement
Proof (Lean source)
lemma reverseRetainedCoordinates_isPolynomial (L : ℕ) :
IsPolynomialMap (@reverseRetainedCoordinates L) := by
intro p
exact ⟨MvPolynomial.X (reverseRetainedCumCoord p), by
intro x
simp [reverseRetainedCoordinates]⟩
theorem restrictCumBand_reverseCumCoordinates
Proves the stated mathematical property of restrict Cum Band reverse Cum Coordinates.
Formal statement
Proof (Lean source)
lemma restrictCumBand_reverseCumCoordinates {L : ℕ} (t : CumVec ℂ) :
restrictCumBand L (reverseCumCoordinates t) =
reverseRetainedCoordinates (restrictCumBand L t) := by
funext p
simp [restrictCumBand, reverseRetainedCoordinates,
reverseRetainedCumCoord, reverseCumCoordinates, p.2.2]
theorem reverseRetainedCoordinates_image_image
Proves the stated mathematical property of reverse Retained Coordinates image image.
Formal statement
hypotheses
L :
ℕ
A :
Set (RetainedCumCoord L → ℂ)
conclusion
reverseRetainedCoordinates '' (reverseRetainedCoordinates '' A) = A
Proof (Lean source)
lemma reverseRetainedCoordinates_image_image {L : ℕ}
(A : Set (RetainedCumCoord L → ℂ)) :
reverseRetainedCoordinates '' (reverseRetainedCoordinates '' A) = A := by
ext x
constructor
· rintro ⟨_, ⟨y, hy, rfl⟩, rfl⟩
simpa using hy
· intro hx
exact ⟨reverseRetainedCoordinates x,
⟨x, hx, rfl⟩,
reverseRetainedCoordinates_involutive x⟩
theorem polynomialInvolution_image_affineZariskiClosure
A polynomial involution commutes with affine Zariski closure.
Formal statement
hypotheses
conclusion
f '' affineZariskiClosure A = affineZariskiClosure (f '' A)
Proof (Lean source)
lemma polynomialInvolution_image_affineZariskiClosure
{ι : Type*} {f : (ι → ℂ) → (ι → ℂ)}
(hf : IsPolynomialMap f) (hinv : LeftInverse f f)
(A : Set (ι → ℂ)) :
f '' affineZariskiClosure A = affineZariskiClosure (f '' A) := by
apply Set.Subset.antisymm
· rintro y ⟨x, hx, rfl⟩
intro P hP
change eval (f x) P = 0
obtain ⟨Q, hQ⟩ := hf.eval_comp P
rw [← hQ x]
apply hx Q
intro z hz
have hz' := hP (f z) ⟨z, hz, rfl⟩
simpa [MvPolynomial.aeval_def, MvPolynomial.eval₂_id, hQ z] using hz'
· have hclosed : affineZariskiClosure (f '' affineZariskiClosure A) =
f '' affineZariskiClosure A :=
polynomial_image_closed_of_retract hf hf hinv
(affineZariskiClosure_idem A)
rw [← hclosed]
exact affineZariskiClosure_mono
(Set.image_mono (affineZariskiClosure_extensive A))
theorem reverseCumCoordinates_forward_range
Proves the stated mathematical property of reverse Cum Coordinates forward range.
Formal statement
Proof (Lean source)
lemma reverseCumCoordinates_forward_range (m L : ℕ) :
reverseCumCoordinates '' range (forwardCumulantMap m L) =
range (reverseCumulantMap m L) := by
ext t
constructor
· rintro ⟨_, ⟨θ, rfl⟩, rfl⟩
exact ⟨axisReverseParameter m θ,
reverseCumulantMap_axisReverseParameter m L θ⟩
· rintro ⟨η, rfl⟩
obtain ⟨θ, rfl⟩ := axisReverseParameter_map_surjective m η
exact ⟨forwardCumulantMap m L θ, ⟨θ, rfl⟩,
(reverseCumulantMap_axisReverseParameter m L θ).symm⟩
theorem reverseCumCoordinates_commonAxis_raw
Proves the stated mathematical property of reverse Cum Coordinates common Axis raw.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
= forwardCumulantMap m (2 * m + 2) '' forwardCommonAxisDivisor m hm
Proof (Lean source)
lemma reverseCumCoordinates_commonAxis_raw (m : ℕ) (hm : 1 ≤ m) :
reverseCumCoordinates ''
(forwardCumulantMap m (2 * m + 2) '' forwardCommonAxisDivisor m hm) =
forwardCumulantMap m (2 * m + 2) '' forwardCommonAxisDivisor m hm := by
let L := 2 * m + 2
let A := forwardCumulantMap m L '' forwardCommonAxisDivisor m hm
have hsubset : reverseCumCoordinates '' A ⊆ A := by
rintro _ ⟨_, ⟨θ, hθ, rfl⟩, rfl⟩
let η := commonAxisReverseTwin m hm θ
let θ' := axisReverseParameter m η
have hηgen : η ∈ genericParameterLocus m L :=
commonAxisReverseTwin_generic hm hθ
have hθ'gen : θ' ∈ genericParameterLocus m L :=
axisReverseParameter_generic hηgen
have hθ'axis : θ'.2.1 ⟨0, hm⟩ = 0 := by
simp [θ', axisReverseParameter, η, commonAxisReverseTwin]
refine ⟨θ', ⟨hθ'gen, hθ'axis⟩, ?_⟩
have htwin : reverseCumulantMap m L η = forwardCumulantMap m L θ :=
commonAxisReverseTwin_map_eq hm hθ.2
(gamma_ne_zero_of_generic hθ.1) (by
intro i hi
have hinj := rho_injective_of_generic hθ.1
intro hz
have heq : i = ⟨0, hm⟩ := hinj (hz.trans hθ.2.symm)
exact hi (congrArg val heq))
have hrev := reverseCumulantMap_axisReverseParameter m L θ'
have hparam : axisReverseParameter m θ' = η := by
simp [θ', axisReverseParameter_involutive]
rw [hparam] at hrev
have := congrArg reverseCumCoordinates hrev
simpa [reverseCumCoordinates_involutive, htwin] using this.symm
apply Set.Subset.antisymm hsubset
intro t ht
have hrt : reverseCumCoordinates t ∈ A :=
hsubset ⟨t, ht, rfl⟩
exact ⟨reverseCumCoordinates t, hrt,
reverseCumCoordinates_involutive t⟩
theorem reverseRetainedCoordinates_forwardVariety
Proves the stated mathematical property of reverse Retained Coordinates forward Variety.
Formal statement
hypotheses
m :
ℕ
conclusion
reverseRetainedCoordinates '' (restrictCumBand (2 * m + 2) '' cumulantImageVariety (forwardCumulantMap m (2 * m + 2)))
Proof (Lean source)
lemma reverseRetainedCoordinates_forwardVariety (m : ℕ) :
reverseRetainedCoordinates ''
(restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) =
restrictCumBand (2 * m + 2) ''
cumulantImageVariety (reverseCumulantMap m (2 * m + 2)) := by
let L := 2 * m + 2
let Af : Set (CumVec ℂ) := range (forwardCumulantMap m L)
let Ar : Set (CumVec ℂ) := range (reverseCumulantMap m L)
have hAf : Af ⊆ bandSupportedCumulants L := by
rintro _ ⟨θ, rfl⟩
exact forwardCumulantMap_mem_bandSupportedCumulants m L θ
have hAr : Ar ⊆ bandSupportedCumulants L := by
rintro _ ⟨η, rfl⟩
exact reverseCumulantMap_mem_bandSupportedCumulants m L η
change reverseRetainedCoordinates ''
(restrictCumBand L '' zariskiClosure Af) =
restrictCumBand L '' zariskiClosure Ar
rw [restrictCumBand_image_zariskiClosure hAf,
restrictCumBand_image_zariskiClosure hAr,
polynomialInvolution_image_affineZariskiClosure
(reverseRetainedCoordinates_isPolynomial L)
reverseRetainedCoordinates_involutive]
congr 1
rw [restrict_image_reverse, reverseCumCoordinates_forward_range]
theorem reverseRetainedCoordinates_commonAxisClosure
Proves the stated mathematical property of reverse Retained Coordinates common Axis Closure.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
= restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm
Proof (Lean source)
lemma reverseRetainedCoordinates_commonAxisClosure (m : ℕ) (hm : 1 ≤ m) :
reverseRetainedCoordinates ''
(restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) =
restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm := by
let L := 2 * m + 2
let A : Set (CumVec ℂ) :=
forwardCumulantMap m L '' forwardCommonAxisDivisor m hm
have hA : A ⊆ bandSupportedCumulants L := by
rintro _ ⟨θ, _, rfl⟩
exact forwardCumulantMap_mem_bandSupportedCumulants m L θ
change reverseRetainedCoordinates ''
(restrictCumBand L '' zariskiClosure A) =
restrictCumBand L '' zariskiClosure A
rw [restrictCumBand_image_zariskiClosure hA,
polynomialInvolution_image_affineZariskiClosure
(reverseRetainedCoordinates_isPolynomial L)
reverseRetainedCoordinates_involutive]
congr 1
rw [restrict_image_reverse, reverseCumCoordinates_commonAxis_raw]
theorem reverse_no_intermediate_of_forward
Coordinate reversal transfers the reverse no-intermediate statement from the forward one.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
hforward :
¬ ∃ Y, IsIrreducibleAffineClosed Y ∧ restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm ⊂ Y ∧ Y ⊂ restrictCumBand (2 * m + 2) '' cumulantImageVariety (forwardCumulantMap m (2 * m + 2))
conclusion
¬ ∃ Y, IsIrreducibleAffineClosed Y ∧ restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm ⊂ Y ∧ Y ⊂ restrictCumBand (2 * m + 2) '' cumulantImageVariety (reverseCumulantMap m (2 * m + 2))
Proof (Lean source)
theorem reverse_no_intermediate_of_forward (m : ℕ) (hm : 1 ≤ m)
(hforward : ¬ ∃ Y, IsIrreducibleAffineClosed Y ∧
restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm ⊂ Y ∧
Y ⊂ restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) :
¬ ∃ Y, IsIrreducibleAffineClosed Y ∧
restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm ⊂ Y ∧
Y ⊂ restrictCumBand (2 * m + 2) ''
cumulantImageVariety (reverseCumulantMap m (2 * m + 2)) := by
rintro ⟨Y, hY, hCY, hYX⟩
let R := @reverseRetainedCoordinates (2 * m + 2)
have hRinj : Injective R := by
intro x y h
have := congrArg R h
simpa [R] using this
apply hforward
refine ⟨R '' Y, ?_, ?_, ?_⟩
· exact irreducible_image_polynomial_retract
(reverseRetainedCoordinates_isPolynomial _) (reverseRetainedCoordinates_isPolynomial _)
reverseRetainedCoordinates_involutive hY
· rw [← reverseRetainedCoordinates_commonAxisClosure m hm]
exact image_ssubset_image_of_injective hRinj hCY
· have h := image_ssubset_image_of_injective hRinj hYX
have hvar :
restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2)) =
R '' (restrictCumBand (2 * m + 2) ''
cumulantImageVariety (reverseCumulantMap m (2 * m + 2))) := by
calc
_ = R '' (R '' (restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2)))) := by
symm
exact reverseRetainedCoordinates_image_image _
_ = _ := congrArg (fun S => R '' S)
(reverseRetainedCoordinates_forwardVariety m)
rw [← hvar] at h
exact h
Helpers.CommonAxisTwin 9 declarations
def forwardCommonAxisDivisor
The generic forward parameter divisor on which the first latent direction is the horizontal axis.
Definition (Lean source)
def forwardCommonAxisDivisor (m : ℕ) (hm : 1 ≤ m) : Set (ParamSpace ℂ m) :=
{θ | θ ∈ genericParameterLocus m (2 * m + 2) ∧ θ.2.1 ⟨0, hm⟩ = 0}
def commonAxisReverseTwin
Reverse parameters obtained by reciprocating every nonzero finite forward slope and cycling the two fixed axes with the zero latent direction.
Definition (Lean source)
def commonAxisReverseTwin (m : ℕ) (hm : 1 ≤ m) (θ : ParamSpace ℂ m) :
ParamSpace ℂ m :=
(θ.1⁻¹,
(fun i => if i.val = 0 then 0 else (θ.2.1 i)⁻¹),
fun j r =>
let c := θ.2.2 (commonAxisIndex m hm j) r
if hlast : j.val = m + 1 then c * θ.1 ^ r
else if htwo : 2 ≤ j.val then c * θ.2.1 ⟨j.val - 1, by omega⟩ ^ r
else c)
theorem commonAxisReverseTwin_bandSupported
If every source weight of a forward parameter point vanishes outside the retained orders two through 2m+2, the same holds for its common-axis reverse twin. The twin only relabels the sources and rescales each weight by a power of a slope, so it can create no weight outside the band.
Formal statement
hypotheses
conclusion
commonAxisReverseTwin m hm θ ∈ bandSupportedParams m (2 * m + 2)
Proof (Lean source)
lemma commonAxisReverseTwin_bandSupported {m : ℕ} (hm : 1 ≤ m)
{θ : ParamSpace ℂ m} (hθ : θ ∈ bandSupportedParams m (2 * m + 2)) :
commonAxisReverseTwin m hm θ ∈ bandSupportedParams m (2 * m + 2) := by
intro j r hr
simp only [commonAxisReverseTwin]
have hc : θ.2.2 (commonAxisIndex m hm j) r = 0 := hθ _ _ hr
simp [commonAxisReverseTwin, hc]
theorem commonAxisReverseTwin_generic
The reciprocal common-axis twin stays in the generic retained-band locus. This is the parameter-level symmetry needed to transport the common-axis closure through observable coordinate reversal.
Formal statement
hypotheses
conclusion
commonAxisReverseTwin m hm θ ∈ genericParameterLocus m (2 * m + 2)
Proof (Lean source)
lemma commonAxisReverseTwin_generic {m : ℕ} (hm : 1 ≤ m)
{θ : ParamSpace ℂ m} (hθ : θ ∈ forwardCommonAxisDivisor m hm) :
commonAxisReverseTwin m hm θ ∈ genericParameterLocus m (2 * m + 2) := by
let L := 2 * m + 2
let η := commonAxisReverseTwin m hm θ
have hband : η ∈ bandSupportedParams m L :=
commonAxisReverseTwin_bandSupported hm
(genericParameterLocus_bandSupported hθ.1)
have hγ : θ.1 ≠ 0 := gamma_ne_zero_of_generic hθ.1
have hρinj : Injective θ.2.1 := rho_injective_of_generic hθ.1
have hρ : ∀ i : Fin m, i.val ≠ 0 → θ.2.1 i ≠ 0 := by
intro i hi hzero
have heq : i = ⟨0, hm⟩ := hρinj (hzero.trans hθ.2.symm)
exact hi (congrArg val heq)
have hηγ : η.1 ≠ 0 := by
simp [η, commonAxisReverseTwin, hγ]
have hηρzero : η.2.1 ⟨0, hm⟩ = 0 := by
simp [η, commonAxisReverseTwin]
have hηρnz : ∀ i : Fin m, i.val ≠ 0 → η.2.1 i ≠ 0 := by
intro i hi
simp [η, commonAxisReverseTwin, hi, hρ i hi]
have hηρinj : Injective η.2.1 := by
intro i j hij
by_cases hi : i.val = 0
· have hi0 : i = ⟨0, hm⟩ := Fin.ext hi
subst i
by_contra hj
have hjv : j.val ≠ 0 := fun h => hj (Fin.ext h.symm)
exact hηρnz j hjv (hij ▸ hηρzero)
· by_cases hj : j.val = 0
· have hj0 : j = ⟨0, hm⟩ := Fin.ext hj
subst j
exact (hηρnz i hi (hij.trans hηρzero)).elim
· apply hρinj
have hinv := hij
simp [η, commonAxisReverseTwin, hi, hj] at hinv
exact hinv
have hηγρ : ∀ i : Fin m, η.1 ≠ η.2.1 i := by
intro i heq
by_cases hi : i.val = 0
· have hi0 : i = ⟨0, hm⟩ := Fin.ext hi
subst i
exact hηγ (heq.trans hηρzero)
· have hinv : θ.1⁻¹ = (θ.2.1 i)⁻¹ := by
simpa [η, commonAxisReverseTwin, hi] using heq
exact gamma_ne_rho_of_generic hθ.1 i (inv_injective hinv)
have hηw : ∀ (j : Fin (m + 2)) {r : ℕ}, r ∈ Icc 2 L →
η.2.2 j r ≠ 0 := by
intro j r hr
have hc : θ.2.2 (commonAxisIndex m hm j) r ≠ 0 :=
retainedWeight_ne_zero_of_generic hθ.1 _ hr
by_cases hlast : j.val = m + 1
· simp [η, commonAxisReverseTwin, hlast, hc, hγ]
· by_cases htwo : 2 ≤ j.val
· have hi : (⟨j.val - 1, by omega⟩ : Fin m).val ≠ 0 := by simp; omega
simp [η, commonAxisReverseTwin, hlast, htwo, hc,
hρ ⟨j.val - 1, by omega⟩ hi]
· simp [η, commonAxisReverseTwin, hlast, htwo, hc]
refine ⟨hband, ?_⟩
apply mul_ne_zero
· apply mul_ne_zero
· exact mul_ne_zero hηγ
(Finset.prod_ne_zero_iff.mpr (fun i _ => sub_ne_zero.mpr (hηγρ i)))
· apply Finset.prod_ne_zero_iff.mpr
intro i _
apply Finset.prod_ne_zero_iff.mpr
intro j _
by_cases hij : i < j
· simp only [hij, if_true]
exact sub_ne_zero.mpr (fun h => (ne_of_lt hij) (hηρinj h))
· simp [hij]
· apply Finset.prod_ne_zero_iff.mpr
intro j _
apply Finset.prod_ne_zero_iff.mpr
intro r hr
exact hηw j hr
theorem commonAxisReverseTwin_map_eq
Proves the stated equality or equivalence for common Axis Reverse Twin map eq.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
θ :
ParamSpace ℂ m
hzero :
θ.2.1 ⟨0, hm⟩ = 0
hγ :
θ.1 ≠ 0
hρ :
∀ i : Fin m
if
i.val ≠ 0
then
θ.2.1 i ≠ 0
conclusion
reverseCumulantMap m (2 * m + 2) (commonAxisReverseTwin m hm θ)
= forwardCumulantMap m (2 * m + 2) θ
Proof (Lean source)
lemma commonAxisReverseTwin_map_eq {m : ℕ} (hm : 1 ≤ m)
{θ : ParamSpace ℂ m} (hzero : θ.2.1 ⟨0, hm⟩ = 0)
(hγ : θ.1 ≠ 0)
(hρ : ∀ i : Fin m, i.val ≠ 0 → θ.2.1 i ≠ 0) :
reverseCumulantMap m (2 * m + 2) (commonAxisReverseTwin m hm θ) =
forwardCumulantMap m (2 * m + 2) θ := by
funext r a
simp only [reverseCumulantMap, forwardCumulantMap]
split
· rw [← Equiv.sum_comp (commonAxisPermutation m hm)
(fun j => θ.2.2 j r * (forwardLoading m θ.1 θ.2.1 j).1 ^ (r - a) *
(forwardLoading m θ.1 θ.2.1 j).2 ^ a)]
apply Finset.sum_congr rfl
intro j _
exact commonAxis_term_identity hm hzero hγ hρ r a (by omega) j
· rfl
theorem forwardCommonAxis_image_mem_exceptional
Proves the stated set-containment or membership property for forward Common Axis image mem exceptional.
Formal statement
hypotheses
conclusion
forwardCumulantMap m (2 * m + 2) θ ∈ genericFullFiberCompatibility m
Proof (Lean source)
lemma forwardCommonAxis_image_mem_exceptional {m : ℕ} (hm : 1 ≤ m)
{θ : ParamSpace ℂ m} (hθ : θ ∈ forwardCommonAxisDivisor m hm) :
forwardCumulantMap m (2 * m + 2) θ ∈ genericFullFiberCompatibility m := by
have hband := genericParameterLocus_bandSupported hθ.1
have htwinband := commonAxisReverseTwin_bandSupported hm hband
have hγ := gamma_ne_zero_of_generic hθ.1
have hρ : ∀ i : Fin m, i.val ≠ 0 → θ.2.1 i ≠ 0 := by
intro i hi hzeroi
have heq : i = ⟨0, hm⟩ := rho_injective_of_generic hθ.1 (hzeroi.trans hθ.2.symm)
exact hi (congrArg val heq)
refine ⟨forwardCumulantMap_mem_bandSupportedCumulants m (2 * m + 2) θ,
inl ⟨⟨θ, mem_fiberCorrespondence_self hband, hθ.1⟩, ?_⟩⟩
refine ⟨commonAxisReverseTwin m hm θ, htwinband, ?_⟩
intro r a hr hrL ha
exact congrFun (congrFun (commonAxisReverseTwin_map_eq hm hθ.2 hγ hρ) r) a
def forwardCommonAxisImageClosure
Closure of the common-axis image divisor inside the forward arrow variety.
Definition (Lean source)
def forwardCommonAxisImageClosure (m : ℕ) (hm : 1 ≤ m) : Set (CumVec ℂ) :=
zariskiClosure ((forwardCumulantMap m (2 * m + 2)) ''
forwardCommonAxisDivisor m hm)
theorem forwardCommonAxisImageClosure_subset_exceptional
The closure of the observable image of the common-axis divisor lies inside the closure of the generic full-fiber compatibility locus. Every truncated cumulant vector generated by a generic forward parameter whose first latent direction is the horizontal axis is therefore also generated by some reverse-arrow parameter, so the arrow direction is not pinned down there.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
Proof (Lean source)
lemma forwardCommonAxisImageClosure_subset_exceptional {m : ℕ} (hm : 1 ≤ m) :
forwardCommonAxisImageClosure m hm ⊆ genericCompatibilityClosure m := by
apply zariskiClosure_mono
rintro _ ⟨θ, hθ, rfl⟩
exact forwardCommonAxis_image_mem_exceptional hm hθ
theorem forwardCommonAxisImageClosure_horizontalMinor_vanishes
The explicit common-axis image closure lies on the observable horizontal contraction-minor hypersurface.
Formal statement
hypotheses
conclusion
= 0
Proof (Lean source)
lemma forwardCommonAxisImageClosure_horizontalMinor_vanishes
{m : ℕ} (hm : 1 ≤ m) {t : CumVec ℂ}
(ht : t ∈ forwardCommonAxisImageClosure m hm) :
eval (restrictCumBand (2 * m + 2) t)
(horizontalContractionMinorPolynomial m) = 0 := by
exact horizontalContractionMinorPolynomial_forwardCommonAxisClosure_vanishes hm ht
Helpers.CoordinateReversalGeometry 19 declarations
def reverseCumCoordinates
Exchange the two observable coordinates in every cumulant block.
Definition (Lean source)
def reverseCumCoordinates (t : CumVec ℂ) : CumVec ℂ :=
fun r a => if a ≤ r then t r (r - a) else t r a
theorem reverseCumCoordinates_apply_of_le
At a coordinate whose number of Y-copies does not exceed the cumulant order, the coordinate-reversed cumulant vector reproduces the original vector at the same order with the roles of the two observables interchanged: the entry of order r carrying a copies of Y is the original entry of order r carrying r − a copies.
Formal statement
Proof (Lean source)
@[simp] lemma reverseCumCoordinates_apply_of_le (t : CumVec ℂ)
{r a : ℕ} (ha : a ≤ r) :
reverseCumCoordinates t r a = t r (r - a) := by
simp [reverseCumCoordinates, ha]
theorem reverseCumCoordinates_involutive
Exchanging the two observable coordinates twice restores the original cumulant vector, so coordinate reversal is an involution of the cumulant space.
Formal statement
Proof (Lean source)
@[simp] lemma reverseCumCoordinates_involutive (t : CumVec ℂ) :
reverseCumCoordinates (reverseCumCoordinates t) = t := by
funext r a
by_cases ha : a ≤ r
· simp [reverseCumCoordinates, ha, Nat.sub_sub_self ha]
· simp [reverseCumCoordinates, ha]
def axisSourceReversal
Reverse the source order at the two fixed axes.
Definition (Lean source)
def axisReverseParameter
The same slope coordinates and weights, with the two fixed-axis sources exchanged. Observable coordinate reversal turns this forward parameter into a reverse parameter.
Definition (Lean source)
def axisReverseParameter (m : ℕ) (theta : ParamSpace ℂ m) : ParamSpace ℂ m :=
(theta.1, theta.2.1, fun j r => theta.2.2 (axisSourceReversal m j) r)
theorem axisSourceReversal_involutive
Exchanging the two fixed-axis source labels twice returns the original source label, so the axis reversal is an involution of the source index set.
Formal statement
Proof (Lean source)
@[simp] lemma axisSourceReversal_involutive (m : ℕ) (j : Fin (m + 2)) :
axisSourceReversal m (axisSourceReversal m j) = j := by
exact Equiv.apply_symm_apply (axisSourceReversal m) j
theorem axisReverseParameter_involutive
Applying the axis reversal twice returns the original parameter point: the direct and latent slopes are never touched, and the source-weight families attached to the two fixed axes are exchanged back into place.
Formal statement
hypotheses
m :
ℕ
theta :
ParamSpace ℂ m
conclusion
axisReverseParameter m (axisReverseParameter m theta) = theta
Proof (Lean source)
@[simp] lemma axisReverseParameter_involutive (m : ℕ)
(theta : ParamSpace ℂ m) :
axisReverseParameter m (axisReverseParameter m theta) = theta := by
rcases theta with ⟨γ, ρ, w⟩
simp [axisReverseParameter]
theorem reverseCumulantMap_axisReverseParameter
Honest coordinate reversal identifies the two polynomial arrow maps.
Formal statement
hypotheses
m L :
ℕ
theta :
ParamSpace ℂ m
conclusion
reverseCumulantMap m L (axisReverseParameter m theta)
= reverseCumCoordinates (forwardCumulantMap m L theta)
Proof (Lean source)
lemma reverseCumulantMap_axisReverseParameter (m L : ℕ)
(theta : ParamSpace ℂ m) :
reverseCumulantMap m L (axisReverseParameter m theta) =
reverseCumCoordinates (forwardCumulantMap m L theta) := by
funext r a
by_cases ha : a ≤ r
· simp only [reverseCumulantMap, reverseCumCoordinates_apply_of_le _ ha,
forwardCumulantMap]
by_cases hr : 2 ≤ r ∧ r ≤ L
· rw [if_pos ⟨hr.1, hr.2, ha⟩]
have hra : r - a ≤ r := Nat.sub_le r a
rw [if_pos ⟨hr.1, hr.2, hra⟩]
calc
_ = ∑ j : Fin (m + 2),
theta.2.2 (axisSourceReversal m j) r *
(forwardLoading m theta.1 theta.2.1
(axisSourceReversal m j)).1 ^ a *
(forwardLoading m theta.1 theta.2.1
(axisSourceReversal m j)).2 ^ (r - a) := by
apply Finset.sum_congr rfl
intro j _
rw [reverseLoading_axisReverseParameter]
simp only [axisReverseParameter]
ring
_ = ∑ j : Fin (m + 2),
theta.2.2 j r *
(forwardLoading m theta.1 theta.2.1 j).1 ^ a *
(forwardLoading m theta.1 theta.2.1 j).2 ^ (r - a) :=
by
simpa using Equiv.sum_comp (axisSourceReversal m)
(fun j : Fin (m + 2) =>
theta.2.2 j r *
(forwardLoading m theta.1 theta.2.1 j).1 ^ a *
(forwardLoading m theta.1 theta.2.1 j).2 ^ (r - a))
_ = _ := by
apply Finset.sum_congr rfl
intro j _
rw [Nat.sub_sub_self ha]
· have hleft : ¬ (2 ≤ r ∧ r ≤ L ∧ a ≤ r) := by aesop
have hright : ¬ (2 ≤ r ∧ r ≤ L ∧ r - a ≤ r) := by aesop
rw [if_neg hleft, if_neg hright]
· have hleft : ¬ (2 ≤ r ∧ r ≤ L ∧ a ≤ r) := by aesop
simp [reverseCumCoordinates, ha, reverseCumulantMap, forwardCumulantMap, hleft]
theorem axisReverseParameter_bandSupported
Proves the stated mathematical property of axis Reverse Parameter band Supported.
Formal statement
Proof (Lean source)
lemma axisReverseParameter_bandSupported {m L : ℕ}
{theta : ParamSpace ℂ m} (htheta : theta ∈ bandSupportedParams m L) :
axisReverseParameter m theta ∈ bandSupportedParams m L := by
intro j r hr
exact htheta (axisSourceReversal m j) r hr
theorem axisReverseParameter_generic
Proves the stated mathematical property of axis Reverse Parameter generic.
Formal statement
Proof (Lean source)
lemma axisReverseParameter_generic {m L : ℕ}
{theta : ParamSpace ℂ m} (htheta : theta ∈ genericParameterLocus m L) :
axisReverseParameter m theta ∈ genericParameterLocus m L := by
refine ⟨axisReverseParameter_bandSupported
(genericParameterLocus_bandSupported htheta), ?_⟩
let base := theta.1 * (∏ i : Fin m, (theta.1 - theta.2.1 i)) *
(∏ i : Fin m, ∏ i' : Fin m,
if i < i' then theta.2.1 i - theta.2.1 i' else 1)
have hw : (∏ j : Fin (m + 2), ∏ r ∈ Icc 2 L,
theta.2.2 (axisSourceReversal m j) r) =
∏ j : Fin (m + 2), ∏ r ∈ Icc 2 L, theta.2.2 j r := by
simpa using Equiv.prod_comp (axisSourceReversal m)
(fun j : Fin (m + 2) => ∏ r ∈ Icc 2 L, theta.2.2 j r)
change base * (∏ j : Fin (m + 2), ∏ r ∈ Icc 2 L,
theta.2.2 (axisSourceReversal m j) r) ≠ 0
rw [hw]
exact genericParameterLocus_prod_ne_zero htheta
theorem reverseCumCoordinates_mem_band
Proves the stated set-containment or membership property for reverse Cum Coordinates mem band.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma reverseCumCoordinates_mem_band {L : ℕ} {t : CumVec ℂ}
(ht : t ∈ bandSupportedCumulants L) :
reverseCumCoordinates t ∈ bandSupportedCumulants L := by
intro r a hout
by_cases ha : a ≤ r
· rw [reverseCumCoordinates_apply_of_le _ ha]
apply ht
omega
· simp [reverseCumCoordinates, ha, ht r a hout]
def reverseRetainedCumCoord
Coordinate reversal on finite retained cumulant coordinates.
Definition (Lean source)
def reverseRetainedCumCoord {L : ℕ} (p : RetainedCumCoord L) :
RetainedCumCoord L :=
⟨(p.1.1, ⟨p.1.1 - p.1.2.1, by omega⟩), p.2.1, Nat.sub_le _ _⟩
theorem reverseRetainedCumCoord_involutive
Reversing a retained cumulant coordinate twice gives back the original coordinate: at a fixed order r the position carrying a copies of Y is sent to the one carrying r − a copies, and back again.
Formal statement
hypotheses
L :
ℕ
p :
conclusion
Proof (Lean source)
@[simp] lemma reverseRetainedCumCoord_involutive {L : ℕ}
(p : RetainedCumCoord L) :
reverseRetainedCumCoord (reverseRetainedCumCoord p) = p := by
apply Subtype.ext
apply Prod.ext
· rfl
· apply Fin.ext
simp [reverseRetainedCumCoord, Nat.sub_sub_self p.2.2]
def verticalContractionMinorPolynomial
The coordinate-reversed observable contraction minor.
Definition (Lean source)
def verticalContractionMinorPolynomial (m : ℕ) :
MvPolynomial (RetainedCumCoord (2 * m + 2)) ℂ :=
rename reverseRetainedCumCoord
(horizontalContractionMinorPolynomial m)
theorem eval_verticalContractionMinorPolynomial
Evaluating the vertical contraction minor on the retained band of a cumulant vector gives the same number as evaluating the horizontal contraction minor on the retained band of the coordinate-reversed vector: the vertical minor is exactly the horizontal one read in the exchanged observable coordinates.
Formal statement
hypotheses
m :
ℕ
t :
CumVec ℂ
conclusion
= eval (restrictCumBand (2 * m + 2) (reverseCumCoordinates t)) (horizontalContractionMinorPolynomial m)
Proof (Lean source)
lemma eval_verticalContractionMinorPolynomial (m : ℕ) (t : CumVec ℂ) :
eval (restrictCumBand (2 * m + 2) t)
(verticalContractionMinorPolynomial m) =
eval
(restrictCumBand (2 * m + 2) (reverseCumCoordinates t))
(horizontalContractionMinorPolynomial m) := by
rw [verticalContractionMinorPolynomial, MvPolynomial.eval_rename]
apply congrArg (fun f => eval f (horizontalContractionMinorPolynomial m))
funext p
simp [Function.comp_apply, restrictCumBand, reverseRetainedCumCoord,
reverseCumCoordinates, p.2.2]
theorem verticalContractionMinorPolynomial_forward_vanishes
Proves the stated mathematical property of vertical Contraction Minor Polynomial forward vanishes.
Formal statement
hypotheses
m :
ℕ
theta :
ParamSpace ℂ m
conclusion
eval (restrictCumBand (2 * m + 2) (forwardCumulantMap m (2 * m + 2) theta)) (verticalContractionMinorPolynomial m)
= 0
Proof (Lean source)
lemma verticalContractionMinorPolynomial_forward_vanishes (m : ℕ)
(theta : ParamSpace ℂ m) :
eval
(restrictCumBand (2 * m + 2)
(forwardCumulantMap m (2 * m + 2) theta))
(verticalContractionMinorPolynomial m) = 0 := by
rw [eval_verticalContractionMinorPolynomial]
rw [← reverseCumulantMap_axisReverseParameter]
exact horizontalContractionMinorPolynomial_reverse_vanishes m
(axisReverseParameter m theta)
theorem verticalContractionMinorPolynomial_forwardVariety_vanishes
The vertical minor vanishes on the entire forward arrow-image variety.
Formal statement
hypotheses
conclusion
= 0
Proof (Lean source)
lemma verticalContractionMinorPolynomial_forwardVariety_vanishes (m : ℕ)
{t : CumVec ℂ}
(ht : t ∈ cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) :
eval (restrictCumBand (2 * m + 2) t)
(verticalContractionMinorPolynomial m) = 0 := by
have htband : t ∈ bandSupportedCumulants (2 * m + 2) := by
apply zariskiClosure_subset_band
(A := range (forwardCumulantMap m (2 * m + 2)))
· rintro _ ⟨theta, rfl⟩
exact forwardCumulantMap_mem_bandSupportedCumulants m (2 * m + 2) theta
· exact ht
rw [← eval_extendCumPolynomial (2 * m + 2)
(restrictCumBand (2 * m + 2) t) (verticalContractionMinorPolynomial m)]
rw [extend_restrictCumBand htband]
apply ht (extendCumPolynomial (2 * m + 2)
(verticalContractionMinorPolynomial m))
rintro _ ⟨theta, rfl⟩
rw [← extend_restrictCumBand
(forwardCumulantMap_mem_bandSupportedCumulants m (2 * m + 2) theta)]
rw [eval_extendCumPolynomial]
exact verticalContractionMinorPolynomial_forward_vanishes m theta
theorem verticalContractionMinorPolynomial_reverseWitness_ne_zero
The mirrored block-Vandermonde witness makes the vertical minor nonzero on the reverse arrow image.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
eval (restrictCumBand (2 * m + 2) (reverseCumulantMap m (2 * m + 2) (axisReverseParameter m (forwardContractionMinorWitnessParameter m)))) (verticalContractionMinorPolynomial m)
≠ 0
Proof (Lean source)
lemma verticalContractionMinorPolynomial_reverseWitness_ne_zero
(m : ℕ) (hm : 1 ≤ m) :
eval
(restrictCumBand (2 * m + 2)
(reverseCumulantMap m (2 * m + 2)
(axisReverseParameter m (forwardContractionMinorWitnessParameter m))))
(verticalContractionMinorPolynomial m) ≠ 0 := by
rw [eval_verticalContractionMinorPolynomial,
reverseCumulantMap_axisReverseParameter, reverseCumCoordinates_involutive]
exact horizontalContractionMinorPolynomial_forwardWitness_ne_zero m hm
theorem verticalContractionMinorPolynomial_ne_zero
With at least one latent confounder the vertical contraction-minor polynomial is not the zero polynomial: the mirrored block-Vandermonde reverse parameter produces an observable vector at which it does not vanish.
Formal statement
Proof (Lean source)
lemma verticalContractionMinorPolynomial_ne_zero (m : ℕ) (hm : 1 ≤ m) :
verticalContractionMinorPolynomial m ≠ 0 := by
intro hzero
exact (verticalContractionMinorPolynomial_reverseWitness_ne_zero m hm)
(by rw [hzero, map_zero])
Helpers.DirectLatentSwaps 14 declarations
def latentSourceIndex
The source index i+1 belonging to the i-th latent loading.
Definition (Lean source)
θ' interchanges the complete forward direct-source pair with latent pair i.
Definition (Lean source)
def IsForwardDirectLatentSwap {m : ℕ} (i : Fin m)
(θ θ' : ParamSpace ℂ m) : Prop :=
θ'.1 = θ.2.1 i ∧
θ'.2.1 = update θ.2.1 i θ.1 ∧
θ'.2.2 = update
(update θ.2.2 (0 : Fin (m + 2)) (θ.2.2 (latentSourceIndex i)))
(latentSourceIndex i) (θ.2.2 0)
η' interchanges the complete reverse direct-source pair with latent pair i.
Definition (Lean source)
def IsReverseDirectLatentSwap {m : ℕ} (i : Fin m)
(η η' : ParamSpace ℂ m) : Prop :=
η'.1 = η.2.1 i ∧
η'.2.1 = update η.2.1 i η.1 ∧
η'.2.2 = update
(update η.2.2 (last (m + 1)) (η.2.2 (latentSourceIndex i)))
(latentSourceIndex i) (η.2.2 (last (m + 1)))
The unordered finite-slope part of either arrow support.
Definition (Lean source)
def loadingSlopeMultiset {m : ℕ} (θ : ParamSpace ℂ m) : Multiset ℂ :=
θ.1 ::ₘ (Finset.univ.val.map (fun i => θ.2.1 i))
def forwardDirectLatentSwap
The concrete forward direct/latent swap.
Definition (Lean source)
def forwardDirectLatentSwap {m : ℕ} (i : Fin m) (θ : ParamSpace ℂ m) :
ParamSpace ℂ m :=
(θ.2.1 i, update θ.2.1 i θ.1,
update
(update θ.2.2 (0 : Fin (m + 2)) (θ.2.2 (latentSourceIndex i)))
(latentSourceIndex i) (θ.2.2 0))
def reverseDirectLatentSwap
The concrete reverse direct/latent swap.
Definition (Lean source)
def reverseDirectLatentSwap {m : ℕ} (i : Fin m) (η : ParamSpace ℂ m) :
ParamSpace ℂ m :=
(η.2.1 i, update η.2.1 i η.1,
update
(update η.2.2 (last (m + 1)) (η.2.2 (latentSourceIndex i)))
(latentSourceIndex i) (η.2.2 (last (m + 1))))
theorem forwardDirectLatentSwap_spec
The explicitly constructed forward swap really does interchange the direct source with the i-th latent source: the new direct slope is the old i-th latent slope, the new i-th latent slope is the old direct slope, and the source-weight families of the two sources are exchanged.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma forwardDirectLatentSwap_spec {m : ℕ} (i : Fin m) (θ : ParamSpace ℂ m) :
IsForwardDirectLatentSwap i θ (forwardDirectLatentSwap i θ) := by
exact ⟨rfl, rfl, rfl⟩
theorem reverseDirectLatentSwap_spec
The explicitly constructed reverse swap really does interchange the reverse arrow's direct source with the i-th latent source: the new direct slope is the old i-th latent slope, the new i-th latent slope is the old direct slope, and the source-weight families of the two sources are exchanged.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma reverseDirectLatentSwap_spec {m : ℕ} (i : Fin m) (η : ParamSpace ℂ m) :
IsReverseDirectLatentSwap i η (reverseDirectLatentSwap i η) := by
exact ⟨rfl, rfl, rfl⟩
theorem forwardDirectLatentSwap_generic
Proves the stated mathematical property of forward Direct Latent Swap generic.
Formal statement
hypotheses
conclusion
forwardDirectLatentSwap i θ ∈ genericParameterLocus m L
Proof (Lean source)
lemma forwardDirectLatentSwap_generic {m L : ℕ} (i : Fin m) (θ : ParamSpace ℂ m)
(hθ : θ ∈ genericParameterLocus m L) (hρi : θ.2.1 i ≠ 0) :
forwardDirectLatentSwap i θ ∈ genericParameterLocus m L := by
apply generic_of_coordinates
· intro j r hr
simp only [forwardDirectLatentSwap]
by_cases hji : j = latentSourceIndex i
· subst j
simp [latentSourceIndex_ne_zero, genericParameterLocus_bandSupported hθ _ r hr]
by_cases hj0 : j = 0
· subst j
simp [hji, latentSourceIndex_ne_zero,
genericParameterLocus_bandSupported hθ (latentSourceIndex i) r hr]
simp [hji, hj0, genericParameterLocus_bandSupported hθ j r hr]
· exact hρi
· intro j
by_cases hji : j = i
· subst j
simpa [forwardDirectLatentSwap] using (gamma_ne_rho_of_generic hθ i).symm
· simpa [forwardDirectLatentSwap, hji] using
(rho_injective_of_generic hθ).ne (Ne.symm hji)
· intro j k hjk
by_cases hji : j = i
· subst j
by_cases hki : k = i
· exact hki.symm
· simp [forwardDirectLatentSwap, hki] at hjk
exact ((gamma_ne_rho_of_generic hθ k) hjk).elim
· by_cases hki : k = i
· subst k
simp [forwardDirectLatentSwap, hji] at hjk
exact ((gamma_ne_rho_of_generic hθ j) hjk.symm).elim
· simp [forwardDirectLatentSwap, hji, hki] at hjk
exact (rho_injective_of_generic hθ) hjk
· intro j r hr
have hw := retained_weight_ne_zero_of_generic hθ
simp only [forwardDirectLatentSwap]
by_cases hji : j = latentSourceIndex i
· subst j
simpa [latentSourceIndex_ne_zero] using hw (0 : Fin (m + 2)) r hr
by_cases hj0 : j = 0
· subst j
simpa [hji, latentSourceIndex_ne_zero] using hw (latentSourceIndex i) r hr
simpa [hji, hj0] using hw j r hr
theorem reverseDirectLatentSwap_generic
Proves the stated mathematical property of reverse Direct Latent Swap generic.
Formal statement
hypotheses
conclusion
reverseDirectLatentSwap i η ∈ genericParameterLocus m L
Proof (Lean source)
lemma reverseDirectLatentSwap_generic {m L : ℕ} (i : Fin m) (η : ParamSpace ℂ m)
(hη : η ∈ genericParameterLocus m L) (hσi : η.2.1 i ≠ 0) :
reverseDirectLatentSwap i η ∈ genericParameterLocus m L := by
apply generic_of_coordinates
· intro j r hr
simp only [reverseDirectLatentSwap]
by_cases hji : j = latentSourceIndex i
· subst j
simp [latentSourceIndex_ne_last, genericParameterLocus_bandSupported hη _ r hr]
by_cases hjl : j = last (m + 1)
· subst j
simp [hji, latentSourceIndex_ne_last,
genericParameterLocus_bandSupported hη (latentSourceIndex i) r hr]
simp [hji, hjl, genericParameterLocus_bandSupported hη j r hr]
· exact hσi
· intro j
by_cases hji : j = i
· subst j
simpa [reverseDirectLatentSwap] using (gamma_ne_rho_of_generic hη i).symm
· simpa [reverseDirectLatentSwap, hji] using
(rho_injective_of_generic hη).ne (Ne.symm hji)
· intro j k hjk
by_cases hji : j = i
· subst j
by_cases hki : k = i
· exact hki.symm
· simp [reverseDirectLatentSwap, hki] at hjk
exact ((gamma_ne_rho_of_generic hη k) hjk).elim
· by_cases hki : k = i
· subst k
simp [reverseDirectLatentSwap, hji] at hjk
exact ((gamma_ne_rho_of_generic hη j) hjk.symm).elim
· simp [reverseDirectLatentSwap, hji, hki] at hjk
exact (rho_injective_of_generic hη) hjk
· intro j r hr
have hw := retained_weight_ne_zero_of_generic hη
simp only [reverseDirectLatentSwap]
by_cases hji : j = latentSourceIndex i
· subst j
simpa [latentSourceIndex_ne_last] using hw (last (m + 1)) r hr
by_cases hjl : j = last (m + 1)
· subst j
simpa [hji, latentSourceIndex_ne_last] using hw (latentSourceIndex i) r hr
simpa [hji, hjl] using hw j r hr
theorem forwardCumulantMap_directLatentSwap
Proves the stated mathematical property of forward Cumulant Map direct Latent Swap.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma forwardCumulantMap_directLatentSwap {m L : ℕ} (i : Fin m) (θ : ParamSpace ℂ m) :
forwardCumulantMap m L (forwardDirectLatentSwap i θ) = forwardCumulantMap m L θ := by
funext r a
simp only [forwardCumulantMap]
split
· calc
_ = ∑ j : Fin (m + 2),
θ.2.2 (Equiv.swap (0 : Fin (m + 2)) (latentSourceIndex i) j) r *
(forwardLoading m θ.1 θ.2.1
(Equiv.swap (0 : Fin (m + 2)) (latentSourceIndex i) j)).1 ^ (r - a) *
(forwardLoading m θ.1 θ.2.1
(Equiv.swap (0 : Fin (m + 2)) (latentSourceIndex i) j)).2 ^ a := by
apply Finset.sum_congr rfl
intro j _
exact forward_swap_summand i θ j r a
_ = _ := Equiv.sum_comp (Equiv.swap (0 : Fin (m + 2)) (latentSourceIndex i))
(fun j : Fin (m + 2) =>
θ.2.2 j r * (forwardLoading m θ.1 θ.2.1 j).1 ^ (r - a) *
(forwardLoading m θ.1 θ.2.1 j).2 ^ a)
· rfl
theorem reverseCumulantMap_directLatentSwap
Proves the stated mathematical property of reverse Cumulant Map direct Latent Swap.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma reverseCumulantMap_directLatentSwap {m L : ℕ} (i : Fin m) (η : ParamSpace ℂ m) :
reverseCumulantMap m L (reverseDirectLatentSwap i η) = reverseCumulantMap m L η := by
funext r a
simp only [reverseCumulantMap]
split
· calc
_ = ∑ j : Fin (m + 2),
η.2.2 (Equiv.swap (last (m + 1)) (latentSourceIndex i) j) r *
(reverseLoading m η.1 η.2.1
(Equiv.swap (last (m + 1)) (latentSourceIndex i) j)).1 ^ (r - a) *
(reverseLoading m η.1 η.2.1
(Equiv.swap (last (m + 1)) (latentSourceIndex i) j)).2 ^ a := by
apply Finset.sum_congr rfl
intro j _
exact reverse_swap_summand i η j r a
_ = _ := Equiv.sum_comp
(Equiv.swap (last (m + 1)) (latentSourceIndex i))
(fun j : Fin (m + 2) =>
η.2.2 j r * (reverseLoading m η.1 η.2.1 j).1 ^ (r - a) *
(reverseLoading m η.1 η.2.1 j).2 ^ a)
· rfl
theorem forwardDirectLatentSwap_not_mem_admissibleOrbit
Proves the stated set-containment or membership property for forward Direct Latent Swap not mem admissible Orbit.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma forwardDirectLatentSwap_not_mem_admissibleOrbit {m : ℕ} (i : Fin m)
(θ : ParamSpace ℂ m) (hneq : θ.1 ≠ θ.2.1 i) :
forwardDirectLatentSwap i θ ∉ admissibleOrbit θ := by
rintro ⟨π, hπ⟩
have := congrArg fst hπ
exact hneq (by simpa [forwardDirectLatentSwap, admissibleSourceSwap] using this.symm)
theorem reverseDirectLatentSwap_not_mem_admissibleOrbit
Proves the stated set-containment or membership property for reverse Direct Latent Swap not mem admissible Orbit.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma reverseDirectLatentSwap_not_mem_admissibleOrbit {m : ℕ} (i : Fin m)
(η : ParamSpace ℂ m) (hneq : η.1 ≠ η.2.1 i) :
reverseDirectLatentSwap i η ∉ admissibleOrbit η := by
rintro ⟨π, hπ⟩
have := congrArg fst hπ
exact hneq (by simpa [reverseDirectLatentSwap, admissibleSourceSwap] using this.symm)
Helpers.EmptyFiber 2 declarations
theorem forward_reverse_fiber_empty
A point satisfying the forward apolar rank conditions has no reverse-arrow parameterization with the same truncated cumulants.
Formal statement
hypotheses
conclusion
fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2)) (forwardCumulantMap m (2 * m + 2) θ)
= (∅ : Set (ParamSpace ℂ m))
Proof (Lean source)
theorem forward_reverse_fiber_empty (m : ℕ) (θ : ParamSpace ℂ m)
(hslopes : Injective
(fun j : Fin (m + 1) => (forwardLoading m θ.1 θ.2.1 (castSucc j)).2))
(hγ : θ.1 ≠ 0) (hρ : ∀ i, θ.2.1 i ≠ 0)
(hnonzero : ∀ j : Fin (m + 1),
(forwardLoading m θ.1 θ.2.1 (castSucc j)).2 ≠ 0)
(hrank : Injective (forwardWeightedContraction m θ)) :
fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2))
(forwardCumulantMap m (2 * m + 2) θ) = (∅ : Set (ParamSpace ℂ m)) := by
ext η
simp only [Set.mem_empty_iff_false, iff_false]
intro hη
rcases hη with ⟨_hband, hηband⟩
-- `fiberCorrespondence` compares the two cumulant vectors on the retained band only;
-- both maps vanish off the band by construction, so band-equality gives full equality.
have hη : reverseCumulantMap m (2 * m + 2) η =
forwardCumulantMap m (2 * m + 2) θ := by
funext r a
by_cases hb : 2 ≤ r ∧ r ≤ 2 * m + 2 ∧ a ≤ r
· exact hηband r a hb.1 hb.2.1 hb.2.2
· simp [reverseCumulantMap, forwardCumulantMap, hb]
let Qr := supportAnnihilator (reverseLoading m η.1 η.2.1)
let Qf := supportAnnihilator (forwardLoading m θ.1 θ.2.1)
have hQrHom : Qr.IsHomogeneous (m + 2) :=
supportAnnihilator_isHomogeneous _
have hQrRev : ∀ k, k ≤ m → diffApply Qr
(dividedPowerBlock (reverseCumulantMap m (2 * m + 2) η) (m + 2 + k)) = 0 :=
reverse_supportAnnihilator_in_contraction_kernel m η Qr hQrHom ⟨1, by simp [Qr]⟩
have hQrFwd : ∀ k, k ≤ m → diffApply Qr
(dividedPowerBlock (forwardCumulantMap m (2 * m + 2) θ) (m + 2 + k)) = 0 := by
simpa [hη] using hQrRev
obtain ⟨c, hc⟩ :=
(forward_apolar_kernel_identity m θ hslopes hnonzero hrank Qr hQrHom).mp hQrFwd
have hdivQr : X (1 : Fin 2) ∣ Qr := by
simpa [Qr] using X1_dvd_supportAnnihilator_reverse η.1 η.2.1
have hnDivQf : ¬ X (1 : Fin 2) ∣ Qf := by
simpa [Qf] using
not_X1_dvd_supportAnnihilator_forward θ.1 θ.2.1 hγ hρ
have hQrNe : Qr ≠ 0 := by
apply supportAnnihilator_ne_zero (reverseLoading m η.1 η.2.1)
intro j
by_cases hj0 : j.val = 0
· left
simp [reverseLoading, hj0]
· right
simp only [reverseLoading, hj0, ↓reduceDIte]
split <;> simp
by_cases hc0 : c = 0
· apply hQrNe
rw [hc, hc0]
simp
· apply hnDivQf
obtain ⟨p, hp⟩ := hdivQr
refine ⟨MvPolynomial.C c⁻¹ * p, ?_⟩
rw [hc] at hp
simp only [MvPolynomial.smul_eq_C_mul] at hp
calc
Qf = C c⁻¹ * (C c * Qf) := by
rw [← mul_assoc, ← MvPolynomial.C_mul, inv_mul_cancel₀ hc0, map_one, one_mul]
_ = C c⁻¹ * (X (1 : Fin 2) * p) := by rw [← hp]
_ = X (1 : Fin 2) * (C c⁻¹ * p) := by ring
theorem reverse_forward_fiber_empty
A point satisfying the reverse apolar rank conditions has no forward-arrow parameterization with the same truncated cumulants.
Formal statement
hypotheses
m :
ℕ
η :
ParamSpace ℂ m
hslopes :
hδ :
η.1 ≠ 0
hσ :
∀ i, η.2.1 i ≠ 0
hnonzero :
∀ j : Fin (m + 1), (reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0
hrank :
conclusion
fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2)) (reverseCumulantMap m (2 * m + 2) η)
= (∅ : Set (ParamSpace ℂ m))
Proof (Lean source)
theorem reverse_forward_fiber_empty (m : ℕ) (η : ParamSpace ℂ m)
(hslopes : Injective
(fun j : Fin (m + 1) => (reverseLoading m η.1 η.2.1 j.succ).1))
(hδ : η.1 ≠ 0) (hσ : ∀ i, η.2.1 i ≠ 0)
(hnonzero : ∀ j : Fin (m + 1), (reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0)
(hrank : Injective (reverseWeightedContraction m η)) :
fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2))
(reverseCumulantMap m (2 * m + 2) η) = (∅ : Set (ParamSpace ℂ m)) := by
ext θ
simp only [Set.mem_empty_iff_false, iff_false]
intro hθ
rcases hθ with ⟨_hband, hθband⟩
-- band-equality gives full equality: both cumulant maps vanish off the retained band.
have hθ : forwardCumulantMap m (2 * m + 2) θ =
reverseCumulantMap m (2 * m + 2) η := by
funext r a
by_cases hb : 2 ≤ r ∧ r ≤ 2 * m + 2 ∧ a ≤ r
· exact hθband r a hb.1 hb.2.1 hb.2.2
· simp [forwardCumulantMap, reverseCumulantMap, hb]
let Qf := supportAnnihilator (forwardLoading m θ.1 θ.2.1)
let Qr := supportAnnihilator (reverseLoading m η.1 η.2.1)
have hQfHom : Qf.IsHomogeneous (m + 2) :=
supportAnnihilator_isHomogeneous _
have hQfFwd : ∀ k, k ≤ m → diffApply Qf
(dividedPowerBlock (forwardCumulantMap m (2 * m + 2) θ) (m + 2 + k)) = 0 :=
forward_supportAnnihilator_in_contraction_kernel m θ Qf hQfHom ⟨1, by simp [Qf]⟩
have hQfRev : ∀ k, k ≤ m → diffApply Qf
(dividedPowerBlock (reverseCumulantMap m (2 * m + 2) η) (m + 2 + k)) = 0 := by
simpa [hθ] using hQfFwd
obtain ⟨c, hc⟩ :=
(reverse_apolar_kernel_identity m η hslopes hnonzero hrank Qf hQfHom).mp hQfRev
have hdivQf : X (0 : Fin 2) ∣ Qf := by
simpa [Qf] using X0_dvd_supportAnnihilator_forward θ.1 θ.2.1
have hnDivQr : ¬ X (0 : Fin 2) ∣ Qr := by
simpa [Qr] using
not_X0_dvd_supportAnnihilator_reverse η.1 η.2.1 hδ hσ
have hQfNe : Qf ≠ 0 := by
apply supportAnnihilator_ne_zero (forwardLoading m θ.1 θ.2.1)
intro j
by_cases hjlast : j.val = m + 1
· right
simp [forwardLoading, hjlast]
· left
simp only [forwardLoading]
split <;> simp_all
by_cases hc0 : c = 0
· apply hQfNe
rw [hc, hc0]
simp
· apply hnDivQr
obtain ⟨p, hp⟩ := hdivQf
refine ⟨MvPolynomial.C c⁻¹ * p, ?_⟩
rw [hc] at hp
simp only [MvPolynomial.smul_eq_C_mul] at hp
calc
Qr = C c⁻¹ * (C c * Qr) := by
rw [← mul_assoc, ← MvPolynomial.C_mul, inv_mul_cancel₀ hc0, map_one, one_mul]
_ = C c⁻¹ * (X (0 : Fin 2) * p) := by rw [← hp]
_ = X (0 : Fin 2) * (C c⁻¹ * p) := by ring
Helpers.ExceptionalCodimension 4 declarations
C is an irreducible component of the Zariski-closed set Z.
Definition (Lean source)
def IsIrreducibleComponent (C Z : Set (CumVec ℂ)) : Prop :=
IsIrreducibleZariskiClosed C ∧ C ⊆ Z ∧
∀ C', IsIrreducibleZariskiClosed C' → C ⊆ C' → C' ⊆ Z → C' = C
Exact minimum codimension of a closed set in an ambient irreducible variety, measured by strict irreducible chains from its components.
Definition (Lean source)
def HasCodimensionIn (d : ℕ) (Z X : Set (CumVec ℂ)) : Prop :=
(∀ C, IsIrreducibleComponent C Z →
∃ chain : Fin (d + 1) → Set (CumVec ℂ),
StrictMono chain ∧ (∀ i, IsIrreducibleZariskiClosed (chain i)) ∧
chain 0 = C ∧ chain (last d) = X) ∧
∃ C, IsIrreducibleComponent C Z ∧
¬ ∃ chain : Fin (d + 2) → Set (CumVec ℂ),
StrictMono chain ∧ (∀ i, IsIrreducibleZariskiClosed (chain i)) ∧
chain 0 = C ∧ chain (last (d + 1)) = X
theorem not_of_one
Exact codimension one excludes every claimed exact codimension d ≥ 2.
Formal statement
hypotheses
conclusion
¬ HasCodimensionIn d Z X
Proof (Lean source)
lemma HasCodimensionIn.not_of_one {Z X : Set (CumVec ℂ)}
(h1 : HasCodimensionIn 1 Z X) {d : ℕ} (hd : 2 ≤ d) :
¬ HasCodimensionIn d Z X := by
rintro hdimen
obtain ⟨C, hC, hno3⟩ := h1.2
obtain ⟨chain, hmono, hirr, hzero, hlast⟩ := hdimen.1 C hC
apply hno3
refine ⟨chain ∘ threeIndices d hd, hmono.comp (threeIndices_strictMono d hd),
?_, ?_, ?_⟩
· exact fun i => hirr (threeIndices d hd i)
· rw [Function.comp_apply, threeIndices_zero, hzero]
· rw [Function.comp_apply, threeIndices_last, hlast]
theorem hasCodimensionIn_one_of_component
A proper closed subset of an irreducible ambient has codimension at least one; one component with no intermediate irreducible closed set makes the minimum codimension exactly one.
Formal statement
hypotheses
hX :
hZX :
Z ⊆ X
hne :
Z ≠ X
hw :
∃ C
if
IsIrreducibleComponent C Z ∧ ¬ ∃ chain : Fin 3
then
conclusion
HasCodimensionIn 1 Z X
Proof (Lean source)
lemma hasCodimensionIn_one_of_component
{Z X : Set (CumVec ℂ)}
(hX : IsIrreducibleZariskiClosed X)
(hZX : Z ⊆ X) (hne : Z ≠ X)
(hw : ∃ C, IsIrreducibleComponent C Z ∧
¬ ∃ chain : Fin 3 → Set (CumVec ℂ),
StrictMono chain ∧ (∀ i, IsIrreducibleZariskiClosed (chain i)) ∧
chain 0 = C ∧ chain (last 2) = X) :
HasCodimensionIn 1 Z X := by
constructor
· intro C hC
have hCX : C ⊂ X := by
refine Set.ssubset_iff_subset_ne.mpr ⟨hC.2.1.trans hZX, ?_⟩
intro hEq
apply hne
apply Set.Subset.antisymm hZX
simpa [hEq] using hC.2.1
refine ⟨twoSetChain C X, twoSetChain_strictMono hCX, ?_, rfl, rfl⟩
intro i
fin_cases i
· exact hC.1
· exact hX
· exact hw
Helpers.ExceptionalCommonAxisJacobianTop 29 declarations Differentiating after pinning the common-axis variable
Differentiating after pinning the common-axis variable
theorem pderiv_commonAxisPolynomial
Pinning one variable to zero commutes with partial differentiation in every retained variable.
Formal statement
hypotheses
conclusion
pderiv c (commonAxisPolynomial hm P)
= commonAxisPolynomial hm (pderiv c.1 P)
Proof (Lean source)
theorem pderiv_commonAxisPolynomial {m L : ℕ} (hm : 1 ≤ m)
(c : CommonAxisBandCoord m L hm)
(P : MvPolynomial (BandParamCoord m L) ℂ) :
pderiv c (commonAxisPolynomial hm P) =
commonAxisPolynomial hm (pderiv c.1 P) := by
classical
induction P using MvPolynomial.induction_on with
| C a => simp [commonAxisPolynomial]
| add P Q hP hQ =>
rw [commonAxisPolynomial_add, map_add, map_add, hP, hQ,
commonAxisPolynomial_add]
| mul_X P d hP =>
rw [commonAxisPolynomial_mul, MvPolynomial.pderiv_mul,
MvPolynomial.pderiv_mul, commonAxisPolynomial_add,
commonAxisPolynomial_mul, commonAxisPolynomial_mul, hP]
by_cases hd : d = inr (inl (⟨0, hm⟩ : Fin m))
· subst d
have hne :
(inr (inl (⟨0, hm⟩ : Fin m)) : BandParamCoord m L) ≠
c.1 := by
intro h
exact c.2 h.symm
simp [commonAxisPolynomial, hne, hP]
· by_cases hdc : d = c.1
· subst d
simp [commonAxisPolynomial, c.2, hP, mul_comm]
· have hsub : (⟨d, hd⟩ : CommonAxisBandCoord m L hm) ≠ c := by
intro h
exact hdc (congrArg val h)
simp [commonAxisPolynomial, hd, hdc, hsub, hP]
theorem eval_pderiv_commonAxisPolynomial
Evaluation form of pderiv_commonAxisPolynomial.
Formal statement
hypotheses
m L :
ℕ
hm :
1 ≤ m
x :
CommonAxisBandCoord m L hm → ℂ
c :
CommonAxisBandCoord m L hm
P :
MvPolynomial (BandParamCoord m L) ℂ
conclusion
Proof (Lean source)
theorem eval_pderiv_commonAxisPolynomial {m L : ℕ} (hm : 1 ≤ m)
(x : CommonAxisBandCoord m L hm → ℂ)
(c : CommonAxisBandCoord m L hm)
(P : MvPolynomial (BandParamCoord m L) ℂ) :
eval x
(pderiv c (commonAxisPolynomial hm P)) =
eval (commonAxisBandInsert hm x)
(pderiv c.1 P) := by
rw [pderiv_commonAxisPolynomial, eval_commonAxisPolynomial]
theorem commonAxisPolynomial_forwardBandCoordinatePolynomial_eq
The canonical common-axis coordinate is the pinned canonical full coordinate.
Formal statement
hypotheses
conclusion
commonAxisPolynomial hm (forwardBandCoordinatePolynomial m L hL q)
= forwardCommonAxisCoordinatePolynomial m L hm hL q
Proof (Lean source)
theorem commonAxisPolynomial_forwardBandCoordinatePolynomial_eq
(m L : ℕ) (hm : 1 ≤ m) (hL : 2 ≤ L) (q : RetainedCumCoord L) :
commonAxisPolynomial hm (forwardBandCoordinatePolynomial m L hL q) =
forwardCommonAxisCoordinatePolynomial m L hm hL q := by
apply MvPolynomial.funext
intro x
rw [eval_commonAxisPolynomial, eval_forwardBandCoordinatePolynomial]
exact (Classical.choose_spec
(forwardCommonAxisFiniteMap_isPolynomial m L hm hL q) x).symm
theorem pderiv_forwardCommonAxisCoordinatePolynomial
Partial derivatives of the canonical common-axis coordinate can be computed in the full coordinate family and then pinned.
Formal statement
hypotheses
conclusion
pderiv c (forwardCommonAxisCoordinatePolynomial m L hm hL q)
Proof (Lean source)
theorem pderiv_forwardCommonAxisCoordinatePolynomial
(m L : ℕ) (hm : 1 ≤ m) (hL : 2 ≤ L)
(q : RetainedCumCoord L) (c : CommonAxisBandCoord m L hm) :
pderiv c
(forwardCommonAxisCoordinatePolynomial m L hm hL q) =
commonAxisPolynomial hm
(pderiv c.1
(forwardBandCoordinatePolynomial m L hL q)) := by
rw [← commonAxisPolynomial_forwardBandCoordinatePolynomial_eq,
pderiv_commonAxisPolynomial]
theorem eval_pderiv_forwardCommonAxisCoordinatePolynomial
Evaluation transfer from a common-axis Jacobian entry to the full Jacobian at the inserted parameter point.
Formal statement
hypotheses
conclusion
Proof (Lean source)
theorem eval_pderiv_forwardCommonAxisCoordinatePolynomial
(m L : ℕ) (hm : 1 ≤ m) (hL : 2 ≤ L)
(q : RetainedCumCoord L) (c : CommonAxisBandCoord m L hm)
(x : CommonAxisBandCoord m L hm → ℂ) :
eval x
(pderiv c
(forwardCommonAxisCoordinatePolynomial m L hm hL q)) =
eval (commonAxisBandInsert hm x)
(pderiv c.1
(forwardBandCoordinatePolynomial m L hL q)) := by
rw [pderiv_forwardCommonAxisCoordinatePolynomial,
eval_commonAxisPolynomial]
def commonAxisJacobianWitnessCoord
Common-axis witness: the deleted latent slope is zero after insertion; the direct slope is one, all other latent slopes are i+1, and every retained weight is one.
Definition (Lean source)
def commonAxisJacobianWitnessCoord (m : ℕ) (hm : 1 ≤ m) :
CommonAxisBandCoord m (2 * m + 2) hm → ℂ
| ⟨Sum.inl _, _⟩ => 1
| ⟨Sum.inr (inl i), _⟩ => ((i.val + 1 : ℕ) : ℂ)
| ⟨Sum.inr (inr _), _⟩ => 1
def commonAxisNodeSource
The finite source permutation puts the pinned latent source first and the direct source second.
Definition (Lean source)
def commonAxisNodeSource (m : ℕ) (hm : 1 ≤ m) (j : Fin (m + 1)) :
Fin (m + 2) :=
if h0 : j.val = 0 then ⟨1, by omega⟩
else if h1 : j.val = 1 then ⟨0, by omega⟩
else ⟨j.val, by omega⟩
def commonAxisNodeValue
The permuted finite nodes are 0,1,...,m.
Definition (Lean source)
def commonAxisNodeValue (m : ℕ) (j : Fin (m + 1)) : ℂ :=
(j.val : ℂ)
theorem commonAxisNodeValue_injective
The permuted finite nodes carry pairwise distinct values, since node j is assigned the number j itself and the nodes are 0, 1, ..., m.
Formal statement
Proof (Lean source)
theorem commonAxisNodeValue_injective (m : ℕ) :
Injective (commonAxisNodeValue m) := by
intro i j h
apply Fin.ext
exact_mod_cast (show (i.val : ℂ) = j.val by simpa [commonAxisNodeValue] using h)
theorem commonAxisJacobianWitness_insert_direct
Reinstating the pinned latent-slope coordinate at the common-axis witness leaves the direct slope equal to one.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
Proof (Lean source)
lemma commonAxisJacobianWitness_insert_direct (m : ℕ) (hm : 1 ≤ m) :
commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm)
(inl ()) = 1 := by
simp only [commonAxisBandInsert]
rw [dif_neg]
· rfl
· intro h
cases h
theorem commonAxisJacobianWitness_insert_latent
Proves the stated mathematical property of common Axis Jacobian Witness insert latent.
Formal statement
hypotheses
conclusion
= if i = ⟨0, hm⟩ then 0 else ((i.val + 1 : ℕ) : ℂ)
Proof (Lean source)
lemma commonAxisJacobianWitness_insert_latent (m : ℕ) (hm : 1 ≤ m)
(i : Fin m) :
commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm)
(inr (inl i)) =
if i = ⟨0, hm⟩ then 0 else ((i.val + 1 : ℕ) : ℂ) := by
by_cases hi : i = ⟨0, hm⟩
· subst i
simp [commonAxisBandInsert]
· simp only [commonAxisBandInsert]
rw [dif_neg]
· simp [hi, commonAxisJacobianWitnessCoord]
· intro h
apply hi
exact Sum.inl.inj (Sum.inr.inj h)
theorem commonAxisJacobianWitness_insert_weight
Proves the stated mathematical property of common Axis Jacobian Witness insert weight.
Formal statement
hypotheses
conclusion
= 1
Proof (Lean source)
lemma commonAxisJacobianWitness_insert_weight (m : ℕ) (hm : 1 ≤ m)
(j : Fin (m + 2)) (k : Fin (2 * m + 1)) :
commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm)
(inr (inr (j, k))) = 1 := by
simp only [commonAxisBandInsert]
rw [dif_neg]
· rfl
· intro h
cases Sum.inr.inj h
theorem commonAxisJacobianWitness_loading
Loading evaluation at the inserted common-axis witness.
Formal statement
hypotheses
conclusion
forwardLoading m (decodeBandParam (commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).1 (decodeBandParam (commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).2.1 (commonAxisNodeSource m hm j)
= (1, commonAxisNodeValue m j)
Proof (Lean source)
theorem commonAxisJacobianWitness_loading (m : ℕ) (hm : 1 ≤ m)
(j : Fin (m + 1)) :
forwardLoading m
(decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).1
(decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).2.1
(commonAxisNodeSource m hm j) =
(1, commonAxisNodeValue m j) := by
by_cases h0 : j.val = 0
· have hm0 : m ≠ 0 := by omega
simp [commonAxisNodeSource, h0, commonAxisNodeValue, forwardLoading,
decodeBandParam, hm0]
exact commonAxisJacobianWitness_insert_latent m hm ⟨0, hm⟩
· by_cases h1 : j.val = 1
· simp [commonAxisNodeSource, h0, h1, commonAxisNodeValue, forwardLoading,
decodeBandParam]
exact commonAxisJacobianWitness_insert_direct m hm
· have hjpos : 0 < j.val := Nat.pos_of_ne_zero h0
have hjlast : j.val ≠ m + 1 := by omega
have hidx :
(⟨j.val - 1, by omega⟩ : Fin m) ≠ ⟨0, hm⟩ := by
intro h
have hv := congrArg val h
simp at hv
omega
simp [commonAxisNodeSource, h0, h1, commonAxisNodeValue, forwardLoading,
decodeBandParam, hjlast]
simp only [commonAxisBandInsert]
rw [dif_neg]
· simp [commonAxisJacobianWitnessCoord]
norm_cast
omega
· intro h
apply hidx
exact Sum.inl.inj (Sum.inr.inj h)
theorem commonAxisJacobianWitness_weight
Proves the stated mathematical property of common Axis Jacobian Witness weight.
Formal statement
hypotheses
conclusion
= 1
Proof (Lean source)
theorem commonAxisJacobianWitness_weight (m : ℕ) (hm : 1 ≤ m)
(j : Fin (m + 2)) (r : ℕ) (hr : 2 ≤ r ∧ r ≤ 2 * m + 2) :
(decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).2.2 j r = 1 := by
rw [show (decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).2.2 j r =
commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm)
(inr (inr (j, ⟨r - 2, by omega⟩))) by
simp only [decodeBandParam]
rw [dif_pos hr]]
exact commonAxisJacobianWitness_insert_weight m hm _ _
theorem commonAxisJacobianWitness_loading_last
Proves the stated mathematical property of common Axis Jacobian Witness loading last.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
forwardLoading m (decodeBandParam (commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).1 (decodeBandParam (commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).2.1 (last (m + 1))
= (0, 1)
Proof (Lean source)
lemma commonAxisJacobianWitness_loading_last (m : ℕ) (hm : 1 ≤ m) :
forwardLoading m
(decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).1
(decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).2.1
(last (m + 1)) = (0, 1) := by
simp [forwardLoading, decodeBandParam, commonAxisBandInsert,
commonAxisJacobianWitnessCoord, last]
def CommonAxisTopIndex
Proves the stated mathematical property of Common Axis Top Index.
Definition (Lean source)
def commonAxisTopRow
Defines the mathematical object called the common Axis Top Row.
Definition (Lean source)
def commonAxisTopRow (m : ℕ) (a : CommonAxisTopIndex m) :
RetainedCumCoord (2 * m + 2) :=
⟨(⟨2 * m + 2, by omega⟩,
⟨pinnedExponent a, by
have h := pinnedExponent_lt (n := m + 1) a
omega⟩),
by change 2 ≤ 2 * m + 2; omega,
by
change pinnedExponent a ≤ 2 * m + 2
have h := pinnedExponent_lt (n := m + 1) a
omega⟩
def commonAxisUnpinnedSlope
The slope associated with the derivative node i+1: the first is the direct slope; all later ones are their same-index latent slopes.
Definition (Lean source)
def commonAxisUnpinnedSlope (m : ℕ) (i : Fin m) : ForwardSlopeIndex m :=
if h0 : i.val = 0 then inl () else inr i
theorem forwardSlopeSourceIndex_commonAxisUnpinnedSlope
The slope differentiated at the i-th unpinned node — the direct slope when i is zero and the latent slope of the same index otherwise — is carried by exactly the source that the common-axis permutation places at node i + 1.
Formal statement
hypotheses
conclusion
= commonAxisNodeSource m hm (pinnedSucc (n := m + 1) i)
Proof (Lean source)
lemma forwardSlopeSourceIndex_commonAxisUnpinnedSlope
(m : ℕ) (hm : 1 ≤ m) (i : Fin m) :
forwardSlopeSourceIndex m (commonAxisUnpinnedSlope m i) =
commonAxisNodeSource m hm (pinnedSucc (n := m + 1) i) := by
apply Fin.ext
by_cases h0 : i.val = 0
· change (forwardSlopeSourceIndex m (commonAxisUnpinnedSlope m i)).val = _
simp [commonAxisUnpinnedSlope, commonAxisNodeSource, pinnedSucc, h0,
forwardSlopeSourceIndex]
· change (forwardSlopeSourceIndex m (commonAxisUnpinnedSlope m i)).val = _
simp [commonAxisUnpinnedSlope, commonAxisNodeSource, pinnedSucc, h0,
forwardSlopeSourceIndex]
def commonAxisTopColumn
Defines the mathematical object called the common Axis Top Column.
Definition (Lean source)
def commonAxisTopColumn (m : ℕ) (hm : 1 ≤ m) :
CommonAxisTopIndex m → CommonAxisBandCoord m (2 * m + 2) hm
| inl j =>
⟨Sum.inr (inr
(commonAxisNodeSource m hm j, ⟨2 * m, by omega⟩)), by
intro h
cases Sum.inr.inj h⟩
| inr i =>
⟨forwardSlopeBandCoord m (2 * m + 2) (commonAxisUnpinnedSlope m i), by
by_cases h0 : i.val = 0
· simp [commonAxisUnpinnedSlope, h0, forwardSlopeBandCoord]
· intro h
rw [commonAxisUnpinnedSlope, dif_neg h0] at h
simp only [forwardSlopeBandCoord] at h
apply h0
have h' := Sum.inl.inj (Sum.inr.inj h)
exact Fin.ext_iff.mp h'⟩
def canonicalCommonAxisTopJacobianAtWitness
Defines the Jacobian matrix, row, column, or indexing object called the canonical Common Axis Top Jacobian At Witness.
Definition (Lean source)
def canonicalCommonAxisTopJacobianAtWitness (m : ℕ) (hm : 1 ≤ m) :
Matrix (CommonAxisTopIndex m) (CommonAxisTopIndex m) ℂ :=
fun a b =>
eval (commonAxisJacobianWitnessCoord m hm)
(pderiv (commonAxisTopColumn m hm b)
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega)
(commonAxisTopRow m a)))
theorem canonicalCommonAxisTopJacobianAtWitness_eq_pinned
Proves the stated equality or equivalence for canonical Common Axis Top Jacobian At Witness equality pinned.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
= pinnedConfluentVandermonde (n := m + 1) (commonAxisNodeValue m)
Proof (Lean source)
theorem canonicalCommonAxisTopJacobianAtWitness_eq_pinned
(m : ℕ) (hm : 1 ≤ m) :
canonicalCommonAxisTopJacobianAtWitness m hm =
pinnedConfluentVandermonde (n := m + 1)
(commonAxisNodeValue m) := by
ext a b
rcases b with j | i
· simp only [canonicalCommonAxisTopJacobianAtWitness, commonAxisTopColumn]
rw [eval_pderiv_forwardCommonAxisCoordinatePolynomial,
pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by rfl)]
change
(forwardLoading m
(decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).1
(decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).2.1
(commonAxisNodeSource m hm j)).1 ^
(2 * m + 2 - pinnedExponent a) *
(forwardLoading m
(decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).1
(decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).2.1
(commonAxisNodeSource m hm j)).2 ^ pinnedExponent a = _
rw [commonAxisJacobianWitness_loading]
simp [pinnedConfluentVandermonde]
· simp only [canonicalCommonAxisTopJacobianAtWitness, commonAxisTopColumn]
rw [eval_pderiv_forwardCommonAxisCoordinatePolynomial,
pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_slope,
forwardSlopeSourceIndex_commonAxisUnpinnedSlope]
change
(decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).2.2
(commonAxisNodeSource m hm
(pinnedSucc (n := m + 1) i)) (2 * m + 2) *
(forwardLoading m
(decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).1
(decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).2.1
(commonAxisNodeSource m hm
(pinnedSucc (n := m + 1) i))).1 ^
(2 * m + 2 - pinnedExponent a) *
((pinnedExponent a : ℂ) *
(forwardLoading m
(decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).1
(decodeBandParam
(commonAxisBandInsert hm (commonAxisJacobianWitnessCoord m hm))).2.1
(commonAxisNodeSource m hm
(pinnedSucc (n := m + 1) i))).2 ^
(pinnedExponent a - 1)) = _
rw [commonAxisJacobianWitness_weight _ _ _ _ (by omega),
commonAxisJacobianWitness_loading]
simp [pinnedConfluentVandermonde]
theorem det_canonicalCommonAxisTopJacobianAtWitness_ne_zero
Proves that the quantity called the det canonical Common Axis Top Jacobian At Witness is nonzero.
Formal statement
Proof (Lean source)
theorem det_canonicalCommonAxisTopJacobianAtWitness_ne_zero
(m : ℕ) (hm : 1 ≤ m) :
(canonicalCommonAxisTopJacobianAtWitness m hm).det ≠ 0 := by
rw [canonicalCommonAxisTopJacobianAtWitness_eq_pinned]
exact det_pinnedConfluentVandermonde_ne_zero (by omega)
(commonAxisNodeValue m) (commonAxisNodeValue_injective m)
def CommonAxisTopAugmentedIndex
Proves the stated mathematical property of Common Axis Top Augmented Index.
Definition (Lean source)
def commonAxisTopAugmentedRow
Defines the mathematical object called the common Axis Top Augmented Row.
Definition (Lean source)
def commonAxisTopAugmentedRow (m : ℕ) :
CommonAxisTopAugmentedIndex m → RetainedCumCoord (2 * m + 2)
| inl a => commonAxisTopRow m a
| inr _ =>
⟨(⟨2 * m + 2, by omega⟩, ⟨2 * m + 2, by omega⟩),
by change 2 ≤ 2 * m + 2; omega, le_rfl⟩
def commonAxisTopAugmentedColumn
Defines the mathematical object called the common Axis Top Augmented Column.
Definition (Lean source)
def commonAxisTopAugmentedColumn (m : ℕ) (hm : 1 ≤ m) :
CommonAxisTopAugmentedIndex m →
CommonAxisBandCoord m (2 * m + 2) hm
| inl b => commonAxisTopColumn m hm b
| inr _ =>
⟨Sum.inr (inr (last (m + 1), ⟨2 * m, by omega⟩)), by
intro h
cases Sum.inr.inj h⟩
def canonicalCommonAxisTopAugmentedJacobianAtWitness
Defines the Jacobian matrix, row, column, or indexing object called the canonical Common Axis Top Augmented Jacobian At Witness.
Definition (Lean source)
def canonicalCommonAxisTopAugmentedJacobianAtWitness
(m : ℕ) (hm : 1 ≤ m) :
Matrix (CommonAxisTopAugmentedIndex m)
(CommonAxisTopAugmentedIndex m) ℂ :=
fun a b =>
eval (commonAxisJacobianWitnessCoord m hm)
(pderiv (commonAxisTopAugmentedColumn m hm b)
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega)
(commonAxisTopAugmentedRow m a)))
theorem canonicalCommonAxisTopAugmentedJacobianAtWitness_eq
Proves the stated equality or equivalence for canonical Common Axis Top Augmented Jacobian At Witness eq.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
= fromBlocks (canonicalCommonAxisTopJacobianAtWitness m hm) 0 (commonAxisTopAugmentedLowerLeft m hm) 1
Proof (Lean source)
theorem canonicalCommonAxisTopAugmentedJacobianAtWitness_eq
(m : ℕ) (hm : 1 ≤ m) :
canonicalCommonAxisTopAugmentedJacobianAtWitness m hm =
fromBlocks (canonicalCommonAxisTopJacobianAtWitness m hm) 0
(commonAxisTopAugmentedLowerLeft m hm) 1 := by
ext a b
rcases a with a | u <;> rcases b with b | v
· rfl
· obtain rfl : v = () := Subsingleton.elim _ _
simp only [canonicalCommonAxisTopAugmentedJacobianAtWitness,
commonAxisTopAugmentedColumn, commonAxisTopAugmentedRow,
Matrix.fromBlocks_apply₁₂, Pi.zero_apply]
rw [eval_pderiv_forwardCommonAxisCoordinatePolynomial,
pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by rfl), commonAxisJacobianWitness_loading_last]
change
(0 : ℂ) ^ (2 * m + 2 - pinnedExponent a) *
1 ^ pinnedExponent a = 0
simp [show 2 * m + 2 - pinnedExponent a ≠ 0 by
have h := pinnedExponent_lt (n := m + 1) a
omega]
· rfl
· obtain rfl : u = () := Subsingleton.elim _ _
obtain rfl : v = () := Subsingleton.elim _ _
simp only [canonicalCommonAxisTopAugmentedJacobianAtWitness,
commonAxisTopAugmentedColumn, commonAxisTopAugmentedRow,
Matrix.fromBlocks_apply₂₂, Matrix.one_apply]
rw [eval_pderiv_forwardCommonAxisCoordinatePolynomial,
pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by rfl), commonAxisJacobianWitness_loading_last]
simp
theorem det_canonicalCommonAxisTopAugmentedJacobianAtWitness_ne_zero
Proves that the quantity called the det canonical Common Axis Top Augmented Jacobian At Witness is nonzero.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
Proof (Lean source)
theorem det_canonicalCommonAxisTopAugmentedJacobianAtWitness_ne_zero
(m : ℕ) (hm : 1 ≤ m) :
(canonicalCommonAxisTopAugmentedJacobianAtWitness m hm).det ≠ 0 := by
rw [canonicalCommonAxisTopAugmentedJacobianAtWitness_eq,
Matrix.det_fromBlocks_zero₁₂, Matrix.det_one, mul_one]
exact det_canonicalCommonAxisTopJacobianAtWitness_ne_zero m hm
Helpers.ExceptionalCommonAxisOrdinary 6 declarations
def canonicalCommonAxisLowWeightJacobianAtWitness
Defines the Jacobian matrix, row, column, or indexing object called the canonical Common Axis Low Weight Jacobian At Witness.
Definition (Lean source)
def canonicalCommonAxisLowWeightJacobianAtWitness (m : ℕ) (hm : 1 ≤ m) :
Matrix (ForwardLowWeightIndex m) (ForwardLowWeightIndex m) ℂ :=
fun a b =>
eval (commonAxisJacobianWitnessCoord m hm)
(pderiv (commonAxisLowWeightColumn m hm b)
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm
(by omega) (forwardLowWeightRow m a)))
theorem canonicalCommonAxisLowWeightJacobianAtWitness_eq
Proves the stated equality or equivalence for canonical Common Axis Low Weight Jacobian At Witness eq.
Formal statement
Proof (Lean source)
theorem canonicalCommonAxisLowWeightJacobianAtWitness_eq
(m : ℕ) (hm : 1 ≤ m) :
canonicalCommonAxisLowWeightJacobianAtWitness m hm =
blockDiagonal' (commonAxisLowVandermondeBlock (m := m)) := by
ext a b
rcases a with ⟨ka, a⟩
rcases b with ⟨kb, b⟩
by_cases h : ka = kb
· subst kb
rw [Matrix.blockDiagonal'_apply_eq]
simp only [canonicalCommonAxisLowWeightJacobianAtWitness,
commonAxisLowWeightColumn, forwardLowWeightRow]
rw [eval_pderiv_forwardCommonAxisCoordinatePolynomial,
pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by rfl)]
change
(forwardLoading m
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).1
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).2.1
(commonAxisNodeSource m hm ⟨b.val, _⟩)).1 ^ (ka.val + 2 - a.val) *
(forwardLoading m
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).1
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).2.1
(commonAxisNodeSource m hm ⟨b.val, _⟩)).2 ^ a.val = _
rw [commonAxisJacobianWitness_loading]
simp [commonAxisNodeValue, commonAxisLowVandermondeBlock,
Matrix.vandermonde]
· rw [Matrix.blockDiagonal'_apply_ne _ _ _ h]
simp only [canonicalCommonAxisLowWeightJacobianAtWitness]
apply eval_commonAxis_weight_otherOrder
m hm (forwardLowWeightRow m ⟨ka, a⟩)
(commonAxisLowWeightColumn m hm ⟨kb, b⟩)
(commonAxisNodeSource m hm ⟨b.val, by
have := b.isLt; have := kb.isLt; omega⟩)
⟨kb.val, by omega⟩
· rfl
· intro heq
apply h
apply Fin.ext
simpa [forwardLowWeightRow] using heq.symm
theorem det_canonicalCommonAxisLowWeightJacobianAtWitness_ne_zero
Proves that the quantity called the det canonical Common Axis Low Weight Jacobian At Witness is nonzero.
Formal statement
Proof (Lean source)
theorem det_canonicalCommonAxisLowWeightJacobianAtWitness_ne_zero
(m : ℕ) (hm : 1 ≤ m) :
(canonicalCommonAxisLowWeightJacobianAtWitness m hm).det ≠ 0 := by
rw [canonicalCommonAxisLowWeightJacobianAtWitness_eq]
have hblocks : IsUnit (commonAxisLowVandermondeBlock (m := m)) := by
rw [Pi.isUnit_iff]
intro k
rw [Matrix.isUnit_iff_isUnit_det]
rw [commonAxisLowVandermondeBlock, Matrix.det_transpose]
exact (Matrix.det_vandermonde_ne_zero_iff.mpr (by
intro i j hij
apply Fin.ext
change ((i.val : ℕ) : ℂ) = ((j.val : ℕ) : ℂ) at hij
exact_mod_cast hij)).isUnit
have hmatrix : IsUnit (blockDiagonal'
(commonAxisLowVandermondeBlock (m := m))) :=
hblocks.map (Matrix.blockDiagonal'RingHom
(fun k : Fin (m - 1) => Fin (k.val + 3)) ℂ)
exact ((Matrix.isUnit_iff_isUnit_det _).mp hmatrix).ne_zero
def canonicalCommonAxisHighWeightJacobianAtWitness
Defines the Jacobian matrix, row, column, or indexing object called the canonical Common Axis High Weight Jacobian At Witness.
Definition (Lean source)
def canonicalCommonAxisHighWeightJacobianAtWitness (m : ℕ) (hm : 1 ≤ m) :
Matrix (ForwardHighWeightIndex m) (ForwardHighWeightIndex m) ℂ :=
fun a b =>
eval (commonAxisJacobianWitnessCoord m hm)
(pderiv (commonAxisHighWeightColumn m hm b)
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm
(by omega) (forwardHighWeightRow m hm a)))
theorem canonicalCommonAxisHighWeightJacobianAtWitness_eq
Proves the stated equality or equivalence for canonical Common Axis High Weight Jacobian At Witness eq.
Formal statement
Proof (Lean source)
theorem canonicalCommonAxisHighWeightJacobianAtWitness_eq
(m : ℕ) (hm : 1 ≤ m) :
canonicalCommonAxisHighWeightJacobianAtWitness m hm =
blockDiagonal (commonAxisHighWeightBlock m) := by
ext a b
rcases a with ⟨a, ka⟩
rcases b with ⟨b, kb⟩
by_cases h : ka = kb
· subst kb
rw [Matrix.blockDiagonal_apply_eq]
rcases a with a | u <;> rcases b with b | v
· simp only [canonicalCommonAxisHighWeightJacobianAtWitness,
commonAxisHighWeightColumn, forwardHighWeightRow,
commonAxisHighWeightBlock_eq, Matrix.fromBlocks_apply₁₁]
rw [eval_pderiv_forwardCommonAxisCoordinatePolynomial,
pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by
change m - 1 + ka.val = m + 1 + ka.val - 2
omega)]
change
(forwardLoading m
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).1
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).2.1
(commonAxisNodeSource m hm b)).1 ^
((forwardHighWeightRow m hm (inl a, ka)).1.1.val - a.val) *
(forwardLoading m
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).1
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).2.1
(commonAxisNodeSource m hm b)).2 ^ a.val = _
rw [commonAxisJacobianWitness_loading, forwardHighWeightRow_order]
simp [commonAxisNodeValue, Matrix.vandermonde]
· simp only [canonicalCommonAxisHighWeightJacobianAtWitness,
commonAxisHighWeightColumn, forwardHighWeightRow,
commonAxisHighWeightBlock_eq, Matrix.fromBlocks_apply₁₂, Pi.zero_apply]
rw [eval_pderiv_forwardCommonAxisCoordinatePolynomial,
pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by
change m - 1 + ka.val = m + 1 + ka.val - 2
omega)]
change
(forwardLoading m
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).1
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).2.1
(last (m + 1))).1 ^
((forwardHighWeightRow m hm (inl a, ka)).1.1.val - a.val) *
(forwardLoading m
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).1
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).2.1
(last (m + 1))).2 ^ a.val = _
rw [commonAxisJacobianWitness_loading_last, forwardHighWeightRow_order]
simp [show m + 1 + ka.val - a.val ≠ 0 by
have := a.isLt; omega]
· obtain rfl : u = () := Subsingleton.elim _ _
simp only [canonicalCommonAxisHighWeightJacobianAtWitness,
commonAxisHighWeightColumn, forwardHighWeightRow,
commonAxisHighWeightBlock_eq, Matrix.fromBlocks_apply₂₁]
rw [eval_pderiv_forwardCommonAxisCoordinatePolynomial,
pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by
change m - 1 + ka.val = m + 1 + ka.val - 2
omega)]
change
(forwardLoading m
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).1
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).2.1
(commonAxisNodeSource m hm b)).1 ^
((forwardHighWeightRow m hm (inr (), ka)).1.1.val -
(forwardHighWeightRow m hm (inr (), ka)).1.2.val) *
(forwardLoading m
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).1
(decodeBandParam (commonAxisBandInsert hm
(commonAxisJacobianWitnessCoord m hm))).2.1
(commonAxisNodeSource m hm b)).2 ^
(forwardHighWeightRow m hm (inr (), ka)).1.2.val = _
rw [commonAxisJacobianWitness_loading, forwardHighWeightRow_order]
simp [commonAxisNodeValue]
rfl
· simp only [canonicalCommonAxisHighWeightJacobianAtWitness,
commonAxisHighWeightColumn, forwardHighWeightRow,
commonAxisHighWeightBlock_eq, Matrix.fromBlocks_apply₂₂, Matrix.one_apply]
rw [eval_pderiv_forwardCommonAxisCoordinatePolynomial,
pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by
change m - 1 + ka.val = m + 1 + ka.val - 2
omega),
commonAxisJacobianWitness_loading_last]
simp
· rw [Matrix.blockDiagonal_apply_ne _ _ _ h]
rcases a with a | u <;> rcases b with b | v
all_goals
simp only [canonicalCommonAxisHighWeightJacobianAtWitness]
apply eval_commonAxis_weight_otherOrder
· rfl
· intro heq
apply h
apply Fin.ext
change m - 1 + kb.val = m + 1 + ka.val - 2 at heq
omega
theorem det_canonicalCommonAxisHighWeightJacobianAtWitness_ne_zero
Proves that the quantity called the det canonical Common Axis High Weight Jacobian At Witness is nonzero.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
Proof (Lean source)
theorem det_canonicalCommonAxisHighWeightJacobianAtWitness_ne_zero
(m : ℕ) (hm : 1 ≤ m) :
(canonicalCommonAxisHighWeightJacobianAtWitness m hm).det ≠ 0 := by
rw [canonicalCommonAxisHighWeightJacobianAtWitness_eq,
Matrix.det_blockDiagonal]
exact Finset.prod_ne_zero_iff.mpr fun k _ =>
det_commonAxisHighWeightBlock_ne_zero m k
Helpers.ExceptionalGeometryBasic 8 declarations
theorem subset_zariskiClosure
Proves the stated set-containment or membership property for subset zariski Closure.
Formal statement
Proof (Lean source)
lemma subset_zariskiClosure (A : Set (CumVec ℂ)) : A ⊆ zariskiClosure A := by
intro t ht P hP
exact hP t ht
theorem zariskiClosure_mono
Proves the stated mathematical property of zariski Closure mono.
Formal statement
Proof (Lean source)
lemma zariskiClosure_mono {A B : Set (CumVec ℂ)} (h : A ⊆ B) :
zariskiClosure A ⊆ zariskiClosure B := by
intro t ht P hP
exact ht P (fun s hs => hP s (h hs))
theorem zariskiClosure_idem
Proves the stated mathematical property of zariski Closure idem.
Formal statement
Proof (Lean source)
@[simp] lemma zariskiClosure_idem (A : Set (CumVec ℂ)) :
zariskiClosure (zariskiClosure A) = zariskiClosure A := by
apply Set.Subset.antisymm
· intro t ht P hP
exact ht P fun s hs => hs P hP
· exact subset_zariskiClosure _
theorem zariskiClosure_isClosed
Proves the stated mathematical property of zariski Closure is Closed.
Formal statement
Proof (Lean source)
lemma zariskiClosure_isClosed (A : Set (CumVec ℂ)) :
zariskiClosure (zariskiClosure A) = zariskiClosure A :=
zariskiClosure_idem A
theorem genericFullFiberCompatibility_subset_forward_range
Proves the stated set-containment or membership property for generic Full Fiber Compatibility subset forward range.
Formal statement
hypotheses
m :
ℕ
conclusion
Proof (Lean source)
lemma genericFullFiberCompatibility_subset_forward_range (m : ℕ) :
genericFullFiberCompatibility m ⊆
range (forwardCumulantMap m (2 * m + 2)) := by
rintro t ⟨htband, hcompat⟩
rcases hcompat with ⟨⟨θ, hθ, _⟩, _⟩ | ⟨_, ⟨θ, hθ⟩⟩
· exact ⟨θ, map_eq_target_of_mem_fiberCorrespondence
(forwardCumulantMap_mem_bandSupportedCumulants m (2 * m + 2)) htband hθ⟩
· exact ⟨θ, map_eq_target_of_mem_fiberCorrespondence
(forwardCumulantMap_mem_bandSupportedCumulants m (2 * m + 2)) htband hθ⟩
theorem genericFullFiberCompatibility_subset_reverse_range
Proves the stated set-containment or membership property for generic Full Fiber Compatibility subset reverse range.
Formal statement
hypotheses
m :
ℕ
conclusion
Proof (Lean source)
lemma genericFullFiberCompatibility_subset_reverse_range (m : ℕ) :
genericFullFiberCompatibility m ⊆
range (reverseCumulantMap m (2 * m + 2)) := by
rintro t ⟨htband, hcompat⟩
rcases hcompat with ⟨_, ⟨η, hη⟩⟩ | ⟨⟨η, hη, _⟩, _⟩
· exact ⟨η, map_eq_target_of_mem_fiberCorrespondence
(reverseCumulantMap_mem_bandSupportedCumulants m (2 * m + 2)) htband hη⟩
· exact ⟨η, map_eq_target_of_mem_fiberCorrespondence
(reverseCumulantMap_mem_bandSupportedCumulants m (2 * m + 2)) htband hη⟩
theorem genericCompatibilityClosure_subset_forwardVariety
Proves the stated set-containment or membership property for generic Compatibility Closure subset forward Variety.
Formal statement
hypotheses
m :
ℕ
conclusion
Proof (Lean source)
lemma genericCompatibilityClosure_subset_forwardVariety (m : ℕ) :
genericCompatibilityClosure m ⊆
cumulantImageVariety (forwardCumulantMap m (2 * m + 2)) := by
exact zariskiClosure_mono (genericFullFiberCompatibility_subset_forward_range m)
theorem genericCompatibilityClosure_subset_reverseVariety
Proves the stated set-containment or membership property for generic Compatibility Closure subset reverse Variety.
Formal statement
hypotheses
m :
ℕ
conclusion
Proof (Lean source)
lemma genericCompatibilityClosure_subset_reverseVariety (m : ℕ) :
genericCompatibilityClosure m ⊆
cumulantImageVariety (reverseCumulantMap m (2 * m + 2)) := by
exact zariskiClosure_mono (genericFullFiberCompatibility_subset_reverse_range m)
Helpers.ExceptionalHeightReduction 20 declarations
theorem genericCompatibilityClosure_subset_band
Proves the stated set-containment or membership property for generic Compatibility Closure subset band.
Formal statement
Proof (Lean source)
lemma genericCompatibilityClosure_subset_band (m : ℕ) :
genericCompatibilityClosure m ⊆ bandSupportedCumulants (2 * m + 2) := by
apply zariskiClosure_subset_band
intro t ht
exact ht.1
theorem forwardCumulantImageVariety_subset_band
Proves the stated set-containment or membership property for forward Cumulant Image Variety subset band.
Formal statement
hypotheses
m L :
ℕ
conclusion
Proof (Lean source)
lemma forwardCumulantImageVariety_subset_band (m L : ℕ) :
cumulantImageVariety (forwardCumulantMap m L) ⊆
bandSupportedCumulants L := by
apply zariskiClosure_subset_band
rintro _ ⟨θ, rfl⟩
exact forwardCumulantMap_mem_bandSupportedCumulants m L θ
theorem reverseCumulantImageVariety_subset_band
Proves the stated set-containment or membership property for reverse Cumulant Image Variety subset band.
Formal statement
hypotheses
m L :
ℕ
conclusion
Proof (Lean source)
lemma reverseCumulantImageVariety_subset_band (m L : ℕ) :
cumulantImageVariety (reverseCumulantMap m L) ⊆
bandSupportedCumulants L := by
apply zariskiClosure_subset_band
rintro _ ⟨η, rfl⟩
exact reverseCumulantMap_mem_bandSupportedCumulants m L η
theorem genericCompatibilityClosure_ne_forwardVariety
The exceptional closure is proper in the forward arrow variety. The separating equation is the explicit observable horizontal contraction minor: it vanishes on the reverse variety, while the block-Vandermonde forward witness has nonzero value.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
Proof (Lean source)
lemma genericCompatibilityClosure_ne_forwardVariety (m : ℕ) (hm : 1 ≤ m) :
genericCompatibilityClosure m ≠
cumulantImageVariety (forwardCumulantMap m (2 * m + 2)) := by
intro heq
let theta := forwardContractionMinorWitnessParameter m
let t := forwardCumulantMap m (2 * m + 2) theta
have htForward : t ∈
cumulantImageVariety (forwardCumulantMap m (2 * m + 2)) :=
subset_zariskiClosure _ ⟨theta, rfl⟩
have htExceptional : t ∈ genericCompatibilityClosure m := by
rw [heq]
exact htForward
have htReverse : t ∈
cumulantImageVariety (reverseCumulantMap m (2 * m + 2)) :=
genericCompatibilityClosure_subset_reverseVariety m htExceptional
exact (horizontalContractionMinorPolynomial_forwardWitness_ne_zero m hm)
(horizontalContractionMinorPolynomial_reverseVariety_vanishes m htReverse)
theorem restrict_genericCompatibilityClosure_ne_forwardVariety
Proves the stated mathematical property of restrict generic Compatibility Closure ne forward Variety.
Formal statement
Proof (Lean source)
lemma restrict_genericCompatibilityClosure_ne_forwardVariety
(m : ℕ) (hm : 1 ≤ m) :
restrictCumBand (2 * m + 2) '' genericCompatibilityClosure m ≠
restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2)) := by
intro heq
apply genericCompatibilityClosure_ne_forwardVariety m hm
exact image_restrictCumBand_inj
(genericCompatibilityClosure_subset_band m)
(forwardCumulantImageVariety_subset_band m (2 * m + 2)) heq
theorem genericCompatibilityClosure_ne_reverseVariety
The coordinate-reversed observable minor gives the symmetric properness statement in the reverse ambient arrow variety.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
Proof (Lean source)
lemma genericCompatibilityClosure_ne_reverseVariety (m : ℕ) (hm : 1 ≤ m) :
genericCompatibilityClosure m ≠
cumulantImageVariety (reverseCumulantMap m (2 * m + 2)) := by
intro heq
let eta := axisReverseParameter m (forwardContractionMinorWitnessParameter m)
let t := reverseCumulantMap m (2 * m + 2) eta
have htReverse : t ∈
cumulantImageVariety (reverseCumulantMap m (2 * m + 2)) :=
subset_zariskiClosure _ ⟨eta, rfl⟩
have htExceptional : t ∈ genericCompatibilityClosure m := by
rw [heq]
exact htReverse
have htForward : t ∈
cumulantImageVariety (forwardCumulantMap m (2 * m + 2)) :=
genericCompatibilityClosure_subset_forwardVariety m htExceptional
exact (verticalContractionMinorPolynomial_reverseWitness_ne_zero m hm)
(verticalContractionMinorPolynomial_forwardVariety_vanishes m htForward)
theorem restrict_genericCompatibilityClosure_ne_reverseVariety
Proves the stated mathematical property of restrict generic Compatibility Closure ne reverse Variety.
Formal statement
Proof (Lean source)
lemma restrict_genericCompatibilityClosure_ne_reverseVariety
(m : ℕ) (hm : 1 ≤ m) :
restrictCumBand (2 * m + 2) '' genericCompatibilityClosure m ≠
restrictCumBand (2 * m + 2) ''
cumulantImageVariety (reverseCumulantMap m (2 * m + 2)) := by
intro heq
apply genericCompatibilityClosure_ne_reverseVariety m hm
exact image_restrictCumBand_inj
(genericCompatibilityClosure_subset_band m)
(reverseCumulantImageVariety_subset_band m (2 * m + 2)) heq
def ExceptionalFiniteHeightOneCertificate
The exact finite certificate still required for one arrow: properness of the exceptional closure and one of its affine irreducible components being a minimal prime over a single observable equation in the arrow coordinate ring.
Definition (Lean source)
def ExceptionalFiniteHeightOneCertificate (m : ℕ)
(D X : Set (CumVec ℂ)) : Prop :=
let L := 2 * m + 2
let Zf := restrictCumBand L '' genericCompatibilityClosure m
let Df := restrictCumBand L '' D
let Xf := restrictCumBand L '' X
Zf ≠ Xf ∧
∃ P : MvPolynomial (RetainedCumCoord L) ℂ,
IsIrreducibleAffineComponent Df Zf ∧
vanishingIdeal ℂ Df ∈
(vanishingIdeal ℂ Xf ⊔ span {P}).minimalPrimes
def CommonAxisFiniteHeightOneCertificates
The model-specific specialization demanded by the D0 proof: the component is the closure of the explicit common-axis opposite-arrow twin family.
Definition (Lean source)
def CommonAxisFiniteHeightOneCertificates (m : ℕ) (hm : 1 ≤ m) : Prop :=
ExceptionalFiniteHeightOneCertificate m (forwardCommonAxisImageClosure m hm)
(cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ∧
ExceptionalFiniteHeightOneCertificate m (forwardCommonAxisImageClosure m hm)
(cumulantImageVariety (reverseCumulantMap m (2 * m + 2)))
theorem forwardExceptionalFiniteHeightOneCertificate_of_commonAxis_principal
For the forward ambient, observable-minor properness is compiled; only the common-axis component and its principal minimal-prime certificate remain.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
P :
MvPolynomial (RetainedCumCoord (2 * m + 2)) ℂ
hcomponent :
IsIrreducibleAffineComponent (restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) (restrictCumBand (2 * m + 2) '' genericCompatibilityClosure m)
hmin :
vanishingIdeal ℂ (restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) ∈ (vanishingIdeal ℂ (restrictCumBand (2 * m + 2) '' cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ⊔ span {P}).minimalPrimes
conclusion
ExceptionalFiniteHeightOneCertificate m (forwardCommonAxisImageClosure m hm) (cumulantImageVariety (forwardCumulantMap m (2 * m + 2)))
Proof (Lean source)
theorem forwardExceptionalFiniteHeightOneCertificate_of_commonAxis_principal
(m : ℕ) (hm : 1 ≤ m)
(P : MvPolynomial (RetainedCumCoord (2 * m + 2)) ℂ)
(hcomponent : IsIrreducibleAffineComponent
(restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm)
(restrictCumBand (2 * m + 2) '' genericCompatibilityClosure m))
(hmin : vanishingIdeal ℂ
(restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) ∈
(vanishingIdeal ℂ
(restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ⊔
span {P}).minimalPrimes) :
ExceptionalFiniteHeightOneCertificate m
(forwardCommonAxisImageClosure m hm)
(cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) := by
exact ⟨restrict_genericCompatibilityClosure_ne_forwardVariety m hm,
P, hcomponent, hmin⟩
theorem reverseExceptionalFiniteHeightOneCertificate_of_commonAxis_principal
Reverse-ambient assembly using the coordinate-reversed principal equation.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
P :
MvPolynomial (RetainedCumCoord (2 * m + 2)) ℂ
hcomponent :
IsIrreducibleAffineComponent (restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) (restrictCumBand (2 * m + 2) '' genericCompatibilityClosure m)
hmin :
vanishingIdeal ℂ (restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) ∈ (vanishingIdeal ℂ (restrictCumBand (2 * m + 2) '' cumulantImageVariety (reverseCumulantMap m (2 * m + 2))) ⊔ span {P}).minimalPrimes
conclusion
ExceptionalFiniteHeightOneCertificate m (forwardCommonAxisImageClosure m hm) (cumulantImageVariety (reverseCumulantMap m (2 * m + 2)))
Proof (Lean source)
theorem reverseExceptionalFiniteHeightOneCertificate_of_commonAxis_principal
(m : ℕ) (hm : 1 ≤ m)
(P : MvPolynomial (RetainedCumCoord (2 * m + 2)) ℂ)
(hcomponent : IsIrreducibleAffineComponent
(restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm)
(restrictCumBand (2 * m + 2) '' genericCompatibilityClosure m))
(hmin : vanishingIdeal ℂ
(restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) ∈
(vanishingIdeal ℂ
(restrictCumBand (2 * m + 2) ''
cumulantImageVariety (reverseCumulantMap m (2 * m + 2))) ⊔
span {P}).minimalPrimes) :
ExceptionalFiniteHeightOneCertificate m
(forwardCommonAxisImageClosure m hm)
(cumulantImageVariety (reverseCumulantMap m (2 * m + 2))) := by
exact ⟨restrict_genericCompatibilityClosure_ne_reverseVariety m hm,
P, hcomponent, hmin⟩
theorem commonAxisFiniteHeightOneCertificates_of_principal
The exact residual after both observable properness arguments: one common irreducible-component proof and the two explicit principal minimal-prime certificates.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
hcomponent :
IsIrreducibleAffineComponent (restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) (restrictCumBand (2 * m + 2) '' genericCompatibilityClosure m)
hforward :
vanishingIdeal ℂ (restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) ∈ (vanishingIdeal ℂ (restrictCumBand (2 * m + 2) '' cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ⊔ span {horizontalContractionMinorPolynomial m}).minimalPrimes
hreverse :
vanishingIdeal ℂ (restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) ∈ (vanishingIdeal ℂ (restrictCumBand (2 * m + 2) '' cumulantImageVariety (reverseCumulantMap m (2 * m + 2))) ⊔ span {verticalContractionMinorPolynomial m}).minimalPrimes
conclusion
Proof (Lean source)
theorem commonAxisFiniteHeightOneCertificates_of_principal
(m : ℕ) (hm : 1 ≤ m)
(hcomponent : IsIrreducibleAffineComponent
(restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm)
(restrictCumBand (2 * m + 2) '' genericCompatibilityClosure m))
(hforward : vanishingIdeal ℂ
(restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) ∈
(vanishingIdeal ℂ
(restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ⊔
span {horizontalContractionMinorPolynomial m}).minimalPrimes)
(hreverse : vanishingIdeal ℂ
(restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) ∈
(vanishingIdeal ℂ
(restrictCumBand (2 * m + 2) ''
cumulantImageVariety (reverseCumulantMap m (2 * m + 2))) ⊔
span {verticalContractionMinorPolynomial m}).minimalPrimes) :
CommonAxisFiniteHeightOneCertificates m hm := by
exact ⟨
forwardExceptionalFiniteHeightOneCertificate_of_commonAxis_principal m hm
(horizontalContractionMinorPolynomial m) hcomponent hforward,
reverseExceptionalFiniteHeightOneCertificate_of_commonAxis_principal m hm
(verticalContractionMinorPolynomial m) hcomponent hreverse⟩
theorem commonAxisFiniteHeightOneCertificates_of_no_intermediate
The principal certificates follow formally from the honest geometric height-one statement for the common-axis closure. This isolates the remaining model-specific work to irreducibility and the absence of an intermediate irreducible closed set in each arrow variety.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
hC :
hforward :
¬ ∃ Y, IsIrreducibleAffineClosed Y ∧ restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm ⊂ Y ∧ Y ⊂ restrictCumBand (2 * m + 2) '' cumulantImageVariety (forwardCumulantMap m (2 * m + 2))
hreverse :
¬ ∃ Y, IsIrreducibleAffineClosed Y ∧ restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm ⊂ Y ∧ Y ⊂ restrictCumBand (2 * m + 2) '' cumulantImageVariety (reverseCumulantMap m (2 * m + 2))
conclusion
Proof (Lean source)
theorem commonAxisFiniteHeightOneCertificates_of_no_intermediate
(m : ℕ) (hm : 1 ≤ m)
(hC : IsIrreducibleAffineClosed
(restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm))
(hforward : ¬ ∃ Y, IsIrreducibleAffineClosed Y ∧
restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm ⊂ Y ∧
Y ⊂ restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2)))
(hreverse : ¬ ∃ Y, IsIrreducibleAffineClosed Y ∧
restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm ⊂ Y ∧
Y ⊂ restrictCumBand (2 * m + 2) ''
cumulantImageVariety (reverseCumulantMap m (2 * m + 2))) :
CommonAxisFiniteHeightOneCertificates m hm := by
let C := restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm
let Z := restrictCumBand (2 * m + 2) '' genericCompatibilityClosure m
let Xf := restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2))
let Xr := restrictCumBand (2 * m + 2) ''
cumulantImageVariety (reverseCumulantMap m (2 * m + 2))
have hCZ : C ⊆ Z :=
Set.image_mono (forwardCommonAxisImageClosure_subset_exceptional hm)
have hZXf : Z ⊆ Xf :=
Set.image_mono (genericCompatibilityClosure_subset_forwardVariety m)
have hZXr : Z ⊆ Xr :=
Set.image_mono (genericCompatibilityClosure_subset_reverseVariety m)
have hXf : IsIrreducibleAffineClosed Xf :=
(irreducibleZariskiClosed_iff_affine
(forwardCumulantImageVariety_subset_band m (2 * m + 2))).mp
(forwardCumulantImageVariety_isIrreducible m (2 * m + 2))
have hXr : IsIrreducibleAffineClosed Xr :=
(irreducibleZariskiClosed_iff_affine
(reverseCumulantImageVariety_subset_band m (2 * m + 2))).mp
(reverseCumulantImageVariety_isIrreducible m (2 * m + 2))
have hcomponent : IsIrreducibleAffineComponent C Z :=
irreducibleAffineComponent_of_no_intermediate hC hCZ hZXf
(restrict_genericCompatibilityClosure_ne_forwardVariety m hm) hforward
apply commonAxisFiniteHeightOneCertificates_of_principal m hm hcomponent
· exact vanishingIdeal_mem_minimalPrimes_span_of_no_intermediate
hC hXf (hCZ.trans hZXf) (horizontalContractionMinorPolynomial m)
(horizontalContractionMinor_mem_commonAxis_vanishingIdeal m hm)
(horizontalContractionMinor_not_mem_forward_vanishingIdeal m hm) hforward
· exact vanishingIdeal_mem_minimalPrimes_span_of_no_intermediate
hC hXr (hCZ.trans hZXr) (verticalContractionMinorPolynomial m)
(verticalContractionMinor_mem_commonAxis_vanishingIdeal m hm)
(verticalContractionMinor_not_mem_reverse_vanishingIdeal m hm) hreverse
theorem commonAxisFiniteHeightOneCertificates_of_no_intermediate_only
After proving polynomial-image irreducibility of the common-axis closure, the complete residual consists only of the two height-one (no-intermediate) statements.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
hforward :
¬ ∃ Y, IsIrreducibleAffineClosed Y ∧ restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm ⊂ Y ∧ Y ⊂ restrictCumBand (2 * m + 2) '' cumulantImageVariety (forwardCumulantMap m (2 * m + 2))
hreverse :
¬ ∃ Y, IsIrreducibleAffineClosed Y ∧ restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm ⊂ Y ∧ Y ⊂ restrictCumBand (2 * m + 2) '' cumulantImageVariety (reverseCumulantMap m (2 * m + 2))
conclusion
Proof (Lean source)
theorem commonAxisFiniteHeightOneCertificates_of_no_intermediate_only
(m : ℕ) (hm : 1 ≤ m)
(hforward : ¬ ∃ Y, IsIrreducibleAffineClosed Y ∧
restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm ⊂ Y ∧
Y ⊂ restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2)))
(hreverse : ¬ ∃ Y, IsIrreducibleAffineClosed Y ∧
restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm ⊂ Y ∧
Y ⊂ restrictCumBand (2 * m + 2) ''
cumulantImageVariety (reverseCumulantMap m (2 * m + 2))) :
CommonAxisFiniteHeightOneCertificates m hm := by
exact commonAxisFiniteHeightOneCertificates_of_no_intermediate m hm
(restrict_forwardCommonAxisImageClosure_isIrreducible m hm)
hforward hreverse
theorem commonAxisFiniteHeightOneCertificates_of_forward_no_intermediate
Coordinate reversal supplies the reverse height-one statement, so the single remaining model-specific premise is the forward D - 1 versus D dimension gap.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
hforward :
¬ ∃ Y, IsIrreducibleAffineClosed Y ∧ restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm ⊂ Y ∧ Y ⊂ restrictCumBand (2 * m + 2) '' cumulantImageVariety (forwardCumulantMap m (2 * m + 2))
conclusion
Proof (Lean source)
theorem commonAxisFiniteHeightOneCertificates_of_forward_no_intermediate
(m : ℕ) (hm : 1 ≤ m)
(hforward : ¬ ∃ Y, IsIrreducibleAffineClosed Y ∧
restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm ⊂ Y ∧
Y ⊂ restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) :
CommonAxisFiniteHeightOneCertificates m hm := by
exact commonAxisFiniteHeightOneCertificates_of_no_intermediate_only m hm
hforward (reverse_no_intermediate_of_forward m hm hforward)
def commonAxisExpectedDimension
The expected dimension of the common-axis image, namely D - 1 in the notation of the D0 Jacobian calculation. The forward arrow variety has the successor dimension.
Definition (Lean source)
def commonAxisExpectedDimension (m : ℕ) : ℕ :=
(3 * (m + 2) ^ 2 + (m + 2)) / 2 - 5
theorem commonAxisFiniteHeightOneCertificates_of_exact_forward_dimensions
Exact D - 1 and D image dimensions discharge the sole remaining height-one premise.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
hdims :
HasAffineZariskiDimension (commonAxisExpectedDimension m) (restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) ∧
HasAffineZariskiDimension (commonAxisExpectedDimension m + 1) (restrictCumBand (2 * m + 2) '' cumulantImageVariety (forwardCumulantMap m (2 * m + 2)))
conclusion
Proof (Lean source)
theorem commonAxisFiniteHeightOneCertificates_of_exact_forward_dimensions
(m : ℕ) (hm : 1 ≤ m)
(hdims :
HasAffineZariskiDimension (commonAxisExpectedDimension m)
(restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) ∧
HasAffineZariskiDimension (commonAxisExpectedDimension m + 1)
(restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2)))) :
CommonAxisFiniteHeightOneCertificates m hm := by
let C := restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm
let X := restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2))
have hCXle : C ⊆ X := Set.image_mono
((forwardCommonAxisImageClosure_subset_exceptional hm).trans
(genericCompatibilityClosure_subset_forwardVariety m))
have hCXne : C ≠ X := by
intro hCX
apply restrict_genericCompatibilityClosure_ne_forwardVariety m hm
apply Set.Subset.antisymm
· exact Set.image_mono (genericCompatibilityClosure_subset_forwardVariety m)
· change X ⊆ restrictCumBand (2 * m + 2) '' genericCompatibilityClosure m
rw [← hCX]
exact Set.image_mono (forwardCommonAxisImageClosure_subset_exceptional hm)
have hX : IsIrreducibleAffineClosed X :=
(irreducibleZariskiClosed_iff_affine
(forwardCumulantImageVariety_subset_band m (2 * m + 2))).mp
(forwardCumulantImageVariety_isIrreducible m (2 * m + 2))
apply commonAxisFiniteHeightOneCertificates_of_forward_no_intermediate m hm
exact no_intermediate_of_exact_affine_dimensions hX
hdims.1 hdims.2
theorem exceptionalCodimensionOne_of_finite_certificates
Once the explicit principal minimal-prime certificates are supplied, the frozen custom codimension-one claims follow exactly.
Formal statement
hypotheses
m :
ℕ
hf :
ExceptionalFiniteHeightOneCertificate m Df (cumulantImageVariety (forwardCumulantMap m (2 * m + 2)))
hr :
ExceptionalFiniteHeightOneCertificate m Dl (cumulantImageVariety (reverseCumulantMap m (2 * m + 2)))
conclusion
HasCodimensionIn 1 (genericCompatibilityClosure m) (cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ∧
HasCodimensionIn 1 (genericCompatibilityClosure m) (cumulantImageVariety (reverseCumulantMap m (2 * m + 2)))
Proof (Lean source)
theorem exceptionalCodimensionOne_of_finite_certificates (m : ℕ)
{Df Dl : Set (CumVec ℂ)}
(hf : ExceptionalFiniteHeightOneCertificate m Df
(cumulantImageVariety (forwardCumulantMap m (2 * m + 2))))
(hr : ExceptionalFiniteHeightOneCertificate m Dl
(cumulantImageVariety (reverseCumulantMap m (2 * m + 2)))) :
HasCodimensionIn 1 (genericCompatibilityClosure m)
(cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ∧
HasCodimensionIn 1 (genericCompatibilityClosure m)
(cumulantImageVariety (reverseCumulantMap m (2 * m + 2))) := by
let L := 2 * m + 2
let Z := genericCompatibilityClosure m
let Xr := cumulantImageVariety (forwardCumulantMap m L)
let Xl := cumulantImageVariety (reverseCumulantMap m L)
have hZband : Z ⊆ bandSupportedCumulants L :=
genericCompatibilityClosure_subset_band m
have hXrband : Xr ⊆ bandSupportedCumulants L :=
forwardCumulantImageVariety_subset_band m L
have hXlband : Xl ⊆ bandSupportedCumulants L :=
reverseCumulantImageVariety_subset_band m L
have hZXr : restrictCumBand L '' Z ⊆ restrictCumBand L '' Xr :=
Set.image_mono (genericCompatibilityClosure_subset_forwardVariety m)
have hZXl : restrictCumBand L '' Z ⊆ restrictCumBand L '' Xl :=
Set.image_mono (genericCompatibilityClosure_subset_reverseVariety m)
have hXrirr : IsIrreducibleAffineClosed (restrictCumBand L '' Xr) :=
(irreducibleZariskiClosed_iff_affine hXrband).mp
(forwardCumulantImageVariety_isIrreducible m L)
have hXlirr : IsIrreducibleAffineClosed (restrictCumBand L '' Xl) :=
(irreducibleZariskiClosed_iff_affine hXlband).mp
(reverseCumulantImageVariety_isIrreducible m L)
constructor
· apply (hasCodimensionIn_iff_affineCodimensionIn hZband hXrband).mpr
rcases hf with ⟨hne, P, hC, hmin⟩
exact hasAffineCodimensionIn_one_of_minimalPrime_span
hXrirr hZXr hne hC P hmin
· apply (hasCodimensionIn_iff_affineCodimensionIn hZband hXlband).mpr
rcases hr with ⟨hne, P, hC, hmin⟩
exact hasAffineCodimensionIn_one_of_minimalPrime_span
hXlirr hZXl hne hC P hmin
theorem exceptionalLocusCodimensionOne_of_finite_certificates
All non-geometric conjuncts of the flagship assemble from the compiled incidence helpers. Consequently the two explicit finite height certificates are the complete residual for exceptionalLocusCodimensionOne.
Formal statement
hypotheses
m :
ℕ
hm :
hf :
ExceptionalFiniteHeightOneCertificate m Df (cumulantImageVariety (forwardCumulantMap m (2 * m + 2)))
hr :
ExceptionalFiniteHeightOneCertificate m Dl (cumulantImageVariety (reverseCumulantMap m (2 * m + 2)))
conclusion
HasCodimensionIn 1 (genericCompatibilityClosure m) (cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ∧
HasCodimensionIn 1 (genericCompatibilityClosure m) (cumulantImageVariety (reverseCumulantMap m (2 * m + 2))) ∧
(2 ≤ m → ¬ HasCodimensionIn m (genericCompatibilityClosure m) (cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ∧ ¬ HasCodimensionIn m (genericCompatibilityClosure m) (cumulantImageVariety (reverseCumulantMap m (2 * m + 2)))) ∧
(∀ θ : ParamSpace ℂ m, θ ∈ genericCompatibilityPreimageRight m ↔ θ ∈ bandSupportedParams m (2 * m + 2) ∧ θ ∈ genericParameterLocus m (2 * m + 2) ∧ (fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2)) (forwardCumulantMap m (2 * m + 2) θ)).Nonempty) ∧
(∀ eta : ParamSpace ℂ m, eta ∈ genericCompatibilityPreimageLeft m ↔ eta ∈ bandSupportedParams m (2 * m + 2) ∧ eta ∈ genericParameterLocus m (2 * m + 2) ∧ (fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2)) (reverseCumulantMap m (2 * m + 2) eta)).Nonempty) ∧
(m = 1 → genericFullFiberCompatibility m = {t : CumVec ℂ | ∃ p ∈ (workedCompatibilitySystems m).1, forwardCumulantMap m (2 * m + 2) p.1 = t}) ∧
(m = 2 → genericFullFiberCompatibility m = {t : CumVec ℂ | ∃ p ∈ (workedCompatibilitySystems m).1, forwardCumulantMap m (2 * m + 2) p.1 = t})
Proof (Lean source)
theorem exceptionalLocusCodimensionOne_of_finite_certificates
(m : ℕ) (hm : ValidComplexity m)
{Df Dl : Set (CumVec ℂ)}
(hf : ExceptionalFiniteHeightOneCertificate m Df
(cumulantImageVariety (forwardCumulantMap m (2 * m + 2))))
(hr : ExceptionalFiniteHeightOneCertificate m Dl
(cumulantImageVariety (reverseCumulantMap m (2 * m + 2)))) :
HasCodimensionIn 1 (genericCompatibilityClosure m)
(cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ∧
HasCodimensionIn 1 (genericCompatibilityClosure m)
(cumulantImageVariety (reverseCumulantMap m (2 * m + 2))) ∧
(2 ≤ m →
¬ HasCodimensionIn m (genericCompatibilityClosure m)
(cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ∧
¬ HasCodimensionIn m (genericCompatibilityClosure m)
(cumulantImageVariety (reverseCumulantMap m (2 * m + 2)))) ∧
(∀ θ : ParamSpace ℂ m,
θ ∈ genericCompatibilityPreimageRight m ↔
θ ∈ bandSupportedParams m (2 * m + 2) ∧
θ ∈ genericParameterLocus m (2 * m + 2) ∧
(fiberCorrespondence (2 * m + 2)
(reverseCumulantMap m (2 * m + 2))
(forwardCumulantMap m (2 * m + 2) θ)).Nonempty) ∧
(∀ eta : ParamSpace ℂ m,
eta ∈ genericCompatibilityPreimageLeft m ↔
eta ∈ bandSupportedParams m (2 * m + 2) ∧
eta ∈ genericParameterLocus m (2 * m + 2) ∧
(fiberCorrespondence (2 * m + 2)
(forwardCumulantMap m (2 * m + 2))
(reverseCumulantMap m (2 * m + 2) eta)).Nonempty) ∧
(m = 1 → genericFullFiberCompatibility m =
{t : CumVec ℂ | ∃ p ∈ (workedCompatibilitySystems m).1,
forwardCumulantMap m (2 * m + 2) p.1 = t}) ∧
(m = 2 → genericFullFiberCompatibility m =
{t : CumVec ℂ | ∃ p ∈ (workedCompatibilitySystems m).1,
forwardCumulantMap m (2 * m + 2) p.1 = t}) := by
have hcodim := exceptionalCodimensionOne_of_finite_certificates m hf hr
refine ⟨hcodim.1, hcodim.2, ?_,
genericCompatibilityPreimageRight_iff m,
genericCompatibilityPreimageLeft_iff m, ?_, ?_⟩
· intro hm2
exact ⟨hcodim.1.not_of_one hm2, hcodim.2.not_of_one hm2⟩
· intro hm1
exact genericFullFiberCompatibility_eq_worked_projection m (inl hm1)
· intro hm2
exact genericFullFiberCompatibility_eq_worked_projection m (inr hm2)
def exceptionalLocusCodimensionOne_of_commonAxis_certificates
The explicit common-axis certificates alone imply the entire flagship conclusion.
Definition (Lean source)
def exceptionalLocusCodimensionOne_of_commonAxis_certificates
(m : ℕ) (hm : ValidComplexity m)
(hcert : CommonAxisFiniteHeightOneCertificates m hm) :=
exceptionalLocusCodimensionOne_of_finite_certificates m hm hcert.1 hcert.2
Helpers.ExceptionalImageDimension 13 declarations
def forwardBandFiniteMap
The forward cumulant map on the finite retained-band parameter space.
Definition (Lean source)
def forwardBandFiniteMap (m L : ℕ) (x : BandParamCoord m L → ℂ) :
RetainedCumCoord L → ℂ :=
restrictCumBand L (forwardCumulantMap m L (decodeBandParam x))
theorem forwardBandFiniteMap_isPolynomial
Every retained cumulant coordinate of the forward map is a polynomial in the finitely many retained parameter coordinates, so the forward map on the finite band is a polynomial map. The truncation order is assumed to be at least two.
Formal statement
Proof (Lean source)
lemma forwardBandFiniteMap_isPolynomial (m L : ℕ) (hL : 2 ≤ L) :
IsPolynomialMap (forwardBandFiniteMap m L) := by
obtain ⟨coord, hcoord⟩ := forwardCumulantMap_isPolynomial m L
intro q
refine ⟨restrictParamPolynomial (coord (q.1.1, q.1.2.1)), ?_⟩
intro x
rw [eval_restrictParamPolynomial hL, hcoord]
rfl
def forwardBandCoordinatePolynomial
A canonical coordinate-polynomial family for the finite forward map.
Definition (Lean source)
noncomputable def forwardBandCoordinatePolynomial (m L : ℕ) (hL : 2 ≤ L)
(q : RetainedCumCoord L) : MvPolynomial (BandParamCoord m L) ℂ :=
choose (forwardBandFiniteMap_isPolynomial m L hL q)
theorem eval_forwardBandCoordinatePolynomial
The chosen coordinate polynomial of a retained cumulant coordinate does what it is supposed to do: evaluated at any finite parameter coordinate vector it returns that coordinate of the forward band map.
Formal statement
hypotheses
conclusion
eval x (forwardBandCoordinatePolynomial m L hL q)
= forwardBandFiniteMap m L x q
Proof (Lean source)
lemma eval_forwardBandCoordinatePolynomial (m L : ℕ) (hL : 2 ≤ L)
(x : BandParamCoord m L → ℂ) (q : RetainedCumCoord L) :
eval x (forwardBandCoordinatePolynomial m L hL q) =
forwardBandFiniteMap m L x q :=
Classical.choose_spec (forwardBandFiniteMap_isPolynomial m L hL q) x
theorem polynomialCoordinateMap_forwardBand
Assembling the chosen coordinate polynomials into a single vector-valued map recovers exactly the forward map on the finite retained band.
Formal statement
hypotheses
m L :
ℕ
hL :
2 ≤ L
conclusion
Proof (Lean source)
lemma polynomialCoordinateMap_forwardBand (m L : ℕ) (hL : 2 ≤ L) :
polynomialCoordinateMap (forwardBandCoordinatePolynomial m L hL) =
forwardBandFiniteMap m L := by
funext x q
exact eval_forwardBandCoordinatePolynomial m L hL x q
theorem forwardCumulantMap_decode_encodeBandParam
Pinning the unused parameter coordinates does not change a truncated forward cumulant vector.
Formal statement
hypotheses
conclusion
= forwardCumulantMap m L θ
Proof (Lean source)
lemma forwardCumulantMap_decode_encodeBandParam (m L : ℕ) (hL : 2 ≤ L)
(θ : ParamSpace ℂ m) :
forwardCumulantMap m L
(decodeBandParam (L := L) (encodeBandParam (L := L) θ)) =
forwardCumulantMap m L θ := by
funext r a
simp only [forwardCumulantMap]
split
· rename_i h
apply Finset.sum_congr rfl
intro j _
simp [decodeBandParam, encodeBandParam, h]
· rfl
theorem range_forwardBandFiniteMap
The set of retained cumulant vectors produced by the finite forward map is exactly the retained-band restriction of the set produced by the full forward cumulant map. Nothing is lost by pinning the off-band weights to zero, because cumulants of orders two through L never depend on them; the truncation order is assumed to be at least two.
Formal statement
Proof (Lean source)
lemma range_forwardBandFiniteMap (m L : ℕ) (hL : 2 ≤ L) :
range (forwardBandFiniteMap m L) =
restrictCumBand L '' range (forwardCumulantMap m L) := by
ext y
constructor
· rintro ⟨x, rfl⟩
exact ⟨forwardCumulantMap m L (decodeBandParam x),
⟨decodeBandParam x, rfl⟩, rfl⟩
· rintro ⟨_, ⟨θ, rfl⟩, rfl⟩
refine ⟨encodeBandParam (L := L) θ, ?_⟩
simp only [forwardBandFiniteMap]
rw [forwardCumulantMap_decode_encodeBandParam m L hL θ]
theorem restrict_forwardCumulantImageVariety_eq_polynomialImageClosure
The finite restriction of the forward arrow variety is exactly the polynomial-image closure to which the promoted dimension bridge applies.
Formal statement
hypotheses
m L :
ℕ
hL :
2 ≤ L
conclusion
Proof (Lean source)
theorem restrict_forwardCumulantImageVariety_eq_polynomialImageClosure
(m L : ℕ) (hL : 2 ≤ L) :
restrictCumBand L ''
cumulantImageVariety (forwardCumulantMap m L) =
polynomialImageClosure (forwardBandCoordinatePolynomial m L hL) := by
change restrictCumBand L '' zariskiClosure (range (forwardCumulantMap m L)) = _
rw [restrictCumBand_image_zariskiClosure (by
rintro _ ⟨θ, rfl⟩
exact forwardCumulantMap_mem_bandSupportedCumulants m L θ)]
change affineZariskiClosure
(restrictCumBand L '' range (forwardCumulantMap m L)) =
affineZariskiClosure
(range (polynomialCoordinateMap
(forwardBandCoordinatePolynomial m L hL)))
rw [← range_forwardBandFiniteMap m L hL,
polynomialCoordinateMap_forwardBand m L hL]
def forwardCommonAxisCoordinatePolynomial
A canonical coordinate-polynomial family for the common-axis map.
Definition (Lean source)
noncomputable def forwardCommonAxisCoordinatePolynomial (m L : ℕ)
(hm : 1 ≤ m) (hL : 2 ≤ L) (q : RetainedCumCoord L) :
MvPolynomial (CommonAxisBandCoord m L hm) ℂ :=
choose (forwardCommonAxisFiniteMap_isPolynomial m L hm hL q)
theorem polynomialCoordinateMap_forwardCommonAxis
Assembling the chosen common-axis coordinate polynomials into a single vector-valued map recovers exactly the forward map on the common-axis band, where the first latent slope is pinned to zero. At least one latent source and a truncation order of at least two are assumed.
Formal statement
Proof (Lean source)
lemma polynomialCoordinateMap_forwardCommonAxis (m L : ℕ)
(hm : 1 ≤ m) (hL : 2 ≤ L) :
polynomialCoordinateMap
(forwardCommonAxisCoordinatePolynomial m L hm hL) =
forwardCommonAxisFiniteMap m L hm := by
funext x q
exact Classical.choose_spec
(forwardCommonAxisFiniteMap_isPolynomial m L hm hL q) x
theorem restrict_forwardCommonAxisImageClosure_eq_polynomialImageClosure
The finite common-axis closure is the corresponding polynomial-image closure; density removes the generic nonvanishing condition on the source.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm
= polynomialImageClosure (forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega))
Proof (Lean source)
theorem restrict_forwardCommonAxisImageClosure_eq_polynomialImageClosure
(m : ℕ) (hm : 1 ≤ m) :
restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm =
polynomialImageClosure
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega)) := by
let L := 2 * m + 2
let A : Set (CumVec ℂ) :=
forwardCumulantMap m L '' forwardCommonAxisDivisor m hm
have hA : A ⊆ bandSupportedCumulants L := by
rintro _ ⟨θ, _, rfl⟩
exact forwardCumulantMap_mem_bandSupportedCumulants m L θ
change restrictCumBand L '' zariskiClosure A = _
rw [restrictCumBand_image_zariskiClosure hA]
have himage : restrictCumBand L '' A =
forwardCommonAxisFiniteMap m L hm '' commonAxisSource m L hm := by
symm
simpa [A, forwardCommonAxisDivisor] using
commonAxisFiniteImage_eq m L hm (by omega)
rw [himage]
rw [affineZariskiClosure_polynomial_image_of_dense
(forwardCommonAxisFiniteMap_isPolynomial m L hm (by omega))
(commonAxisSource_dense hm (by omega))]
change affineZariskiClosure (range (forwardCommonAxisFiniteMap m L hm)) =
affineZariskiClosure
(range (polynomialCoordinateMap
(forwardCommonAxisCoordinatePolynomial m L hm (by omega))))
rw [polynomialCoordinateMap_forwardCommonAxis m L hm (by omega)]
theorem restrict_forwardCumulantImageVariety_dimension_of_jacobian
The promoted Jacobian/transcendence bridge specialized to the full forward arrow image. The two hypotheses are precisely the model-specific lower and upper certificates still owed by the confluent-Vandermonde calculation and the low-order weight kernels.
Formal statement
hypotheses
m d :
ℕ
rows :
Fin d → RetainedCumCoord (2 * m + 2)
cols :
Fin d → BandParamCoord m (2 * m + 2)
hminor :
polynomialJacobianMinor (forwardBandCoordinatePolynomial m (2 * m + 2) (by omega)) rows cols
≠ 0
hupper :
@trdeg ℂ (polynomialCoordinateSubalgebra (forwardBandCoordinatePolynomial m (2 * m + 2) (by omega))) _ _ (jacobianCoordinateSubalgebraAlgebra (forwardBandCoordinatePolynomial m (2 * m + 2) (by omega)))
≤ d
conclusion
HasAffineZariskiDimension d (restrictCumBand (2 * m + 2) '' cumulantImageVariety (forwardCumulantMap m (2 * m + 2)))
Proof (Lean source)
theorem restrict_forwardCumulantImageVariety_dimension_of_jacobian
(m d : ℕ)
(rows : Fin d → RetainedCumCoord (2 * m + 2))
(cols : Fin d → BandParamCoord m (2 * m + 2))
(hminor : polynomialJacobianMinor
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega)) rows cols ≠ 0)
(hupper : @trdeg ℂ
(polynomialCoordinateSubalgebra
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega))) _ _
(jacobianCoordinateSubalgebraAlgebra
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega))) ≤ d) :
HasAffineZariskiDimension d
(restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) := by
rw [restrict_forwardCumulantImageVariety_eq_polynomialImageClosure m
(2 * m + 2) (by omega)]
exact polynomialImageClosure_dimension_of_jacobian _ rows cols hminor hupper
theorem restrict_forwardCommonAxisImageClosure_dimension_of_jacobian
The same promoted bridge specialized to the common-axis divisor image.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
rows :
cols :
hminor :
polynomialJacobianMinor (forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega)) rows cols
≠ 0
hupper :
@trdeg ℂ (polynomialCoordinateSubalgebra (forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega))) _ _ (jacobianCoordinateSubalgebraAlgebra (forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega)))
conclusion
HasAffineZariskiDimension (commonAxisExpectedDimension m) (restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm)
Proof (Lean source)
theorem restrict_forwardCommonAxisImageClosure_dimension_of_jacobian
(m : ℕ) (hm : 1 ≤ m)
(rows : Fin (commonAxisExpectedDimension m) →
RetainedCumCoord (2 * m + 2))
(cols : Fin (commonAxisExpectedDimension m) →
CommonAxisBandCoord m (2 * m + 2) hm)
(hminor : polynomialJacobianMinor
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega))
rows cols ≠ 0)
(hupper : @trdeg ℂ
(polynomialCoordinateSubalgebra
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega))) _ _
(jacobianCoordinateSubalgebraAlgebra
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega))) ≤
commonAxisExpectedDimension m) :
HasAffineZariskiDimension (commonAxisExpectedDimension m)
(restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) := by
rw [restrict_forwardCommonAxisImageClosure_eq_polynomialImageClosure m hm]
exact polynomialImageClosure_dimension_of_jacobian _ rows cols hminor hupper
Helpers.ExceptionalImageDimensionUpper 9 declarations
def ForwardImageGenerator
The retained generators for the full forward image: all loading slopes, all cumulant coordinates through order m, and all source weights from order m+1 through order 2m+2.
Definition (Lean source)
abbrev ForwardImageGenerator (m : ℕ) :=
(Unit ⊕ Fin m) ⊕ RetainedCumCoord m ⊕ (Fin (m + 2) × Fin (m + 2))
theorem forwardBandCoordinatePolynomial_factorization
Every forward coordinate polynomial factors through the retained generator family. This is the model-specific content of the upper dimension bound.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
∀ q,
bind₁ (forwardImageGeneratorPolynomial m hm) (forwardImageFactorPolynomial m hm q)
= forwardBandCoordinatePolynomial m (2 * m + 2) (by omega) q
Proof (Lean source)
theorem forwardBandCoordinatePolynomial_factorization (m : ℕ) (hm : 1 ≤ m) :
∀ q, bind₁ (forwardImageGeneratorPolynomial m hm)
(forwardImageFactorPolynomial m hm q) =
forwardBandCoordinatePolynomial m (2 * m + 2) (by omega) q := by
intro q
unfold forwardImageFactorPolynomial
split
· rename_i qlow heq
rw [MvPolynomial.bind₁_X_right]
simp only [forwardImageGeneratorPolynomial]
unfold retainedCumCoordLow? at heq
split at heq
· rename_i hlow
simp only [Option.some.injEq] at heq
subst qlow
rw [lowCumCoordLift_of_low m q hlow]
· contradiction
· rename_i hnone
rw [MvPolynomial.bind₁_bind₁]
apply MvPolynomial.funext
intro x
change MvPolynomial.eval₂Hom (id ℂ) x
(bind₁ _ _) = _
rw [MvPolynomial.eval₂Hom_bind₁]
change eval _ _ = eval x _
rw [eval_forwardBandCoordinatePolynomial,
eval_forwardBandCoordinatePolynomial]
have hhigh : m < q.1.1 := by
unfold retainedCumCoordLow? at hnone
split at hnone
· contradiction
· omega
have hargs :
(fun c => MvPolynomial.eval₂Hom (id ℂ) x
(bind₁ (forwardImageGeneratorPolynomial m hm)
(bandParamToForwardGeneratorPolynomial m hm c))) =
(fun c => match c with
| inl u => x (inl u)
| inr (inl i) => x (inr (inl i))
| inr (inr (j, k)) =>
if m + 1 ≤ k.1 + 2 then x (inr (inr (j, k))) else 0) := by
funext c
change eval x
(bind₁ (forwardImageGeneratorPolynomial m hm)
(bandParamToForwardGeneratorPolynomial m hm c)) = _
exact eval_bind_bandParamToForwardGeneratorPolynomial m hm x c
rw [hargs]
exact forwardBandFiniteMap_lowWeight_independent m q hhigh x
theorem forwardBandCoordinateSubalgebra_trdeg_le_generatorCard
The full forward coordinate algebra is generated by the slopes, low-order outputs, and high-order weights retained above.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
@trdeg ℂ (polynomialCoordinateSubalgebra (forwardBandCoordinatePolynomial m (2 * m + 2) (by omega))) _ _ (algebra (polynomialCoordinateSubalgebra (forwardBandCoordinatePolynomial m (2 * m + 2) (by omega))))
≤ card (ForwardImageGenerator m)
Proof (Lean source)
theorem forwardBandCoordinateSubalgebra_trdeg_le_generatorCard
(m : ℕ) (hm : 1 ≤ m) :
@trdeg ℂ
(polynomialCoordinateSubalgebra
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega))) _ _
(algebra (polynomialCoordinateSubalgebra
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega)))) ≤
card (ForwardImageGenerator m) := by
simpa only [Nat.card_eq_fintype_card] using
(coordinateSubalgebra_trdeg_le_of_polynomial_factorization
(τ := ForwardImageGenerator m)
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega))
(forwardImageGeneratorPolynomial m hm)
(forwardImageFactorPolynomial m hm)
(forwardBandCoordinatePolynomial_factorization m hm))
def CommonAxisImageGenerator
The common-axis generator family is obtained by deleting the pinned rho_0 slope from the full generator family.
Definition (Lean source)
abbrev CommonAxisImageGenerator (m : ℕ) (hm : 1 ≤ m) :=
{g : ForwardImageGenerator m // g ≠ fixedAxisForwardGenerator m hm}
theorem forwardCommonAxisCoordinatePolynomial_factorization
Every common-axis coordinate polynomial factors through the generator family obtained by deleting the fixed slope.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
∀ q,
bind₁ (commonAxisGeneratorPolynomial m hm) (commonAxisImageFactorPolynomial m hm q)
= forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega) q
Proof (Lean source)
theorem forwardCommonAxisCoordinatePolynomial_factorization
(m : ℕ) (hm : 1 ≤ m) :
∀ q, bind₁ (commonAxisGeneratorPolynomial m hm)
(commonAxisImageFactorPolynomial m hm q) =
forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega) q := by
intro q
unfold commonAxisImageFactorPolynomial
rw [MvPolynomial.bind₁_bind₁]
rw [show (fun g => bind₁ (commonAxisGeneratorPolynomial m hm)
(fullToCommonAxisGeneratorPolynomial m hm g)) =
(fun g => commonAxisPolynomial hm
(forwardImageGeneratorPolynomial m hm g)) from
funext (commonAxisGeneratorPolynomial_compat m hm)]
calc
_ = commonAxisPolynomial hm
(bind₁ (forwardImageGeneratorPolynomial m hm)
(forwardImageFactorPolynomial m hm q)) := by
rw [commonAxisPolynomial_eq_bind]
exact (MvPolynomial.bind₁_bind₁ _ _ _).symm
_ = _ := by
rw [forwardBandCoordinatePolynomial_factorization m hm q]
exact commonAxisPolynomial_forwardBandCoordinatePolynomial m hm q
theorem card_forwardImageGenerator
The generator envelope has exactly the full expected image dimension.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
Proof (Lean source)
theorem card_forwardImageGenerator (m : ℕ) (hm : 1 ≤ m) :
card (ForwardImageGenerator m) =
commonAxisExpectedDimension m + 1 := by
simp only [ForwardImageGenerator, Fintype.card_sum, Fintype.card_unit,
Fintype.card_fin, Fintype.card_prod, card_retainedCumCoord]
unfold qDim commonAxisExpectedDimension
let x := m * (m + 3)
let y := (m + 2) ^ 2
have hx : 2 ∣ x := by
simpa [x] using two_dvd_generator_quadratic m
have hpoly : 3 * y + (m + 2) = x + 2 * (y + m + 3) := by
dsimp [x, y]
ring
have hxlower : 2 ≤ x / 2 := by
have hfour : 4 ≤ x := by
dsimp [x]
nlinarith
omega
rw [show 3 * (m + 2) ^ 2 + (m + 2) =
x + 2 * (y + m + 3) by simpa [y] using hpoly]
rw [Nat.add_div_of_dvd_right hx]
dsimp [x, y]
simp only [pow_two]
omega
theorem card_commonAxisImageGenerator
Deleting the pinned common-axis slope removes exactly one generator.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
Proof (Lean source)
theorem card_commonAxisImageGenerator (m : ℕ) (hm : 1 ≤ m) :
card (CommonAxisImageGenerator m hm) =
commonAxisExpectedDimension m := by
change card
{g : ForwardImageGenerator m // g ≠ fixedAxisForwardGenerator m hm} = _
have hsingle : card
{g : ForwardImageGenerator m // g = fixedAxisForwardGenerator m hm} = 1 :=
Fintype.card_subtype_eq _
rw [Fintype.card_subtype_compl
(fun g : ForwardImageGenerator m => g = fixedAxisForwardGenerator m hm),
hsingle, card_forwardImageGenerator m hm]
omega
theorem forwardBandCoordinateSubalgebra_trdeg_le_expected
Exact full-image transcendence upper bound supplied by the generator envelope, with no fiber-dimension interface.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
@trdeg ℂ (polynomialCoordinateSubalgebra (forwardBandCoordinatePolynomial m (2 * m + 2) (by omega))) _ _ (algebra (polynomialCoordinateSubalgebra (forwardBandCoordinatePolynomial m (2 * m + 2) (by omega))))
≤ commonAxisExpectedDimension m + 1
Proof (Lean source)
theorem forwardBandCoordinateSubalgebra_trdeg_le_expected
(m : ℕ) (hm : 1 ≤ m) :
@trdeg ℂ
(polynomialCoordinateSubalgebra
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega))) _ _
(algebra (polynomialCoordinateSubalgebra
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega)))) ≤
commonAxisExpectedDimension m + 1 := by
have hcard : (card (ForwardImageGenerator m) : Cardinal) =
(commonAxisExpectedDimension m : Cardinal) + 1 := by
exact_mod_cast card_forwardImageGenerator m hm
exact (forwardBandCoordinateSubalgebra_trdeg_le_generatorCard m hm).trans_eq hcard
theorem forwardCommonAxisCoordinateSubalgebra_trdeg_le_expected
Exact common-axis transcendence upper bound supplied by the generator envelope with the pinned slope deleted.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
@trdeg ℂ (polynomialCoordinateSubalgebra (forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega))) _ _ (algebra (polynomialCoordinateSubalgebra (forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega))))
Proof (Lean source)
theorem forwardCommonAxisCoordinateSubalgebra_trdeg_le_expected
(m : ℕ) (hm : 1 ≤ m) :
@trdeg ℂ
(polynomialCoordinateSubalgebra
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega))) _ _
(algebra (polynomialCoordinateSubalgebra
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega)))) ≤
commonAxisExpectedDimension m := by
have hcard : @trdeg ℂ
(polynomialCoordinateSubalgebra
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega))) _ _
(algebra (polynomialCoordinateSubalgebra
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega)))) ≤
card (CommonAxisImageGenerator m hm) :=
by
simpa only [Nat.card_eq_fintype_card] using
(coordinateSubalgebra_trdeg_le_of_polynomial_factorization
(τ := CommonAxisImageGenerator m hm)
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega))
(commonAxisGeneratorPolynomial m hm)
(commonAxisImageFactorPolynomial m hm)
(forwardCommonAxisCoordinatePolynomial_factorization m hm))
have heq : (card (CommonAxisImageGenerator m hm) : Cardinal) =
(commonAxisExpectedDimension m : Cardinal) := by
exact_mod_cast card_commonAxisImageGenerator m hm
exact hcard.trans_eq heq
Helpers.ExceptionalIncidence 10 declarations
theorem forwardCumulantMap_mem_bandSupportedCumulants
Proves the stated set-containment or membership property for forward Cumulant Map mem band Supported Cumulants.
Formal statement
hypotheses
conclusion
forwardCumulantMap m L θ ∈ bandSupportedCumulants L
Proof (Lean source)
lemma forwardCumulantMap_mem_bandSupportedCumulants {R : Type*} [CommRing R]
(m L : ℕ) (θ : ParamSpace R m) :
forwardCumulantMap m L θ ∈ bandSupportedCumulants L := by
intro r a hra
simp only [forwardCumulantMap]
rw [if_neg hra]
theorem reverseCumulantMap_mem_bandSupportedCumulants
Proves the stated set-containment or membership property for reverse Cumulant Map mem band Supported Cumulants.
Formal statement
hypotheses
conclusion
reverseCumulantMap m L η ∈ bandSupportedCumulants L
Proof (Lean source)
lemma reverseCumulantMap_mem_bandSupportedCumulants {R : Type*} [CommRing R]
(m L : ℕ) (η : ParamSpace R m) :
reverseCumulantMap m L η ∈ bandSupportedCumulants L := by
intro r a hra
simp only [reverseCumulantMap]
rw [if_neg hra]
theorem mem_fiberCorrespondence_self
Proves the stated set-containment or membership property for mem fiber Correspondence self.
Formal statement
hypotheses
conclusion
θ ∈ fiberCorrespondence L Φ (Φ θ)
Proof (Lean source)
lemma mem_fiberCorrespondence_self {R : Type*} [Zero R] {m L : ℕ}
{Φ : ParamSpace R m → CumVec R} {θ : ParamSpace R m}
(hθ : θ ∈ bandSupportedParams m L) :
θ ∈ fiberCorrespondence L Φ (Φ θ) := by
exact ⟨hθ, fun _ _ _ _ _ => rfl⟩
theorem maps_eq_of_mem_fiberCorrespondence
Proves the stated set-containment or membership property for maps equality of mem fiber Correspondence.
Formal statement
hypotheses
R :
Type*
CommRing R
m L :
ℕ
ParamSpace R m → CumVec R
hΦ :
∀ θ, Φ θ ∈ bandSupportedCumulants L
hΨ :
∀ η, Ψ η ∈ bandSupportedCumulants L
t :
CumVec R
θ η :
ParamSpace R m
hθ :
θ ∈ fiberCorrespondence L Φ t
hη :
η ∈ fiberCorrespondence L Ψ t
conclusion
Φ θ = Ψ η
Proof (Lean source)
lemma maps_eq_of_mem_fiberCorrespondence {R : Type*} [CommRing R]
{m L : ℕ} {Φ Ψ : ParamSpace R m → CumVec R}
(hΦ : ∀ θ, Φ θ ∈ bandSupportedCumulants L)
(hΨ : ∀ η, Ψ η ∈ bandSupportedCumulants L)
{t : CumVec R} {θ η : ParamSpace R m}
(hθ : θ ∈ fiberCorrespondence L Φ t)
(hη : η ∈ fiberCorrespondence L Ψ t) :
Φ θ = Ψ η := by
funext r a
by_cases hra : 2 ≤ r ∧ r ≤ L ∧ a ≤ r
· exact (hθ.2 r a hra.1 hra.2.1 hra.2.2).trans
(hη.2 r a hra.1 hra.2.1 hra.2.2).symm
· rw [hΦ θ r a hra, hΨ η r a hra]
theorem map_eq_target_of_mem_fiberCorrespondence
Proves the stated set-containment or membership property for map equality target of mem fiber Correspondence.
Formal statement
hypotheses
R :
Type*
CommRing R
m L :
ℕ
ParamSpace R m → CumVec R
hΦ :
∀ θ, Φ θ ∈ bandSupportedCumulants L
t :
CumVec R
θ :
ParamSpace R m
ht :
t ∈ bandSupportedCumulants L
hθ :
θ ∈ fiberCorrespondence L Φ t
conclusion
Φ θ = t
Proof (Lean source)
lemma map_eq_target_of_mem_fiberCorrespondence {R : Type*} [CommRing R]
{m L : ℕ} {Φ : ParamSpace R m → CumVec R}
(hΦ : ∀ θ, Φ θ ∈ bandSupportedCumulants L)
{t : CumVec R} {θ : ParamSpace R m}
(ht : t ∈ bandSupportedCumulants L)
(hθ : θ ∈ fiberCorrespondence L Φ t) :
Φ θ = t := by
funext r a
by_cases hra : 2 ≤ r ∧ r ≤ L ∧ a ≤ r
· exact hθ.2 r a hra.1 hra.2.1 hra.2.2
· rw [hΦ θ r a hra, ht r a hra]
theorem forward_image_mem_genericFullFiberCompatibility_iff
Proves the stated set-containment or membership property for forward image mem generic Full Fiber Compatibility iff.
Formal statement
hypotheses
m :
ℕ
ParamSpace ℂ m
hθ :
θ ∈ genericParameterLocus m (2 * m + 2)
conclusion
forwardCumulantMap m (2 * m + 2) θ ∈ genericFullFiberCompatibility m
↔ (fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2)) (forwardCumulantMap m (2 * m + 2) θ)).Nonempty
Proof (Lean source)
lemma forward_image_mem_genericFullFiberCompatibility_iff {m : ℕ}
{θ : ParamSpace ℂ m} (hθ : θ ∈ genericParameterLocus m (2 * m + 2)) :
forwardCumulantMap m (2 * m + 2) θ ∈ genericFullFiberCompatibility m ↔
(fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2))
(forwardCumulantMap m (2 * m + 2) θ)).Nonempty := by
let L := 2 * m + 2
have hself : θ ∈ fiberCorrespondence L (forwardCumulantMap m L)
(forwardCumulantMap m L θ) :=
mem_fiberCorrespondence_self (genericParameterLocus_bandSupported hθ)
constructor
· rintro ⟨_, hcompat⟩
rcases hcompat with hcompat | hcompat
· exact hcompat.2
· rcases hcompat.1 with ⟨η, hηfib, _⟩
exact ⟨η, hηfib⟩
· intro hopp
refine ⟨forwardCumulantMap_mem_bandSupportedCumulants m L θ, ?_⟩
exact inl ⟨⟨θ, hself, hθ⟩, hopp⟩
theorem reverse_image_mem_genericFullFiberCompatibility_iff
Proves the stated set-containment or membership property for reverse image mem generic Full Fiber Compatibility iff.
Formal statement
hypotheses
m :
ℕ
ParamSpace ℂ m
hη :
η ∈ genericParameterLocus m (2 * m + 2)
conclusion
reverseCumulantMap m (2 * m + 2) η ∈ genericFullFiberCompatibility m
↔ (fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2)) (reverseCumulantMap m (2 * m + 2) η)).Nonempty
Proof (Lean source)
lemma reverse_image_mem_genericFullFiberCompatibility_iff {m : ℕ}
{η : ParamSpace ℂ m} (hη : η ∈ genericParameterLocus m (2 * m + 2)) :
reverseCumulantMap m (2 * m + 2) η ∈ genericFullFiberCompatibility m ↔
(fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2))
(reverseCumulantMap m (2 * m + 2) η)).Nonempty := by
let L := 2 * m + 2
have hself : η ∈ fiberCorrespondence L (reverseCumulantMap m L)
(reverseCumulantMap m L η) :=
mem_fiberCorrespondence_self (genericParameterLocus_bandSupported hη)
constructor
· rintro ⟨_, hcompat⟩
rcases hcompat with hcompat | hcompat
· rcases hcompat.1 with ⟨θ, hθfib, _⟩
exact ⟨θ, hθfib⟩
· exact hcompat.2
· intro hopp
refine ⟨reverseCumulantMap_mem_bandSupportedCumulants m L η, ?_⟩
exact inr ⟨⟨η, hself, hη⟩, hopp⟩
theorem genericCompatibilityPreimageRight_iff
Proves the stated equality or equivalence for generic Compatibility Preimage Right iff.
Formal statement
hypotheses
m :
ℕ
θ :
ParamSpace ℂ m
conclusion
θ ∈ genericCompatibilityPreimageRight m ↔ θ ∈ bandSupportedParams m (2 * m + 2) ∧
θ ∈ genericParameterLocus m (2 * m + 2) ∧
(fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2)) (forwardCumulantMap m (2 * m + 2) θ)).Nonempty
Proof (Lean source)
lemma genericCompatibilityPreimageRight_iff (m : ℕ) (θ : ParamSpace ℂ m) :
θ ∈ genericCompatibilityPreimageRight m ↔
θ ∈ bandSupportedParams m (2 * m + 2) ∧
θ ∈ genericParameterLocus m (2 * m + 2) ∧
(fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2))
(forwardCumulantMap m (2 * m + 2) θ)).Nonempty := by
rw [genericCompatibilityPreimageRight, genericCompatibilityPreimage]
constructor
· rintro ⟨⟨hband, hgen⟩, hmem⟩
exact ⟨hband, hgen,
(forward_image_mem_genericFullFiberCompatibility_iff hgen).mp hmem⟩
· rintro ⟨hband, hgen, hopp⟩
exact ⟨⟨hband, hgen⟩,
(forward_image_mem_genericFullFiberCompatibility_iff hgen).mpr hopp⟩
theorem genericCompatibilityPreimageLeft_iff
Proves the stated equality or equivalence for generic Compatibility Preimage Left iff.
Formal statement
hypotheses
m :
ℕ
η :
ParamSpace ℂ m
conclusion
η ∈ genericCompatibilityPreimageLeft m ↔ η ∈ bandSupportedParams m (2 * m + 2) ∧
η ∈ genericParameterLocus m (2 * m + 2) ∧
(fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2)) (reverseCumulantMap m (2 * m + 2) η)).Nonempty
Proof (Lean source)
lemma genericCompatibilityPreimageLeft_iff (m : ℕ) (η : ParamSpace ℂ m) :
η ∈ genericCompatibilityPreimageLeft m ↔
η ∈ bandSupportedParams m (2 * m + 2) ∧
η ∈ genericParameterLocus m (2 * m + 2) ∧
(fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2))
(reverseCumulantMap m (2 * m + 2) η)).Nonempty := by
rw [genericCompatibilityPreimageLeft, genericCompatibilityPreimage]
constructor
· rintro ⟨⟨hband, hgen⟩, hmem⟩
exact ⟨hband, hgen,
(reverse_image_mem_genericFullFiberCompatibility_iff hgen).mp hmem⟩
· rintro ⟨hband, hgen, hopp⟩
exact ⟨⟨hband, hgen⟩,
(reverse_image_mem_genericFullFiberCompatibility_iff hgen).mpr hopp⟩
theorem genericFullFiberCompatibility_eq_worked_projection
Proves the stated equality or equivalence for generic Full Fiber Compatibility equality worked projection.
Formal statement
hypotheses
m :
ℕ
hm :
m = 1 ∨ m = 2
conclusion
Proof (Lean source)
lemma genericFullFiberCompatibility_eq_worked_projection (m : ℕ)
(hm : m = 1 ∨ m = 2) :
genericFullFiberCompatibility m =
{t : CumVec ℂ | ∃ p ∈ (workedCompatibilitySystems m).1,
forwardCumulantMap m (2 * m + 2) p.1 = t} := by
let L := 2 * m + 2
ext t
constructor
· rintro ⟨htband, hcompat⟩
rcases hcompat with ⟨⟨θ, hθfib, hθgen⟩, ⟨η, hηfib⟩⟩ |
⟨⟨η, hηfib, hηgen⟩, ⟨θ, hθfib⟩⟩
· refine ⟨(θ, η), ?_, ?_⟩
· exact ⟨hm, hθfib.1, hηfib.1,
maps_eq_of_mem_fiberCorrespondence
(forwardCumulantMap_mem_bandSupportedCumulants m L)
(reverseCumulantMap_mem_bandSupportedCumulants m L) hθfib hηfib,
Or.inl hθgen⟩
· funext r a
by_cases hra : 2 ≤ r ∧ r ≤ L ∧ a ≤ r
· exact hθfib.2 r a hra.1 hra.2.1 hra.2.2
· exact (forwardCumulantMap_mem_bandSupportedCumulants m L θ r a hra).trans
(htband r a hra).symm
· refine ⟨(θ, η), ?_, ?_⟩
· exact ⟨hm, hθfib.1, hηfib.1,
maps_eq_of_mem_fiberCorrespondence
(forwardCumulantMap_mem_bandSupportedCumulants m L)
(reverseCumulantMap_mem_bandSupportedCumulants m L) hθfib hηfib,
Or.inr hηgen⟩
· funext r a
by_cases hra : 2 ≤ r ∧ r ≤ L ∧ a ≤ r
· exact hθfib.2 r a hra.1 hra.2.1 hra.2.2
· exact (forwardCumulantMap_mem_bandSupportedCumulants m L θ r a hra).trans
(htband r a hra).symm
· rintro ⟨⟨θ, η⟩, hp, rfl⟩
rcases hp with ⟨_, hθband, hηband, heq, hgen | hgen⟩
· refine ⟨forwardCumulantMap_mem_bandSupportedCumulants m L θ, Or.inl ?_⟩
exact ⟨⟨θ, mem_fiberCorrespondence_self hθband, hgen⟩,
⟨η, hηband, fun r a hr hrL ha => by rw [← heq]⟩⟩
· refine ⟨forwardCumulantMap_mem_bandSupportedCumulants m L θ, Or.inr ?_⟩
exact ⟨⟨η, ⟨hηband, fun r a hr hrL ha => by rw [← heq]⟩, hgen⟩,
⟨θ, mem_fiberCorrespondence_self hθband⟩⟩
Helpers.ExceptionalJacobianCoordinates 50 declarations Loading-slope derivatives
Loading-slope derivatives
theorem eval_forwardBandLoadingPolynomial
Gives the stated evaluation formula for eval forward Band Loading Polynomial.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma eval_forwardBandLoadingPolynomial (m L : ℕ)
(x : BandParamCoord m L → ℂ) (j : Fin (m + 2)) :
(eval x (forwardBandLoadingPolynomial m L j).1,
eval x (forwardBandLoadingPolynomial m L j).2) =
forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j := by
by_cases h0 : j.val = 0
· simp [forwardBandLoadingPolynomial, forwardLoading, h0,
bandDirectPolynomial, decodeBandParam]
· by_cases hlast : j.val = m + 1
· simp [forwardBandLoadingPolynomial, forwardLoading, h0, hlast]
· simp [forwardBandLoadingPolynomial, forwardLoading, h0, hlast,
bandLatentPolynomial, decodeBandParam]
def explicitForwardBandCoordinatePolynomial
A definitionally explicit representative of the forward retained coordinate polynomial. Unlike the Classical.choose representative, its partial derivatives simplify directly.
Definition (Lean source)
def explicitForwardBandCoordinatePolynomial (m L : ℕ) (hL : 2 ≤ L)
(q : RetainedCumCoord L) : MvPolynomial (BandParamCoord m L) ℂ :=
∑ j : Fin (m + 2),
bandWeightPolynomial m L j ⟨q.1.1 - 2, by omega⟩ *
(forwardBandLoadingPolynomial m L j).1 ^ (q.1.1 - q.1.2.1) *
(forwardBandLoadingPolynomial m L j).2 ^ q.1.2.1
theorem eval_explicitForwardBandCoordinatePolynomial
The explicit representative computes the right thing: evaluated at any finite parameter coordinate vector it returns the corresponding retained cumulant coordinate of the forward band map, namely the sum over sources of that source's weight at the given order times the binary-form monomial in the source's loading direction.
Formal statement
hypotheses
conclusion
eval x (explicitForwardBandCoordinatePolynomial m L hL q)
= forwardBandFiniteMap m L x q
Proof (Lean source)
lemma eval_explicitForwardBandCoordinatePolynomial (m L : ℕ) (hL : 2 ≤ L)
(q : RetainedCumCoord L) (x : BandParamCoord m L → ℂ) :
eval x (explicitForwardBandCoordinatePolynomial m L hL q) =
forwardBandFiniteMap m L x q := by
simp only [explicitForwardBandCoordinatePolynomial, map_sum, map_mul, map_pow,
bandWeightPolynomial, MvPolynomial.eval_X]
simp only [forwardBandFiniteMap, restrictCumBand, forwardCumulantMap]
have hqL : q.1.1 ≤ L := by omega
rw [if_pos ⟨q.2.1, hqL, q.2.2⟩]
apply Finset.sum_congr rfl
intro j _
rw [show eval x (forwardBandLoadingPolynomial m L j).1 =
(forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j).1 by
simpa using congrArg fst
(eval_forwardBandLoadingPolynomial m L x j),
show eval x (forwardBandLoadingPolynomial m L j).2 =
(forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j).2 by
simpa using congrArg snd
(eval_forwardBandLoadingPolynomial m L x j)]
simp only [decodeBandParam]
rw [dif_pos ⟨q.2.1, hqL⟩]
theorem forwardBandCoordinatePolynomial_eq_explicit
The chosen coordinate family used by the promoted substrate is equal to the explicit coordinate polynomial above.
Formal statement
hypotheses
conclusion
forwardBandCoordinatePolynomial m L hL q
= explicitForwardBandCoordinatePolynomial m L hL q
Proof (Lean source)
theorem forwardBandCoordinatePolynomial_eq_explicit (m L : ℕ) (hL : 2 ≤ L)
(q : RetainedCumCoord L) :
forwardBandCoordinatePolynomial m L hL q =
explicitForwardBandCoordinatePolynomial m L hL q := by
apply MvPolynomial.funext
intro x
rw [eval_forwardBandCoordinatePolynomial,
eval_explicitForwardBandCoordinatePolynomial]
theorem pderiv_forwardBandCoordinatePolynomial_eq_explicit
Partial derivatives of the canonical chosen coordinates may henceforth be computed from the explicit representative.
Formal statement
hypotheses
conclusion
pderiv c (forwardBandCoordinatePolynomial m L hL q)
= pderiv c (explicitForwardBandCoordinatePolynomial m L hL q)
Proof (Lean source)
theorem pderiv_forwardBandCoordinatePolynomial_eq_explicit
(m L : ℕ) (hL : 2 ≤ L) (q : RetainedCumCoord L)
(c : BandParamCoord m L) :
pderiv c (forwardBandCoordinatePolynomial m L hL q) =
pderiv c
(explicitForwardBandCoordinatePolynomial m L hL q) := by
rw [forwardBandCoordinatePolynomial_eq_explicit]
theorem pderiv_explicitForwardBandCoordinatePolynomial_weight
A weight derivative is the corresponding binary-form monomial. This is the ordinary Vandermonde block used at every retained order.
Formal statement
hypotheses
conclusion
= (forwardBandLoadingPolynomial m L j).1 ^ (q.1.1 - q.1.2.1) * (forwardBandLoadingPolynomial m L j).2 ^ q.1.2.1
Proof (Lean source)
lemma pderiv_explicitForwardBandCoordinatePolynomial_weight
(m L : ℕ) (hL : 2 ≤ L) (q : RetainedCumCoord L)
(j : Fin (m + 2)) :
pderiv
(inr (inr (j, ⟨q.1.1 - 2, by omega⟩)))
(explicitForwardBandCoordinatePolynomial m L hL q) =
(forwardBandLoadingPolynomial m L j).1 ^ (q.1.1 - q.1.2.1) *
(forwardBandLoadingPolynomial m L j).2 ^ q.1.2.1 := by
classical
simp only [explicitForwardBandCoordinatePolynomial, map_sum,
MvPolynomial.pderiv_mul, MvPolynomial.pderiv_pow]
rw [Finset.sum_eq_single j]
· have hload := pderiv_weight_forwardBandLoadingPolynomial m L j j
⟨q.1.1 - 2, by omega⟩ ⟨q.1.1 - 2, by omega⟩
rw [hload.1, hload.2]
simp [bandWeightPolynomial]
· intro k _ hkj
let a : Fin (L - 1) := ⟨q.1.1 - 2, by omega⟩
have hpair : (k, a) ≠ (j, a) := by
intro h
exact hkj (congrArg fst h)
have hload := pderiv_weight_forwardBandLoadingPolynomial m L j k a a
rw [hload.1, hload.2]
simp [bandWeightPolynomial, a, hpair]
· intro h
exact (h (Finset.mem_univ j)).elim
theorem pderiv_explicitForwardBandCoordinatePolynomial_weight_otherOrder
A weight coordinate belonging to a different retained order has zero derivative. This is the off-diagonal vanishing used by the block Jacobian.
Formal statement
hypotheses
conclusion
= 0
Proof (Lean source)
lemma pderiv_explicitForwardBandCoordinatePolynomial_weight_otherOrder
(m L : ℕ) (hL : 2 ≤ L) (q : RetainedCumCoord L)
(j : Fin (m + 2)) (k : Fin (L - 1))
(hk : k.val ≠ q.1.1 - 2) :
pderiv
(inr (inr (j, k)) : BandParamCoord m L)
(explicitForwardBandCoordinatePolynomial m L hL q) = 0 := by
classical
simp only [explicitForwardBandCoordinatePolynomial, map_sum,
MvPolynomial.pderiv_mul, MvPolynomial.pderiv_pow]
apply Finset.sum_eq_zero
intro i _
have hload := pderiv_weight_forwardBandLoadingPolynomial m L j i k k
rw [hload.1, hload.2]
have hpair :
((i, ⟨q.1.1 - 2, by omega⟩) : Fin (m + 2) × Fin (L - 1)) ≠ (j, k) := by
intro h
apply hk
have := congrArg (fun z : Fin (m + 2) × Fin (L - 1) => z.2.val) h
simpa using this.symm
simp [bandWeightPolynomial, hpair]
theorem eval_pderiv_explicitForwardBandCoordinatePolynomial_weight
Gives the stated evaluation formula for eval pderiv explicit Forward Band Coordinate Polynomial weight.
Formal statement
hypotheses
conclusion
eval x (pderiv (inr (inr (j, ⟨q.1.1 - 2, by omega⟩))) (explicitForwardBandCoordinatePolynomial m L hL q))
= (forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j).1 ^ (q.1.1 - q.1.2.1) * (forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j).2 ^ q.1.2.1
Proof (Lean source)
lemma eval_pderiv_explicitForwardBandCoordinatePolynomial_weight
(m L : ℕ) (hL : 2 ≤ L) (q : RetainedCumCoord L)
(j : Fin (m + 2)) (x : BandParamCoord m L → ℂ) :
eval x
(pderiv
(inr (inr (j, ⟨q.1.1 - 2, by omega⟩)))
(explicitForwardBandCoordinatePolynomial m L hL q)) =
(forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j).1 ^
(q.1.1 - q.1.2.1) *
(forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j).2 ^
q.1.2.1 := by
rw [pderiv_explicitForwardBandCoordinatePolynomial_weight]
simp only [map_mul, map_pow]
rw [show eval x (forwardBandLoadingPolynomial m L j).1 =
(forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j).1 by
simpa using congrArg fst
(eval_forwardBandLoadingPolynomial m L x j),
show eval x (forwardBandLoadingPolynomial m L j).2 =
(forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j).2 by
simpa using congrArg snd
(eval_forwardBandLoadingPolynomial m L x j)]
theorem pderiv_explicitForwardBandCoordinatePolynomial_weight_general
Weight derivatives at an arbitrary retained order. Distinct weight-order blocks do not interact; the matching block is the binary-form monomial.
Formal statement
hypotheses
conclusion
= if k.val = q.1.1
- 2 then (forwardBandLoadingPolynomial m L j).1 ^ (q.1.1 - q.1.2.1) * (forwardBandLoadingPolynomial m L j).2 ^ q.1.2.1 else 0
Proof (Lean source)
lemma pderiv_explicitForwardBandCoordinatePolynomial_weight_general
(m L : ℕ) (hL : 2 ≤ L) (q : RetainedCumCoord L)
(j : Fin (m + 2)) (k : Fin (L - 1)) :
pderiv
(inr (inr (j, k)) : BandParamCoord m L)
(explicitForwardBandCoordinatePolynomial m L hL q) =
if k.val = q.1.1 - 2 then
(forwardBandLoadingPolynomial m L j).1 ^ (q.1.1 - q.1.2.1) *
(forwardBandLoadingPolynomial m L j).2 ^ q.1.2.1
else 0 := by
classical
by_cases hk : k.val = q.1.1 - 2
· rw [if_pos hk]
have hcoord :
(inr (inr (j, k)) : BandParamCoord m L) =
inr (inr (j, ⟨q.1.1 - 2, by omega⟩)) := by
apply congrArg (fun a : Fin (L - 1) =>
(inr (inr (j, a)) : BandParamCoord m L))
apply Fin.ext
exact hk
rw [hcoord]
exact pderiv_explicitForwardBandCoordinatePolynomial_weight m L hL q j
· rw [if_neg hk]
simp only [explicitForwardBandCoordinatePolynomial, map_sum,
MvPolynomial.pderiv_mul, MvPolynomial.pderiv_pow]
apply Finset.sum_eq_zero
intro i _
have hload := pderiv_weight_forwardBandLoadingPolynomial m L j i k k
rw [hload.1, hload.2]
have hpair : ((i, ⟨q.1.1 - 2, by omega⟩) :
Fin (m + 2) × Fin (L - 1)) ≠ (j, k) := by
intro h
apply hk
have := congrArg (fun p : Fin (m + 2) × Fin (L - 1) => p.2.val) h
simpa using this.symm
simp [bandWeightPolynomial, hpair]
theorem eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general
Gives the stated evaluation formula for eval pderiv explicit Forward Band Coordinate Polynomial weight general.
Formal statement
hypotheses
conclusion
eval x (pderiv (inr (inr (j, k)) : BandParamCoord m L) (explicitForwardBandCoordinatePolynomial m L hL q))
= if k.val = q.1.1
- 2 then (forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j).1 ^ (q.1.1 - q.1.2.1) * (forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j).2 ^ q.1.2.1 else 0
Proof (Lean source)
lemma eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general
(m L : ℕ) (hL : 2 ≤ L) (q : RetainedCumCoord L)
(j : Fin (m + 2)) (k : Fin (L - 1))
(x : BandParamCoord m L → ℂ) :
eval x
(pderiv
(inr (inr (j, k)) : BandParamCoord m L)
(explicitForwardBandCoordinatePolynomial m L hL q)) =
if k.val = q.1.1 - 2 then
(forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j).1 ^
(q.1.1 - q.1.2.1) *
(forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j).2 ^
q.1.2.1
else 0 := by
rw [pderiv_explicitForwardBandCoordinatePolynomial_weight_general]
split
· simp only [map_mul, map_pow]
rw [show eval x (forwardBandLoadingPolynomial m L j).1 =
(forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j).1 by
simpa using congrArg fst (eval_forwardBandLoadingPolynomial m L x j),
show eval x (forwardBandLoadingPolynomial m L j).2 =
(forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 j).2 by
simpa using congrArg snd (eval_forwardBandLoadingPolynomial m L x j)]
· simp
def ForwardSlopeIndex
Proves the stated mathematical property of Forward Slope Index.
Definition (Lean source)
def forwardSlopeBandCoord
Defines the mathematical object called the forward Slope Band Coord.
Definition (Lean source)
def forwardSlopeBandCoord (m L : ℕ) :
ForwardSlopeIndex m → BandParamCoord m L
| inl u => inl u
| inr i => inr (inl i)
def forwardSlopeSourceIndex
Defines the index set used to select the forward Slope Source Index coordinates.
Definition (Lean source)
def forwardSlopeSourceIndex (m : ℕ) : ForwardSlopeIndex m → Fin (m + 2)
| inl _ => ⟨0, by omega⟩
| inr i => ⟨i.val + 1, by omega⟩
theorem forwardSlopeSourceIndex_injective
Proves that the map or coordinate assignment called the forward Slope Source Index is injective.
Formal statement
Proof (Lean source)
lemma forwardSlopeSourceIndex_injective (m : ℕ) :
Injective (forwardSlopeSourceIndex m) := by
intro i j hij
rcases i with _ | i <;> rcases j with _ | j
· rfl
· have h := congrArg val hij
simp [forwardSlopeSourceIndex] at h
· have h := congrArg val hij
simp [forwardSlopeSourceIndex] at h
· congr 1
apply Fin.ext
have h := congrArg val hij
simp [forwardSlopeSourceIndex] at h
omega
theorem pderiv_explicitForwardBandCoordinatePolynomial_slope
A loading-slope derivative is the derivative column of the corresponding finite node, multiplied by that source's weight.
Formal statement
hypotheses
conclusion
= bandWeightPolynomial m L (forwardSlopeSourceIndex m s) ⟨q.1.1
- 2, by omega⟩ * (forwardBandLoadingPolynomial m L (forwardSlopeSourceIndex m s)).1 ^ (q.1.1 - q.1.2.1) * (C (q.1.2.1 : ℂ) * (forwardBandLoadingPolynomial m L (forwardSlopeSourceIndex m s)).2 ^ (q.1.2.1 - 1))
Proof (Lean source)
lemma pderiv_explicitForwardBandCoordinatePolynomial_slope
(m L : ℕ) (hL : 2 ≤ L) (q : RetainedCumCoord L)
(s : ForwardSlopeIndex m) :
pderiv (forwardSlopeBandCoord m L s)
(explicitForwardBandCoordinatePolynomial m L hL q) =
bandWeightPolynomial m L (forwardSlopeSourceIndex m s)
⟨q.1.1 - 2, by omega⟩ *
(forwardBandLoadingPolynomial m L
(forwardSlopeSourceIndex m s)).1 ^ (q.1.1 - q.1.2.1) *
(C (q.1.2.1 : ℂ) *
(forwardBandLoadingPolynomial m L
(forwardSlopeSourceIndex m s)).2 ^ (q.1.2.1 - 1)) := by
classical
simp only [explicitForwardBandCoordinatePolynomial, map_sum]
rw [Finset.sum_eq_single (forwardSlopeSourceIndex m s)]
· have hload := pderiv_forwardSlope_forwardBandLoadingPolynomial
m L s (forwardSlopeSourceIndex m s)
rw [MvPolynomial.pderiv_mul, MvPolynomial.pderiv_mul,
MvPolynomial.pderiv_pow, MvPolynomial.pderiv_pow,
pderiv_forwardSlope_bandWeightPolynomial, hload.1, hload.2]
simp [bandWeightPolynomial]
· intro j _ hj
have hload := pderiv_forwardSlope_forwardBandLoadingPolynomial m L s j
rw [MvPolynomial.pderiv_mul, MvPolynomial.pderiv_mul,
MvPolynomial.pderiv_pow, MvPolynomial.pderiv_pow,
pderiv_forwardSlope_bandWeightPolynomial, hload.1, hload.2, if_neg hj]
simp [bandWeightPolynomial]
· intro h
exact (h (Finset.mem_univ _)).elim
theorem eval_pderiv_explicitForwardBandCoordinatePolynomial_slope
Evaluation form of the slope derivative. This is the entry formula used to identify the selected top-order Jacobian block with a confluent Vandermonde matrix.
Formal statement
hypotheses
conclusion
= (decodeBandParam x).2.2 (forwardSlopeSourceIndex m s) q.1.1 * (forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 (forwardSlopeSourceIndex m s)).1 ^ (q.1.1 - q.1.2.1) * ((q.1.2.1 : ℂ) * (forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1 (forwardSlopeSourceIndex m s)).2 ^ (q.1.2.1 - 1))
Proof (Lean source)
lemma eval_pderiv_explicitForwardBandCoordinatePolynomial_slope
(m L : ℕ) (hL : 2 ≤ L) (q : RetainedCumCoord L)
(s : ForwardSlopeIndex m) (x : BandParamCoord m L → ℂ) :
eval x
(pderiv (forwardSlopeBandCoord m L s)
(explicitForwardBandCoordinatePolynomial m L hL q)) =
(decodeBandParam x).2.2 (forwardSlopeSourceIndex m s) q.1.1 *
(forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1
(forwardSlopeSourceIndex m s)).1 ^ (q.1.1 - q.1.2.1) *
((q.1.2.1 : ℂ) *
(forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1
(forwardSlopeSourceIndex m s)).2 ^ (q.1.2.1 - 1)) := by
rw [pderiv_explicitForwardBandCoordinatePolynomial_slope]
simp only [map_mul, map_pow, map_natCast, bandWeightPolynomial,
MvPolynomial.eval_X, MvPolynomial.eval_C]
rw [show eval x
(forwardBandLoadingPolynomial m L (forwardSlopeSourceIndex m s)).1 =
(forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1
(forwardSlopeSourceIndex m s)).1 by
simpa using congrArg fst
(eval_forwardBandLoadingPolynomial m L x
(forwardSlopeSourceIndex m s)),
show eval x
(forwardBandLoadingPolynomial m L (forwardSlopeSourceIndex m s)).2 =
(forwardLoading m (decodeBandParam x).1 (decodeBandParam x).2.1
(forwardSlopeSourceIndex m s)).2 by
simpa using congrArg snd
(eval_forwardBandLoadingPolynomial m L x
(forwardSlopeSourceIndex m s))]
rw [show x (inr (inr
(forwardSlopeSourceIndex m s, ⟨q.1.1 - 2, by omega⟩))) =
(decodeBandParam x).2.2 (forwardSlopeSourceIndex m s) q.1.1 by
simp only [decodeBandParam]
rw [dif_pos ⟨q.2.1, Nat.le_of_lt_succ q.1.1.isLt⟩]]
def finiteSourceSlope
The loading-slope coordinate corresponding to a finite (non-infinity) source.
Definition (Lean source)
def finiteSourceSlope (m : ℕ) : Fin (m + 1) → ForwardSlopeIndex m :=
Fin.cases (inl ()) (fun i => inr i)
theorem forwardSlopeSourceIndex_finiteSourceSlope
The slope coordinate attached to the j-th finite source — the direct slope when j is zero and the corresponding latent slope otherwise — is indeed carried by source j, viewed among the m + 1 finite sources, that is, all sources except the one at infinity.
Formal statement
hypotheses
m :
ℕ
j :
Fin (m + 1)
conclusion
forwardSlopeSourceIndex m (finiteSourceSlope m j) = j.castSucc
Proof (Lean source)
lemma forwardSlopeSourceIndex_finiteSourceSlope (m : ℕ)
(j : Fin (m + 1)) :
forwardSlopeSourceIndex m (finiteSourceSlope m j) = j.castSucc := by
refine Fin.cases ?_ (fun i => ?_) j
· rfl
· apply Fin.ext
simp [finiteSourceSlope, forwardSlopeSourceIndex]
def forwardTopRow
Monomial rows of the top-order finite-source block.
Definition (Lean source)
def forwardTopRow (m : ℕ) (a : Fin (m + 1) ⊕ Fin (m + 1)) :
RetainedCumCoord (2 * m + 2) :=
⟨(⟨2 * m + 2, by omega⟩,
⟨doubledExponent a, by
have h := doubledExponent_lt (n := m + 1) a
omega⟩),
by
change 2 ≤ 2 * m + 2
omega, by
change doubledExponent a ≤ 2 * m + 2
have := doubledExponent_lt (n := m + 1) a
omega⟩
def forwardTopColumn
Value columns are top-order weights; derivative columns are the finite source loading slopes.
Definition (Lean source)
def forwardTopColumn (m : ℕ) :
Fin (m + 1) ⊕ Fin (m + 1) → BandParamCoord m (2 * m + 2)
| inl j =>
inr (inr (j.castSucc, ⟨2 * m, by omega⟩))
| inr j =>
forwardSlopeBandCoord m (2 * m + 2) (finiteSourceSlope m j)
def forwardJacobianWitnessCoord
A finite-coordinate witness tailored to the Jacobian calculation: the finite loading slopes are 1, ..., m+1 and every retained weight is one.
Definition (Lean source)
def forwardJacobianWitnessCoord (m : ℕ) :
BandParamCoord m (2 * m + 2) → ℂ
| inl _ => 1
| inr (inl i) => ((i.val + 2 : ℕ) : ℂ)
| inr (inr _) => 1
theorem forwardJacobianWitness_loading_castSucc
At the Jacobian witness parameter the loading direction of the j-th finite source is the vector with first entry one and second entry j + 1, so the finite loading slopes are the distinct numbers 1, ..., m + 1.
Formal statement
hypotheses
m :
ℕ
j :
Fin (m + 1)
conclusion
forwardLoading m (decodeBandParam (forwardJacobianWitnessCoord m)).1 (decodeBandParam (forwardJacobianWitnessCoord m)).2.1 j.castSucc
= ((1 : ℂ), ((j.val + 1 : ℕ) : ℂ))
Proof (Lean source)
lemma forwardJacobianWitness_loading_castSucc (m : ℕ)
(j : Fin (m + 1)) :
forwardLoading m (decodeBandParam (forwardJacobianWitnessCoord m)).1
(decodeBandParam (forwardJacobianWitnessCoord m)).2.1 j.castSucc =
((1 : ℂ), ((j.val + 1 : ℕ) : ℂ)) := by
refine Fin.cases ?_ (fun i => ?_) j
· simp [forwardLoading, decodeBandParam, forwardJacobianWitnessCoord]
· have hi : i.val ≠ m := Nat.ne_of_lt i.isLt
simp [forwardLoading, decodeBandParam, forwardJacobianWitnessCoord, hi]
push_cast
ring
theorem forwardJacobianWitness_topWeight_castSucc
Proves the stated mathematical property of forward Jacobian Witness top Weight cast Succ.
Formal statement
hypotheses
m :
ℕ
j :
Fin (m + 1)
conclusion
(decodeBandParam (forwardJacobianWitnessCoord m)).2.2 j.castSucc (2 * m + 2) = 1
Proof (Lean source)
lemma forwardJacobianWitness_topWeight_castSucc (m : ℕ)
(j : Fin (m + 1)) :
(decodeBandParam (forwardJacobianWitnessCoord m)).2.2 j.castSucc
(2 * m + 2) = 1 := by
simp [decodeBandParam, forwardJacobianWitnessCoord]
def forwardTopJacobianAtWitness
The selected finite-source part of the top-order Jacobian, evaluated at the explicit witness used elsewhere in the LiNGAM development.
Definition (Lean source)
def forwardTopJacobianAtWitness (m : ℕ) :
Matrix (Fin (m + 1) ⊕ Fin (m + 1))
(Fin (m + 1) ⊕ Fin (m + 1)) ℂ :=
fun a b =>
eval
(forwardJacobianWitnessCoord m)
(pderiv (forwardTopColumn m b)
(explicitForwardBandCoordinatePolynomial m (2 * m + 2) (by omega)
(forwardTopRow m a)))
theorem forwardTopJacobianAtWitness_eq_confluentVandermonde
The top-order finite-source block is exactly the standard doubled-node confluent Vandermonde matrix.
Formal statement
Proof (Lean source)
theorem forwardTopJacobianAtWitness_eq_confluentVandermonde (m : ℕ) :
forwardTopJacobianAtWitness m =
confluentVandermonde
(fun j : Fin (m + 1) => ((j.val + 1 : ℕ) : ℂ)) := by
ext a b
rcases b with j | j
· rw [show forwardTopJacobianAtWitness m a (inl j) =
eval
(forwardJacobianWitnessCoord m)
(pderiv
(inr (inr (j.castSucc, ⟨2 * m, by omega⟩)))
(explicitForwardBandCoordinatePolynomial m (2 * m + 2)
(by omega) (forwardTopRow m a))) by rfl]
rw [show (inr (inr (j.castSucc, ⟨2 * m, by omega⟩)) :
BandParamCoord m (2 * m + 2)) =
inr (inr (j.castSucc,
⟨(forwardTopRow m a).1.1 - 2, by omega⟩)) by
apply congrArg (fun k : Fin (2 * m + 2 - 1) =>
(inr (inr (j.castSucc, k)) :
BandParamCoord m (2 * m + 2)))
apply Fin.ext
rfl]
rw [eval_pderiv_explicitForwardBandCoordinatePolynomial_weight]
change
(forwardLoading m (decodeBandParam (forwardJacobianWitnessCoord m)).1
(decodeBandParam (forwardJacobianWitnessCoord m)).2.1 j.castSucc).1 ^
(2 * m + 2 - doubledExponent a) *
(forwardLoading m (decodeBandParam (forwardJacobianWitnessCoord m)).1
(decodeBandParam (forwardJacobianWitnessCoord m)).2.1 j.castSucc).2 ^
doubledExponent a = _
rw [forwardJacobianWitness_loading_castSucc]
simp [confluentVandermonde]
· rw [show forwardTopJacobianAtWitness m a (inr j) =
eval
(forwardJacobianWitnessCoord m)
(pderiv
(forwardSlopeBandCoord m (2 * m + 2) (finiteSourceSlope m j))
(explicitForwardBandCoordinatePolynomial m (2 * m + 2)
(by omega) (forwardTopRow m a))) by rfl]
rw [eval_pderiv_explicitForwardBandCoordinatePolynomial_slope]
rw [forwardSlopeSourceIndex_finiteSourceSlope]
simp only [forwardTopRow]
change
(decodeBandParam (forwardJacobianWitnessCoord m)).2.2 j.castSucc
(2 * m + 2) *
(forwardLoading m (decodeBandParam (forwardJacobianWitnessCoord m)).1
(decodeBandParam (forwardJacobianWitnessCoord m)).2.1 j.castSucc).1 ^
(2 * m + 2 - doubledExponent a) *
((doubledExponent a : ℂ) *
(forwardLoading m (decodeBandParam (forwardJacobianWitnessCoord m)).1
(decodeBandParam (forwardJacobianWitnessCoord m)).2.1 j.castSucc).2 ^
(doubledExponent a - 1)) = _
rw [forwardJacobianWitness_topWeight_castSucc,
forwardJacobianWitness_loading_castSucc]
simp [confluentVandermonde]
theorem det_forwardTopJacobianAtWitness_ne_zero
Proves that the quantity called the det forward Top Jacobian At Witness is nonzero.
Formal statement
Proof (Lean source)
theorem det_forwardTopJacobianAtWitness_ne_zero (m : ℕ) :
(forwardTopJacobianAtWitness m).det ≠ 0 := by
rw [forwardTopJacobianAtWitness_eq_confluentVandermonde]
exact det_confluentVandermonde_ne_zero (by omega)
(fun j : Fin (m + 1) => ((j.val + 1 : ℕ) : ℂ))
(forwardContractionMinorWitness_slope_injective m)
def canonicalForwardTopJacobianAtWitness
The same selected block formed from the canonical coordinate family used by the polynomial-image dimension interface.
Definition (Lean source)
def canonicalForwardTopJacobianAtWitness (m : ℕ) :
Matrix (Fin (m + 1) ⊕ Fin (m + 1))
(Fin (m + 1) ⊕ Fin (m + 1)) ℂ :=
fun a b =>
eval
(forwardJacobianWitnessCoord m)
(pderiv (forwardTopColumn m b)
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega)
(forwardTopRow m a)))
theorem canonicalForwardTopJacobianAtWitness_eq
The selected top-order finite-source Jacobian block is the same matrix whether it is built from the canonical coordinate family used by the polynomial-image dimension interface or from the explicit representative.
Formal statement
Proof (Lean source)
theorem canonicalForwardTopJacobianAtWitness_eq (m : ℕ) :
canonicalForwardTopJacobianAtWitness m = forwardTopJacobianAtWitness m := by
ext a b
simp only [canonicalForwardTopJacobianAtWitness, forwardTopJacobianAtWitness]
rw [pderiv_forwardBandCoordinatePolynomial_eq_explicit]
theorem det_canonicalForwardTopJacobianAtWitness_ne_zero
Proves that the quantity called the det canonical Forward Top Jacobian At Witness is nonzero.
Formal statement
Proof (Lean source)
theorem det_canonicalForwardTopJacobianAtWitness_ne_zero (m : ℕ) :
(canonicalForwardTopJacobianAtWitness m).det ≠ 0 := by
rw [canonicalForwardTopJacobianAtWitness_eq]
exact det_forwardTopJacobianAtWitness_ne_zero m
def ForwardTopAugmentedIndex
Proves the stated mathematical property of Forward Top Augmented Index.
Definition (Lean source)
def forwardTopAugmentedRow
Defines the mathematical object called the forward Top Augmented Row.
Definition (Lean source)
def forwardTopAugmentedRow (m : ℕ) :
ForwardTopAugmentedIndex m → RetainedCumCoord (2 * m + 2)
| inl a => forwardTopRow m a
| inr _ =>
⟨(⟨2 * m + 2, by omega⟩, ⟨2 * m + 2, by omega⟩),
by change 2 ≤ 2 * m + 2; omega,
by change 2 * m + 2 ≤ 2 * m + 2; omega⟩
def forwardTopAugmentedColumn
Defines the mathematical object called the forward Top Augmented Column.
Definition (Lean source)
def forwardTopAugmentedColumn (m : ℕ) :
ForwardTopAugmentedIndex m → BandParamCoord m (2 * m + 2)
| inl b => forwardTopColumn m b
| inr _ =>
inr (inr (last (m + 1), ⟨2 * m, by omega⟩))
def canonicalForwardTopAugmentedJacobianAtWitness
Defines the Jacobian matrix, row, column, or indexing object called the canonical Forward Top Augmented Jacobian At Witness.
Definition (Lean source)
def canonicalForwardTopAugmentedJacobianAtWitness (m : ℕ) :
Matrix (ForwardTopAugmentedIndex m) (ForwardTopAugmentedIndex m) ℂ :=
fun a b =>
eval (forwardJacobianWitnessCoord m)
(pderiv (forwardTopAugmentedColumn m b)
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega)
(forwardTopAugmentedRow m a)))
theorem forwardJacobianWitness_loading_last
Proves the stated mathematical property of forward Jacobian Witness loading last.
Formal statement
hypotheses
m :
ℕ
conclusion
forwardLoading m (decodeBandParam (forwardJacobianWitnessCoord m)).1 (decodeBandParam (forwardJacobianWitnessCoord m)).2.1 (last (m + 1))
= (0, 1)
Proof (Lean source)
lemma forwardJacobianWitness_loading_last (m : ℕ) :
forwardLoading m (decodeBandParam (forwardJacobianWitnessCoord m)).1
(decodeBandParam (forwardJacobianWitnessCoord m)).2.1
(last (m + 1)) = (0, 1) := by
simp [forwardLoading, decodeBandParam, forwardJacobianWitnessCoord, last]
theorem canonicalForwardTopAugmentedJacobianAtWitness_eq
Proves the stated equality or equivalence for canonical Forward Top Augmented Jacobian At Witness eq.
Formal statement
hypotheses
m :
ℕ
conclusion
= fromBlocks (canonicalForwardTopJacobianAtWitness m) 0 (forwardTopAugmentedLowerLeft m) 1
Proof (Lean source)
theorem canonicalForwardTopAugmentedJacobianAtWitness_eq (m : ℕ) :
canonicalForwardTopAugmentedJacobianAtWitness m =
fromBlocks (canonicalForwardTopJacobianAtWitness m) 0
(forwardTopAugmentedLowerLeft m) 1 := by
ext a b
rcases a with a | u <;> rcases b with b | v
· rfl
· obtain rfl : v = () := Subsingleton.elim _ _
simp only [canonicalForwardTopAugmentedJacobianAtWitness,
forwardTopAugmentedColumn, forwardTopAugmentedRow,
Matrix.fromBlocks_apply₁₂, Pi.zero_apply]
rw [pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by rfl)]
change
(forwardLoading m (decodeBandParam (forwardJacobianWitnessCoord m)).1
(decodeBandParam (forwardJacobianWitnessCoord m)).2.1
(last (m + 1))).1 ^
(2 * m + 2 - doubledExponent a) *
(forwardLoading m (decodeBandParam (forwardJacobianWitnessCoord m)).1
(decodeBandParam (forwardJacobianWitnessCoord m)).2.1
(last (m + 1))).2 ^ doubledExponent a = 0
rw [forwardJacobianWitness_loading_last]
simp [show 2 * m + 2 - doubledExponent a ≠ 0 by
have := doubledExponent_lt (n := m + 1) a
omega]
· rfl
· obtain rfl : u = () := Subsingleton.elim _ _
obtain rfl : v = () := Subsingleton.elim _ _
simp only [canonicalForwardTopAugmentedJacobianAtWitness,
forwardTopAugmentedColumn, forwardTopAugmentedRow,
Matrix.fromBlocks_apply₂₂, Matrix.one_apply]
rw [pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by rfl)]
rw [forwardJacobianWitness_loading_last]
simp
theorem det_canonicalForwardTopAugmentedJacobianAtWitness_ne_zero
Proves that the quantity called the det canonical Forward Top Augmented Jacobian At Witness is nonzero.
Formal statement
Proof (Lean source)
theorem det_canonicalForwardTopAugmentedJacobianAtWitness_ne_zero (m : ℕ) :
(canonicalForwardTopAugmentedJacobianAtWitness m).det ≠ 0 := by
rw [canonicalForwardTopAugmentedJacobianAtWitness_eq,
Matrix.det_fromBlocks_zero₁₂, Matrix.det_one, mul_one]
exact det_canonicalForwardTopJacobianAtWitness_ne_zero m
def ForwardLowWeightIndex
Proves the stated mathematical property of Forward Low Weight Index.
Definition (Lean source)
def forwardLowWeightRow
Defines the mathematical object called the forward Low Weight Row.
Definition (Lean source)
def forwardLowWeightRow (m : ℕ) :
ForwardLowWeightIndex m → RetainedCumCoord (2 * m + 2)
| ⟨k, a⟩ =>
⟨(⟨k.val + 2, by omega⟩, ⟨a.val, by omega⟩),
by change 2 ≤ k.val + 2; omega,
by change a.val ≤ k.val + 2; have := a.isLt; omega⟩
def forwardLowWeightColumn
Defines the mathematical object called the forward Low Weight Column.
Definition (Lean source)
def forwardLowWeightColumn (m : ℕ) :
ForwardLowWeightIndex m → BandParamCoord m (2 * m + 2)
| ⟨k, a⟩ =>
inr (inr
(⟨a.val, by have := a.isLt; have := k.isLt; omega⟩, ⟨k.val, by omega⟩))
def canonicalForwardLowWeightJacobianAtWitness
Defines the Jacobian matrix, row, column, or indexing object called the canonical Forward Low Weight Jacobian At Witness.
Definition (Lean source)
def canonicalForwardLowWeightJacobianAtWitness (m : ℕ) :
Matrix (ForwardLowWeightIndex m) (ForwardLowWeightIndex m) ℂ :=
fun a b =>
eval (forwardJacobianWitnessCoord m)
(pderiv (forwardLowWeightColumn m b)
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega)
(forwardLowWeightRow m a)))
theorem canonicalForwardLowWeightJacobianAtWitness_eq
Proves the stated equality or equivalence for canonical Forward Low Weight Jacobian At Witness eq.
Formal statement
Proof (Lean source)
theorem canonicalForwardLowWeightJacobianAtWitness_eq (m : ℕ) :
canonicalForwardLowWeightJacobianAtWitness m =
blockDiagonal' (forwardLowVandermondeBlock m) := by
ext a b
rcases a with ⟨ka, a⟩
rcases b with ⟨kb, b⟩
by_cases h : ka = kb
· subst kb
rw [Matrix.blockDiagonal'_apply_eq]
simp only [canonicalForwardLowWeightJacobianAtWitness,
forwardLowWeightColumn, forwardLowWeightRow]
rw [pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by rfl)]
let j : Fin (m + 1) := ⟨b.val, by
have := b.isLt
have := ka.isLt
omega⟩
change
(forwardLoading m (decodeBandParam (forwardJacobianWitnessCoord m)).1
(decodeBandParam (forwardJacobianWitnessCoord m)).2.1 j.castSucc).1 ^
(ka.val + 2 - a.val) *
(forwardLoading m (decodeBandParam (forwardJacobianWitnessCoord m)).1
(decodeBandParam (forwardJacobianWitnessCoord m)).2.1 j.castSucc).2 ^
a.val = _
rw [forwardJacobianWitness_loading_castSucc]
simp [forwardLowVandermondeBlock, Matrix.vandermonde, j]
· rw [Matrix.blockDiagonal'_apply_ne _ _ _ h]
simp only [canonicalForwardLowWeightJacobianAtWitness,
forwardLowWeightColumn, forwardLowWeightRow]
rw [pderiv_forwardBandCoordinatePolynomial_eq_explicit,
pderiv_explicitForwardBandCoordinatePolynomial_weight_otherOrder]
· simp
· intro heq
apply h
apply Fin.ext
simpa using heq.symm
theorem det_canonicalForwardLowWeightJacobianAtWitness_ne_zero
Proves that the quantity called the det canonical Forward Low Weight Jacobian At Witness is nonzero.
Formal statement
Proof (Lean source)
theorem det_canonicalForwardLowWeightJacobianAtWitness_ne_zero (m : ℕ) :
(canonicalForwardLowWeightJacobianAtWitness m).det ≠ 0 := by
rw [canonicalForwardLowWeightJacobianAtWitness_eq]
have hblocks : IsUnit (forwardLowVandermondeBlock m) := by
rw [Pi.isUnit_iff]
intro k
rw [Matrix.isUnit_iff_isUnit_det]
rw [forwardLowVandermondeBlock, Matrix.det_transpose]
exact (Matrix.det_vandermonde_ne_zero_iff.mpr (by
intro i j hij
apply Fin.ext
have hc : (i.val : ℂ) + 1 = (j.val : ℂ) + 1 := by
simpa using hij
exact_mod_cast add_right_cancel hc)).isUnit
have hmatrix : IsUnit (blockDiagonal'
(forwardLowVandermondeBlock m)) :=
hblocks.map (Matrix.blockDiagonal'RingHom
(fun k : Fin (m - 1) => Fin (k.val + 3)) ℂ)
exact ((Matrix.isUnit_iff_isUnit_det _).mp hmatrix).ne_zero
def ForwardHighWeightNode
Proves the stated mathematical property of Forward High Weight Node.
Definition (Lean source)
def ForwardHighWeightIndex
Proves the stated mathematical property of Forward High Weight Index.
Definition (Lean source)
def forwardHighWeightRow
Defines the mathematical object called the forward High Weight Row.
Definition (Lean source)
def forwardHighWeightRow (m : ℕ) (hm : 1 ≤ m) :
ForwardHighWeightIndex m → RetainedCumCoord (2 * m + 2)
| (inl a, k) =>
⟨(⟨forwardHighOrder m k, by
have := k.isLt
simp only [forwardHighOrder]
omega⟩,
⟨a.val, by
have := a.isLt
have := k.isLt
omega⟩), by
simp only [forwardHighOrder]
omega, by
have := a.isLt
simp only [forwardHighOrder]
omega⟩
| (inr _, k) =>
⟨(⟨forwardHighOrder m k, by
have := k.isLt
simp only [forwardHighOrder]
omega⟩,
⟨forwardHighOrder m k, by
have := k.isLt
simp only [forwardHighOrder]
omega⟩), by
simp only [forwardHighOrder]
omega, le_rfl⟩
theorem forwardHighWeightRow_order
Proves the stated mathematical property of forward High Weight Row order.
Formal statement
hypotheses
conclusion
(forwardHighWeightRow m hm (a, k)).1.1 = m + 1 + k.val
Proof (Lean source)
lemma forwardHighWeightRow_order (m : ℕ) (hm : 1 ≤ m)
(a : ForwardHighWeightNode m) (k : Fin (m + 1)) :
(forwardHighWeightRow m hm (a, k)).1.1 = m + 1 + k.val := by
rcases a with a | u <;> rfl
def forwardHighWeightColumn
Defines the mathematical object called the forward High Weight Column.
Definition (Lean source)
def forwardHighWeightColumn (m : ℕ) :
ForwardHighWeightIndex m → BandParamCoord m (2 * m + 2)
| (inl j, k) =>
inr (inr (j.castSucc, ⟨m - 1 + k.val, by
have := k.isLt
omega⟩))
| (inr _, k) =>
inr (inr (last (m + 1), ⟨m - 1 + k.val, by
have := k.isLt
omega⟩))
def canonicalForwardHighWeightJacobianAtWitness
Defines the Jacobian matrix, row, column, or indexing object called the canonical Forward High Weight Jacobian At Witness.
Definition (Lean source)
def canonicalForwardHighWeightJacobianAtWitness (m : ℕ) (hm : 1 ≤ m) :
Matrix (ForwardHighWeightIndex m) (ForwardHighWeightIndex m) ℂ :=
fun a b =>
eval (forwardJacobianWitnessCoord m)
(pderiv (forwardHighWeightColumn m b)
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega)
(forwardHighWeightRow m hm a)))
theorem canonicalForwardHighWeightJacobianAtWitness_eq
Proves the stated equality or equivalence for canonical Forward High Weight Jacobian At Witness eq.
Formal statement
Proof (Lean source)
theorem canonicalForwardHighWeightJacobianAtWitness_eq (m : ℕ) (hm : 1 ≤ m) :
canonicalForwardHighWeightJacobianAtWitness m hm =
blockDiagonal (forwardHighWeightBlock m) := by
ext a b
rcases a with ⟨a, ka⟩
rcases b with ⟨b, kb⟩
by_cases h : ka = kb
· subst kb
rw [Matrix.blockDiagonal_apply_eq]
rcases a with a | u <;> rcases b with b | v
· simp only [canonicalForwardHighWeightJacobianAtWitness,
forwardHighWeightColumn, forwardHighWeightRow,
forwardHighWeightBlock_eq, Matrix.fromBlocks_apply₁₁]
rw [pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by simp only [forwardHighOrder]; omega)]
change
(forwardLoading m (decodeBandParam (forwardJacobianWitnessCoord m)).1
(decodeBandParam (forwardJacobianWitnessCoord m)).2.1 b.castSucc).1 ^
(forwardHighOrder m ka - a.val) *
(forwardLoading m (decodeBandParam (forwardJacobianWitnessCoord m)).1
(decodeBandParam (forwardJacobianWitnessCoord m)).2.1 b.castSucc).2 ^
a.val = _
rw [forwardJacobianWitness_loading_castSucc]
simp [Matrix.vandermonde]
· obtain rfl : v = () := Subsingleton.elim _ _
simp only [canonicalForwardHighWeightJacobianAtWitness,
forwardHighWeightColumn, forwardHighWeightRow,
forwardHighWeightBlock_eq, Matrix.fromBlocks_apply₁₂, Pi.zero_apply]
rw [pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by simp only [forwardHighOrder]; omega),
forwardJacobianWitness_loading_last]
simp [show forwardHighOrder m ka - a.val ≠ 0 by
have := a.isLt
simp only [forwardHighOrder]
omega]
· obtain rfl : u = () := Subsingleton.elim _ _
simp only [canonicalForwardHighWeightJacobianAtWitness,
forwardHighWeightColumn, forwardHighWeightRow,
forwardHighWeightBlock_eq, Matrix.fromBlocks_apply₂₁]
rw [pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by simp only [forwardHighOrder]; omega),
forwardJacobianWitness_loading_castSucc]
simp
· obtain rfl : u = () := Subsingleton.elim _ _
obtain rfl : v = () := Subsingleton.elim _ _
simp only [canonicalForwardHighWeightJacobianAtWitness,
forwardHighWeightColumn, forwardHighWeightRow,
forwardHighWeightBlock_eq, Matrix.fromBlocks_apply₂₂, Matrix.one_apply]
rw [pderiv_forwardBandCoordinatePolynomial_eq_explicit,
eval_pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_pos (by simp only [forwardHighOrder]; omega),
forwardJacobianWitness_loading_last]
simp
· rw [Matrix.blockDiagonal_apply_ne _ _ _ h]
rcases a with a | u <;> rcases b with b | v
all_goals try { obtain rfl : u = () := Subsingleton.elim _ _ }
all_goals try { obtain rfl : v = () := Subsingleton.elim _ _ }
all_goals
simp only [canonicalForwardHighWeightJacobianAtWitness,
forwardHighWeightColumn, forwardHighWeightRow]
rw [pderiv_forwardBandCoordinatePolynomial_eq_explicit,
pderiv_explicitForwardBandCoordinatePolynomial_weight_general,
if_neg]
· simp
· intro heq
apply h
apply Fin.ext
simp only [forwardHighOrder] at heq
omega
theorem det_canonicalForwardHighWeightJacobianAtWitness_ne_zero
Proves that the quantity called the det canonical Forward High Weight Jacobian At Witness is nonzero.
Formal statement
Proof (Lean source)
theorem det_canonicalForwardHighWeightJacobianAtWitness_ne_zero (m : ℕ)
(hm : 1 ≤ m) :
(canonicalForwardHighWeightJacobianAtWitness m hm).det ≠ 0 := by
rw [canonicalForwardHighWeightJacobianAtWitness_eq,
Matrix.det_blockDiagonal]
exact Finset.prod_ne_zero_iff.mpr fun k _ =>
det_forwardHighWeightBlock_ne_zero m k
Helpers.ExceptionalJacobianMinor 31 declarations The ordinary-order block combines orders 2,...,m and m+1,...,2m+1.
The ordinary-order block combines orders 2,...,m and
m+1,...,2m+1. Only its lower-left block must vanish for the determinant
calculation; the upper-right block is kept explicitly.
def ForwardOrdinaryJacobianIndex
Proves the stated mathematical property of Forward Ordinary Jacobian Index.
Definition (Lean source)
def forwardOrdinaryJacobianRow
Defines the Jacobian matrix, row, column, or indexing object called the forward Ordinary Jacobian Row.
Definition (Lean source)
def forwardOrdinaryJacobianRow (m : ℕ) (hm : 1 ≤ m) :
ForwardOrdinaryJacobianIndex m → RetainedCumCoord (2 * m + 2)
| inl a => forwardLowWeightRow m a
| inr a => forwardHighWeightRow m hm a
def forwardOrdinaryJacobianColumn
Defines the Jacobian matrix, row, column, or indexing object called the forward Ordinary Jacobian Column.
Definition (Lean source)
def forwardOrdinaryJacobianColumn (m : ℕ) :
ForwardOrdinaryJacobianIndex m → BandParamCoord m (2 * m + 2)
| inl b => forwardLowWeightColumn m b
| inr b => forwardHighWeightColumn m b
def canonicalForwardOrdinaryJacobianAtWitness
Defines the Jacobian matrix, row, column, or indexing object called the canonical Forward Ordinary Jacobian At Witness.
Definition (Lean source)
def canonicalForwardOrdinaryJacobianAtWitness (m : ℕ) (hm : 1 ≤ m) :
Matrix (ForwardOrdinaryJacobianIndex m)
(ForwardOrdinaryJacobianIndex m) ℂ :=
fun a b =>
eval (forwardJacobianWitnessCoord m)
(pderiv (forwardOrdinaryJacobianColumn m b)
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega)
(forwardOrdinaryJacobianRow m hm a)))
theorem canonicalForwardOrdinaryJacobianAtWitness_eq
Proves the stated equality or equivalence for canonical Forward Ordinary Jacobian At Witness eq.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
= fromBlocks (canonicalForwardLowWeightJacobianAtWitness m) (forwardOrdinaryUpperRight m hm) 0 (canonicalForwardHighWeightJacobianAtWitness m hm)
Proof (Lean source)
theorem canonicalForwardOrdinaryJacobianAtWitness_eq
(m : ℕ) (hm : 1 ≤ m) :
canonicalForwardOrdinaryJacobianAtWitness m hm =
fromBlocks (canonicalForwardLowWeightJacobianAtWitness m)
(forwardOrdinaryUpperRight m hm) 0
(canonicalForwardHighWeightJacobianAtWitness m hm) := by
ext a b
rcases a with a | a <;> rcases b with b | b
· rfl
· rfl
· rcases a with ⟨a, ka⟩
rcases b with ⟨kb, b⟩
rcases a with a | u
all_goals
simp only [canonicalForwardOrdinaryJacobianAtWitness,
forwardOrdinaryJacobianColumn, forwardOrdinaryJacobianRow,
forwardLowWeightColumn,
Matrix.fromBlocks_apply₂₁, Pi.zero_apply]
apply eval_forward_weight_otherOrder
rw [forwardHighWeightRow_order]
rw [high_order_sub_two m ka.val hm]
intro heq
have hval : kb.val = m - 1 + ka.val := by
simpa using heq
have := kb.isLt
omega
· rfl
theorem det_canonicalForwardOrdinaryJacobianAtWitness_ne_zero
Proves that the quantity called the det canonical Forward Ordinary Jacobian At Witness is nonzero.
Formal statement
Proof (Lean source)
theorem det_canonicalForwardOrdinaryJacobianAtWitness_ne_zero
(m : ℕ) (hm : 1 ≤ m) :
(canonicalForwardOrdinaryJacobianAtWitness m hm).det ≠ 0 := by
rw [canonicalForwardOrdinaryJacobianAtWitness_eq,
Matrix.det_fromBlocks_zero₂₁]
exact mul_ne_zero
(det_canonicalForwardLowWeightJacobianAtWitness_ne_zero m)
(det_canonicalForwardHighWeightJacobianAtWitness_ne_zero m hm)
def ForwardFullJacobianIndex
Proves the stated mathematical property of Forward Full Jacobian Index.
Definition (Lean source)
abbrev ForwardFullJacobianIndex (m : ℕ) :=
ForwardOrdinaryJacobianIndex m ⊕ ForwardTopAugmentedIndex m
def forwardFullJacobianRow
Defines the Jacobian matrix, row, column, or indexing object called the forward Full Jacobian Row.
Definition (Lean source)
def forwardFullJacobianRow (m : ℕ) (hm : 1 ≤ m) :
ForwardFullJacobianIndex m → RetainedCumCoord (2 * m + 2)
| inl a => forwardOrdinaryJacobianRow m hm a
| inr a => forwardTopAugmentedRow m a
def forwardFullJacobianColumn
Defines the Jacobian matrix, row, column, or indexing object called the forward Full Jacobian Column.
Definition (Lean source)
def forwardFullJacobianColumn (m : ℕ) :
ForwardFullJacobianIndex m → BandParamCoord m (2 * m + 2)
| inl b => forwardOrdinaryJacobianColumn m b
| inr b => forwardTopAugmentedColumn m b
def canonicalForwardFullJacobianAtWitness
Defines the Jacobian matrix, row, column, or indexing object called the canonical Forward Full Jacobian At Witness.
Definition (Lean source)
def canonicalForwardFullJacobianAtWitness (m : ℕ) (hm : 1 ≤ m) :
Matrix (ForwardFullJacobianIndex m) (ForwardFullJacobianIndex m) ℂ :=
fun a b =>
eval (forwardJacobianWitnessCoord m)
(pderiv (forwardFullJacobianColumn m b)
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega)
(forwardFullJacobianRow m hm a)))
theorem canonicalForwardFullJacobianAtWitness_eq
Proves the stated equality or equivalence for canonical Forward Full Jacobian At Witness eq.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
= fromBlocks (canonicalForwardOrdinaryJacobianAtWitness m hm) (forwardFullUpperRight m hm) 0 (canonicalForwardTopAugmentedJacobianAtWitness m)
Proof (Lean source)
theorem canonicalForwardFullJacobianAtWitness_eq
(m : ℕ) (hm : 1 ≤ m) :
canonicalForwardFullJacobianAtWitness m hm =
fromBlocks (canonicalForwardOrdinaryJacobianAtWitness m hm)
(forwardFullUpperRight m hm) 0
(canonicalForwardTopAugmentedJacobianAtWitness m) := by
ext a b
rcases a with a | a <;> rcases b with b | b
· rfl
· rfl
· rcases b with b | b
· rcases b with ⟨k, j⟩
rcases a with a | u
· simp only [canonicalForwardFullJacobianAtWitness,
forwardFullJacobianColumn, forwardFullJacobianRow,
forwardOrdinaryJacobianColumn, forwardLowWeightColumn,
forwardTopAugmentedRow, forwardTopRow,
Matrix.fromBlocks_apply₂₁, Pi.zero_apply]
apply eval_forward_weight_otherOrder
change k.val ≠ 2 * m
have := doubledExponent_lt (n := m + 1) a
omega
· simp only [canonicalForwardFullJacobianAtWitness,
forwardFullJacobianColumn, forwardFullJacobianRow,
forwardOrdinaryJacobianColumn, forwardLowWeightColumn,
forwardTopAugmentedRow, Matrix.fromBlocks_apply₂₁, Pi.zero_apply]
apply eval_forward_weight_otherOrder
change k.val ≠ 2 * m
omega
· rcases b with ⟨j, k⟩
rcases j with j | u <;> rcases a with a | v
all_goals
simp only [canonicalForwardFullJacobianAtWitness,
forwardFullJacobianColumn, forwardFullJacobianRow,
forwardOrdinaryJacobianColumn, forwardHighWeightColumn,
forwardTopAugmentedRow, forwardTopRow,
Matrix.fromBlocks_apply₂₁, Pi.zero_apply]
apply eval_forward_weight_otherOrder
change m - 1 + k.val ≠ 2 * m
omega
· rfl
theorem det_canonicalForwardFullJacobianAtWitness_ne_zero
Proves that the quantity called the det canonical Forward Full Jacobian At Witness is nonzero.
Formal statement
Proof (Lean source)
theorem det_canonicalForwardFullJacobianAtWitness_ne_zero
(m : ℕ) (hm : 1 ≤ m) :
(canonicalForwardFullJacobianAtWitness m hm).det ≠ 0 := by
rw [canonicalForwardFullJacobianAtWitness_eq,
Matrix.det_fromBlocks_zero₂₁]
exact mul_ne_zero
(det_canonicalForwardOrdinaryJacobianAtWitness_ne_zero m hm)
(det_canonicalForwardTopAugmentedJacobianAtWitness_ne_zero m)
theorem card_forwardFullJacobianIndex
Proves the stated mathematical property of card forward Full Jacobian Index.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
Proof (Lean source)
theorem card_forwardFullJacobianIndex (m : ℕ) (hm : 1 ≤ m) :
card (ForwardFullJacobianIndex m) =
commonAxisExpectedDimension m + 1 := by
rw [← card_forwardImageGenerator m hm]
have hlow : card (ForwardLowWeightIndex m) =
card (RetainedCumCoord m) :=
Fintype.card_congr (retainedCumCoordEquivSigma m).symm
simp only [ForwardFullJacobianIndex, ForwardOrdinaryJacobianIndex,
ForwardLowWeightIndex, ForwardHighWeightIndex, ForwardHighWeightNode,
ForwardTopAugmentedIndex, ForwardImageGenerator, Fintype.card_sum,
Fintype.card_prod, Fintype.card_fin, Fintype.card_unit, hlow]
ring
def forwardFullJacobianEquivFin
Defines the Jacobian matrix, row, column, or indexing object called the forward Full Jacobian Equiv Fin.
Definition (Lean source)
noncomputable def forwardFullJacobianEquivFin (m : ℕ) (hm : 1 ≤ m) :
ForwardFullJacobianIndex m ≃ Fin (commonAxisExpectedDimension m + 1) :=
Fintype.equivFinOfCardEq (card_forwardFullJacobianIndex m hm)
def forwardFullJacobianFinRow
Defines the Jacobian matrix, row, column, or indexing object called the forward Full Jacobian Fin Row.
Definition (Lean source)
def forwardFullJacobianFinRow (m : ℕ) (hm : 1 ≤ m) :
Fin (commonAxisExpectedDimension m + 1) →
RetainedCumCoord (2 * m + 2) :=
fun i => forwardFullJacobianRow m hm
((forwardFullJacobianEquivFin m hm).symm i)
def forwardFullJacobianFinColumn
Defines the Jacobian matrix, row, column, or indexing object called the forward Full Jacobian Fin Column.
Definition (Lean source)
def forwardFullJacobianFinColumn (m : ℕ) (hm : 1 ≤ m) :
Fin (commonAxisExpectedDimension m + 1) →
BandParamCoord m (2 * m + 2) :=
fun i => forwardFullJacobianColumn m
((forwardFullJacobianEquivFin m hm).symm i)
theorem forwardFullPolynomialJacobianMinor_ne_zero
Proves that the quantity called the forward Full Polynomial Jacobian Minor is nonzero.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
polynomialJacobianMinor (forwardBandCoordinatePolynomial m (2 * m + 2) (by omega)) (forwardFullJacobianFinRow m hm) (forwardFullJacobianFinColumn m hm)
≠ 0
Proof (Lean source)
theorem forwardFullPolynomialJacobianMinor_ne_zero
(m : ℕ) (hm : 1 ≤ m) :
polynomialJacobianMinor
(forwardBandCoordinatePolynomial m (2 * m + 2) (by omega))
(forwardFullJacobianFinRow m hm)
(forwardFullJacobianFinColumn m hm) ≠ 0 := by
intro hz
have hzEval := congrArg (eval (forwardJacobianWitnessCoord m)) hz
rw [map_zero, polynomialJacobianMinor_eq_det, RingHom.map_det] at hzEval
change ((canonicalForwardFullJacobianAtWitness m hm).submatrix
(forwardFullJacobianEquivFin m hm).symm
(forwardFullJacobianEquivFin m hm).symm).det = 0 at hzEval
rw [Matrix.det_submatrix_equiv_self] at hzEval
exact det_canonicalForwardFullJacobianAtWitness_ne_zero m hm hzEval
theorem restrict_forwardCumulantImageVariety_dimension_expected
The full forward retained-band image has the exact dimension certified by the global confluent/Vandermonde Jacobian minor and the independently proved generator-envelope upper bound.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
HasAffineZariskiDimension (commonAxisExpectedDimension m + 1) (restrictCumBand (2 * m + 2) '' cumulantImageVariety (forwardCumulantMap m (2 * m + 2)))
Proof (Lean source)
theorem restrict_forwardCumulantImageVariety_dimension_expected
(m : ℕ) (hm : 1 ≤ m) :
HasAffineZariskiDimension (commonAxisExpectedDimension m + 1)
(restrictCumBand (2 * m + 2) ''
cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) := by
apply restrict_forwardCumulantImageVariety_dimension_of_jacobian
m (commonAxisExpectedDimension m + 1)
(forwardFullJacobianFinRow m hm)
(forwardFullJacobianFinColumn m hm)
(forwardFullPolynomialJacobianMinor_ne_zero m hm)
simpa only [Nat.cast_add, cast_one] using
forwardBandCoordinateSubalgebra_trdeg_le_expected m hm
def CommonAxisOrdinaryJacobianIndex
Proves the stated mathematical property of Common Axis Ordinary Jacobian Index.
Definition (Lean source)
abbrev CommonAxisOrdinaryJacobianIndex (m : ℕ) :=
ForwardLowWeightIndex m ⊕ ForwardHighWeightIndex m
def CommonAxisFullJacobianIndex
Proves the stated mathematical property of Common Axis Full Jacobian Index.
Definition (Lean source)
abbrev CommonAxisFullJacobianIndex (m : ℕ) :=
CommonAxisOrdinaryJacobianIndex m ⊕ CommonAxisTopAugmentedIndex m
def commonAxisFullJacobianRow
Defines the Jacobian matrix, row, column, or indexing object called the common Axis Full Jacobian Row.
Definition (Lean source)
def commonAxisFullJacobianRow (m : ℕ) (hm : 1 ≤ m) :
CommonAxisFullJacobianIndex m → RetainedCumCoord (2 * m + 2)
| inl a => commonAxisOrdinaryJacobianRow m hm a
| inr a => commonAxisTopAugmentedRow m a
def commonAxisFullJacobianColumn
Defines the Jacobian matrix, row, column, or indexing object called the common Axis Full Jacobian Column.
Definition (Lean source)
def commonAxisFullJacobianColumn (m : ℕ) (hm : 1 ≤ m) :
CommonAxisFullJacobianIndex m →
CommonAxisBandCoord m (2 * m + 2) hm
| inl b => commonAxisOrdinaryJacobianColumn m hm b
| inr b => commonAxisTopAugmentedColumn m hm b
def canonicalCommonAxisFullJacobianAtWitness
Defines the Jacobian matrix, row, column, or indexing object called the canonical Common Axis Full Jacobian At Witness.
Definition (Lean source)
def canonicalCommonAxisFullJacobianAtWitness (m : ℕ) (hm : 1 ≤ m) :
Matrix (CommonAxisFullJacobianIndex m)
(CommonAxisFullJacobianIndex m) ℂ :=
fun a b =>
eval (commonAxisJacobianWitnessCoord m hm)
(pderiv (commonAxisFullJacobianColumn m hm b)
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm
(by omega) (commonAxisFullJacobianRow m hm a)))
theorem canonicalCommonAxisFullJacobianAtWitness_eq
Proves the stated equality or equivalence for canonical Common Axis Full Jacobian At Witness eq.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
= fromBlocks (canonicalCommonAxisOrdinaryJacobianAtWitness m hm) (commonAxisFullUpperRight m hm) 0 (canonicalCommonAxisTopAugmentedJacobianAtWitness m hm)
Proof (Lean source)
theorem canonicalCommonAxisFullJacobianAtWitness_eq
(m : ℕ) (hm : 1 ≤ m) :
canonicalCommonAxisFullJacobianAtWitness m hm =
fromBlocks (canonicalCommonAxisOrdinaryJacobianAtWitness m hm)
(commonAxisFullUpperRight m hm) 0
(canonicalCommonAxisTopAugmentedJacobianAtWitness m hm) := by
ext a b
rcases a with a | a <;> rcases b with b | b
· rfl
· rfl
· rcases b with b | b
· rcases b with ⟨k, j⟩
rcases a with a | u
· simp only [canonicalCommonAxisFullJacobianAtWitness,
commonAxisFullJacobianColumn, commonAxisFullJacobianRow,
commonAxisOrdinaryJacobianColumn, selectedCommonAxisLowWeightColumn,
commonAxisTopAugmentedRow, commonAxisTopRow,
Matrix.fromBlocks_apply₂₁, Pi.zero_apply]
apply eval_selected_commonAxis_weight_otherOrder
· rfl
· change k.val ≠ 2 * m
have h := pinnedExponent_lt (n := m + 1) a
omega
· simp only [canonicalCommonAxisFullJacobianAtWitness,
commonAxisFullJacobianColumn, commonAxisFullJacobianRow,
commonAxisOrdinaryJacobianColumn, selectedCommonAxisLowWeightColumn,
commonAxisTopAugmentedRow,
Matrix.fromBlocks_apply₂₁, Pi.zero_apply]
apply eval_selected_commonAxis_weight_otherOrder
· rfl
· change k.val ≠ 2 * m
omega
· rcases b with ⟨j, k⟩
rcases j with j | u <;> rcases a with a | v
all_goals
simp only [canonicalCommonAxisFullJacobianAtWitness,
commonAxisFullJacobianColumn, commonAxisFullJacobianRow,
commonAxisOrdinaryJacobianColumn, selectedCommonAxisHighWeightColumn,
commonAxisTopAugmentedRow, commonAxisTopRow,
Matrix.fromBlocks_apply₂₁, Pi.zero_apply]
apply eval_selected_commonAxis_weight_otherOrder
· rfl
· change m - 1 + k.val ≠ 2 * m
omega
· rfl
theorem det_canonicalCommonAxisFullJacobianAtWitness_ne_zero
Proves that the quantity called the det canonical Common Axis Full Jacobian At Witness is nonzero.
Formal statement
Proof (Lean source)
theorem det_canonicalCommonAxisFullJacobianAtWitness_ne_zero
(m : ℕ) (hm : 1 ≤ m) :
(canonicalCommonAxisFullJacobianAtWitness m hm).det ≠ 0 := by
rw [canonicalCommonAxisFullJacobianAtWitness_eq,
Matrix.det_fromBlocks_zero₂₁]
exact mul_ne_zero
(det_canonicalCommonAxisOrdinaryJacobianAtWitness_ne_zero m hm)
(det_canonicalCommonAxisTopAugmentedJacobianAtWitness_ne_zero m hm)
theorem card_commonAxisFullJacobianIndex
Proves the stated mathematical property of card common Axis Full Jacobian Index.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
Proof (Lean source)
theorem card_commonAxisFullJacobianIndex (m : ℕ) (hm : 1 ≤ m) :
card (CommonAxisFullJacobianIndex m) =
commonAxisExpectedDimension m := by
have h := card_forwardFullJacobianIndex m hm
simp only [CommonAxisFullJacobianIndex, CommonAxisOrdinaryJacobianIndex,
CommonAxisTopAugmentedIndex, CommonAxisTopIndex,
ForwardFullJacobianIndex, ForwardOrdinaryJacobianIndex,
ForwardTopAugmentedIndex, Fintype.card_sum, Fintype.card_fin,
Fintype.card_unit] at h ⊢
omega
def commonAxisFullJacobianEquivFin
Defines the Jacobian matrix, row, column, or indexing object called the common Axis Full Jacobian Equiv Fin.
Definition (Lean source)
noncomputable def commonAxisFullJacobianEquivFin (m : ℕ) (hm : 1 ≤ m) :
CommonAxisFullJacobianIndex m ≃ Fin (commonAxisExpectedDimension m) :=
Fintype.equivFinOfCardEq (card_commonAxisFullJacobianIndex m hm)
def commonAxisFullJacobianFinRow
Defines the Jacobian matrix, row, column, or indexing object called the common Axis Full Jacobian Fin Row.
Definition (Lean source)
def commonAxisFullJacobianFinRow (m : ℕ) (hm : 1 ≤ m) :
Fin (commonAxisExpectedDimension m) → RetainedCumCoord (2 * m + 2) :=
fun i => commonAxisFullJacobianRow m hm
((commonAxisFullJacobianEquivFin m hm).symm i)
def commonAxisFullJacobianFinColumn
Defines the Jacobian matrix, row, column, or indexing object called the common Axis Full Jacobian Fin Column.
Definition (Lean source)
def commonAxisFullJacobianFinColumn (m : ℕ) (hm : 1 ≤ m) :
Fin (commonAxisExpectedDimension m) →
CommonAxisBandCoord m (2 * m + 2) hm :=
fun i => commonAxisFullJacobianColumn m hm
((commonAxisFullJacobianEquivFin m hm).symm i)
theorem forwardCommonAxisPolynomialJacobianMinor_ne_zero
Proves that the quantity called the forward Common Axis Polynomial Jacobian Minor is nonzero.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
polynomialJacobianMinor (forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega)) (commonAxisFullJacobianFinRow m hm) (commonAxisFullJacobianFinColumn m hm)
≠ 0
Proof (Lean source)
theorem forwardCommonAxisPolynomialJacobianMinor_ne_zero
(m : ℕ) (hm : 1 ≤ m) :
polynomialJacobianMinor
(forwardCommonAxisCoordinatePolynomial m (2 * m + 2) hm (by omega))
(commonAxisFullJacobianFinRow m hm)
(commonAxisFullJacobianFinColumn m hm) ≠ 0 := by
intro hz
have hzEval := congrArg
(eval (commonAxisJacobianWitnessCoord m hm)) hz
rw [map_zero, polynomialJacobianMinor_eq_det, RingHom.map_det] at hzEval
change ((canonicalCommonAxisFullJacobianAtWitness m hm).submatrix
(commonAxisFullJacobianEquivFin m hm).symm
(commonAxisFullJacobianEquivFin m hm).symm).det = 0 at hzEval
rw [Matrix.det_submatrix_equiv_self] at hzEval
exact det_canonicalCommonAxisFullJacobianAtWitness_ne_zero m hm hzEval
theorem restrict_forwardCommonAxisImageClosure_dimension_expected
The common-axis retained-band image has the exact dimension certified by the pinned confluent-Vandermonde minor and the generator-envelope upper bound.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
HasAffineZariskiDimension (commonAxisExpectedDimension m) (restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm)
Proof (Lean source)
theorem restrict_forwardCommonAxisImageClosure_dimension_expected
(m : ℕ) (hm : 1 ≤ m) :
HasAffineZariskiDimension (commonAxisExpectedDimension m)
(restrictCumBand (2 * m + 2) '' forwardCommonAxisImageClosure m hm) := by
apply restrict_forwardCommonAxisImageClosure_dimension_of_jacobian m hm
(commonAxisFullJacobianFinRow m hm)
(commonAxisFullJacobianFinColumn m hm)
(forwardCommonAxisPolynomialJacobianMinor_ne_zero m hm)
exact forwardCommonAxisCoordinateSubalgebra_trdeg_le_expected m hm
Helpers.FiberDimensionDefs 2 declarations
def IsIrreducibleZariskiClosedParamIn Definition aux_IsIrreducibleZariskiClosedParamIn in the paper ↗
A relatively Zariski-closed parameter set is irreducible inside the retained finite-band ambient.
Definition (Lean source)
def IsIrreducibleZariskiClosedParamIn {m : ℕ} (L : ℕ)
(Z : Set (ParamSpace ℂ m)) : Prop :=
zariskiClosureParamIn L Z = Z ∧ Z.Nonempty ∧
∀ Z₁ Z₂ : Set (ParamSpace ℂ m),
zariskiClosureParamIn L Z₁ = Z₁ → zariskiClosureParamIn L Z₂ = Z₂ →
Z = Z₁ ∪ Z₂ → Z = Z₁ ∨ Z = Z₂
Exact relative Krull dimension, measured by strict chains of irreducible closed subsets inside the paper's retained-band parameter ambient.
Definition (Lean source)
def HasRelativeZariskiDimension {m : ℕ} (L d : ℕ)
(Z : Set (ParamSpace ℂ m)) : Prop :=
(∃ chain : Fin (d + 1) → Set (ParamSpace ℂ m),
StrictMono chain ∧
(∀ i, IsIrreducibleZariskiClosedParamIn L (chain i)) ∧
(∀ i, chain i ⊆ Z)) ∧
¬ ∃ chain : Fin (d + 2) → Set (ParamSpace ℂ m),
StrictMono chain ∧
(∀ i, IsIrreducibleZariskiClosedParamIn L (chain i)) ∧
(∀ i, chain i ⊆ Z)
Helpers.FiberSlopeComponents 2 declarations
theorem forward_irreducible_subset_fixedLoading
Proves the stated set-containment or membership property for forward irreducible subset fixed Loading.
Formal statement
hypotheses
m L :
ℕ
θ :
ParamSpace ℂ m
hgen :
θ ∈ genericParameterLocus m L
hrecover :
T :
Set (BandParamCoord m L → ℂ)
hT :
hsub :
T ⊆ encodeBandParam (L := L) '' fiberCorrespondence L (forwardCumulantMap m L) (forwardCumulantMap m L θ)
conclusion
T ⊆ encodeBandParam (L := L) '' forwardFixedLoadingFiber m L θ₀
Proof (Lean source)
theorem forward_irreducible_subset_fixedLoading {m L : ℕ}
(θ : ParamSpace ℂ m) (hgen : θ ∈ genericParameterLocus m L)
(hrecover : ∀ θ' ∈ fiberCorrespondence L (forwardCumulantMap m L)
(forwardCumulantMap m L θ), loadingSlopeMultiset θ' = loadingSlopeMultiset θ)
{T : Set (BandParamCoord m L → ℂ)} (hT : IsIrreducibleAffineClosed T)
(hsub : T ⊆ encodeBandParam (L := L) '' fiberCorrespondence L
(forwardCumulantMap m L) (forwardCumulantMap m L θ)) :
∃ θ₀ ∈ fiberCorrespondence L (forwardCumulantMap m L)
(forwardCumulantMap m L θ),
Injective (fun j : Fin (m + 1) =>
(forwardLoading m θ₀.1 θ₀.2.1 j.castSucc).2) ∧
T ⊆ encodeBandParam (L := L) '' forwardFixedLoadingFiber m L θ₀ := by
obtain ⟨x₀, hx₀⟩ := hT.2.1
obtain ⟨θ₀, hθ₀, rfl⟩ := hsub hx₀
let S := (loadingSlopeMultiset θ).toFinset
have hrangeDirect : ∀ x ∈ T, x (inl ()) ∈ S := by
intro x hx
obtain ⟨θ', hθ', rfl⟩ := hsub hx
exact (slopeCoordinate_mem_target (hrecover θ' hθ')).1
obtain ⟨_, _, hdirect⟩ :=
irreducible_coordinate_constant_of_finite_range hT (inl ()) S hrangeDirect
have hrangeLatent : ∀ i : Fin m, ∀ x ∈ T,
x (inr (inl i)) ∈ S := by
intro i x hx
obtain ⟨θ', hθ', rfl⟩ := hsub hx
exact (slopeCoordinate_mem_target (hrecover θ' hθ')).2 i
choose zi hziS hlatent using fun i =>
irreducible_coordinate_constant_of_finite_range hT
(inr (inl i)) S (hrangeLatent i)
refine ⟨θ₀, hθ₀,
forward_actual_slopes_injective_of_recovery hgen (hrecover θ₀ hθ₀), ?_⟩
intro x hx
obtain ⟨θ', hθ', rfl⟩ := hsub hx
have hγ : θ'.1 = θ₀.1 := by
have h1 := hdirect (encodeBandParam θ') hx
have h0 := hdirect (encodeBandParam θ₀) hx₀
simpa [encodeBandParam] using h1.trans h0.symm
have hρ : θ'.2.1 = θ₀.2.1 := by
funext i
have h1 := hlatent i (encodeBandParam θ') hx
have h0 := hlatent i (encodeBandParam θ₀) hx₀
simpa [encodeBandParam] using h1.trans h0.symm
have hfib₀ : θ' ∈ fiberCorrespondence L (forwardCumulantMap m L)
(forwardCumulantMap m L θ₀) := by
refine ⟨hθ'.1, ?_⟩
intro r a hr hrL ha
exact (hθ'.2 r a hr hrL ha).trans (hθ₀.2 r a hr hrL ha).symm
exact ⟨θ', ⟨hfib₀, hγ, hρ⟩, rfl⟩
theorem reverse_irreducible_subset_fixedLoading
Proves the stated set-containment or membership property for reverse irreducible subset fixed Loading.
Formal statement
hypotheses
m L :
ℕ
η :
ParamSpace ℂ m
hgen :
η ∈ genericParameterLocus m L
hrecover :
T :
Set (BandParamCoord m L → ℂ)
hT :
hsub :
T ⊆ encodeBandParam (L := L) '' fiberCorrespondence L (reverseCumulantMap m L) (reverseCumulantMap m L η)
conclusion
T ⊆ encodeBandParam (L := L) '' reverseFixedLoadingFiber m L η₀
Proof (Lean source)
theorem reverse_irreducible_subset_fixedLoading {m L : ℕ}
(η : ParamSpace ℂ m) (hgen : η ∈ genericParameterLocus m L)
(hrecover : ∀ η' ∈ fiberCorrespondence L (reverseCumulantMap m L)
(reverseCumulantMap m L η), loadingSlopeMultiset η' = loadingSlopeMultiset η)
{T : Set (BandParamCoord m L → ℂ)} (hT : IsIrreducibleAffineClosed T)
(hsub : T ⊆ encodeBandParam (L := L) '' fiberCorrespondence L
(reverseCumulantMap m L) (reverseCumulantMap m L η)) :
∃ η₀ ∈ fiberCorrespondence L (reverseCumulantMap m L)
(reverseCumulantMap m L η),
Injective (fun j : Fin (m + 1) =>
(reverseLoading m η₀.1 η₀.2.1 j.succ).1) ∧
T ⊆ encodeBandParam (L := L) '' reverseFixedLoadingFiber m L η₀ := by
obtain ⟨x₀, hx₀⟩ := hT.2.1
obtain ⟨η₀, hη₀, rfl⟩ := hsub hx₀
let S := (loadingSlopeMultiset η).toFinset
have hrangeDirect : ∀ x ∈ T, x (inl ()) ∈ S := by
intro x hx
obtain ⟨η', hη', rfl⟩ := hsub hx
exact (slopeCoordinate_mem_target (hrecover η' hη')).1
obtain ⟨_, _, hdirect⟩ :=
irreducible_coordinate_constant_of_finite_range hT (inl ()) S hrangeDirect
have hrangeLatent : ∀ i : Fin m, ∀ x ∈ T,
x (inr (inl i)) ∈ S := by
intro i x hx
obtain ⟨η', hη', rfl⟩ := hsub hx
exact (slopeCoordinate_mem_target (hrecover η' hη')).2 i
choose zi hziS hlatent using fun i =>
irreducible_coordinate_constant_of_finite_range hT
(inr (inl i)) S (hrangeLatent i)
refine ⟨η₀, hη₀,
reverse_actual_slopes_injective_of_recovery hgen (hrecover η₀ hη₀), ?_⟩
intro x hx
obtain ⟨η', hη', rfl⟩ := hsub hx
have hδ : η'.1 = η₀.1 := by
have h1 := hdirect (encodeBandParam η') hx
have h0 := hdirect (encodeBandParam η₀) hx₀
simpa [encodeBandParam] using h1.trans h0.symm
have hσ : η'.2.1 = η₀.2.1 := by
funext i
have h1 := hlatent i (encodeBandParam η') hx
have h0 := hlatent i (encodeBandParam η₀) hx₀
simpa [encodeBandParam] using h1.trans h0.symm
have hfib₀ : η' ∈ fiberCorrespondence L (reverseCumulantMap m L)
(reverseCumulantMap m L η₀) := by
refine ⟨hη'.1, ?_⟩
intro r a hr hrL ha
exact (hη'.2 r a hr hrL ha).trans (hη₀.2 r a hr hrL ha).symm
exact ⟨η', ⟨hfib₀, hδ, hσ⟩, rfl⟩
Helpers.FiniteCodimensionTransfer 2 declarations
theorem irreducibleComponent_iff_affineComponent
Irreducible-component maximality is preserved by finite-band restriction.
Formal statement
hypotheses
conclusion
Proof (Lean source)
theorem irreducibleComponent_iff_affineComponent {L : ℕ}
{C Z : Set (CumVec ℂ)} (hC : C ⊆ bandSupportedCumulants L)
(hZ : Z ⊆ bandSupportedCumulants L) :
IsIrreducibleComponent C Z ↔
IsIrreducibleAffineComponent
(restrictCumBand L '' C) (restrictCumBand L '' Z) := by
constructor
· intro h
refine ⟨(irreducibleZariskiClosed_iff_affine hC).mp h.1,
Set.image_mono h.2.1, ?_⟩
intro D hD hCD hDZ
let D' := extendCumBand L '' D
have hD'band : D' ⊆ bandSupportedCumulants L := by
rintro _ ⟨x, _, rfl⟩
exact extendCumBand_mem_band L x
have hD'irr : IsIrreducibleZariskiClosed D' := by
apply (irreducibleZariskiClosed_iff_affine hD'band).mpr
simpa [D', restrict_image_extend] using hD
have hCD' : C ⊆ D' := by
rw [← (image_restrictCumBand_subset_iff hC hD'band)]
simpa [D', restrict_image_extend] using hCD
have hD'Z : D' ⊆ Z := by
rw [← (image_restrictCumBand_subset_iff hD'band hZ)]
simpa [D', restrict_image_extend] using hDZ
have heq := h.2.2 D' hD'irr hCD' hD'Z
have := congrArg (fun S => restrictCumBand L '' S) heq
simpa [D', restrict_image_extend] using this
· intro h
refine ⟨(irreducibleZariskiClosed_iff_affine hC).mpr h.1,
(image_restrictCumBand_subset_iff hC hZ).mp h.2.1, ?_⟩
intro D hD hCD hDZ
have hDband : D ⊆ bandSupportedCumulants L := hDZ.trans hZ
have hDi := (irreducibleZariskiClosed_iff_affine hDband).mp hD
have himage := h.2.2 (restrictCumBand L '' D) hDi
((image_restrictCumBand_subset_iff hC hDband).mpr hCD)
((image_restrictCumBand_subset_iff hDband hZ).mpr hDZ)
exact image_restrictCumBand_inj hDband hC himage
theorem hasCodimensionIn_iff_affineCodimensionIn
Exact custom codimension in a band-supported CumVec set is equivalent to the same endpoint-fixed irreducible-chain statement in the finite retained affine space.
Formal statement
hypotheses
conclusion
HasCodimensionIn d Z X
Proof (Lean source)
theorem hasCodimensionIn_iff_affineCodimensionIn {L d : ℕ}
{Z X : Set (CumVec ℂ)} (hZ : Z ⊆ bandSupportedCumulants L)
(hX : X ⊆ bandSupportedCumulants L) :
HasCodimensionIn d Z X ↔
HasAffineCodimensionIn d
(restrictCumBand L '' Z) (restrictCumBand L '' X) := by
let f := restrictCumBand L
let g := extendCumBand L
have hf := restrictCumBand_injective_on_band L
constructor
· rintro ⟨hall, C, hC, hno⟩
constructor
· intro D hD
let D' := g '' D
have hD'band : D' ⊆ bandSupportedCumulants L := by
rintro _ ⟨x, _, rfl⟩
exact extendCumBand_mem_band L x
have hD'comp : IsIrreducibleComponent D' Z := by
apply (irreducibleComponent_iff_affineComponent hD'band hZ).mpr
simpa [D', f, g, restrict_image_extend] using hD
obtain ⟨chain, hmono, hirr, hzero, hlast⟩ := hall D' hD'comp
refine ⟨fun i => f '' chain i,
image_strictMono_on f hf hmono
(fun i => (hmono.monotone (Fin.le_last i)).trans
(hlast.le.trans hX)), ?_, ?_, ?_⟩
· intro i
have hiband : chain i ⊆ bandSupportedCumulants L := by
exact (hmono.monotone (Fin.le_last i)) |>.trans (hlast.le.trans hX)
exact (irreducibleZariskiClosed_iff_affine hiband).mp (hirr i)
· change f '' chain 0 = D
rw [hzero]
simpa [D', f, g, restrict_image_extend]
· change f '' chain (last d) = f '' X
rw [hlast]
· refine ⟨f '' C, ?_, ?_⟩
· exact (irreducibleComponent_iff_affineComponent
(hC.2.1.trans hZ) hZ).mp hC
· rintro ⟨chain, hmono, hirr, hzero, hlast⟩
apply hno
refine ⟨fun i => g '' chain i, image_strictMono_extend hmono, ?_, ?_, ?_⟩
· intro i
have hiband : g '' chain i ⊆ bandSupportedCumulants L := by
rintro _ ⟨x, _, rfl⟩
exact extendCumBand_mem_band L x
apply (irreducibleZariskiClosed_iff_affine hiband).mpr
simpa [g, restrict_image_extend] using hirr i
· change g '' chain 0 = C
rw [hzero]
exact extend_image_restrict (hC.2.1.trans hZ)
· change g '' chain (last (d + 1)) = X
rw [hlast]
exact extend_image_restrict hX
· rintro ⟨hall, C, hC, hno⟩
constructor
· intro D hD
have hDband := hD.2.1.trans hZ
have hDfcomp := (irreducibleComponent_iff_affineComponent hDband hZ).mp hD
obtain ⟨chain, hmono, hirr, hzero, hlast⟩ := hall (f '' D) hDfcomp
refine ⟨fun i => g '' chain i, image_strictMono_extend hmono, ?_, ?_, ?_⟩
· intro i
have hiband : g '' chain i ⊆ bandSupportedCumulants L := by
rintro _ ⟨x, _, rfl⟩
exact extendCumBand_mem_band L x
apply (irreducibleZariskiClosed_iff_affine hiband).mpr
simpa [g, restrict_image_extend] using hirr i
· change g '' chain 0 = D
rw [hzero]
exact extend_image_restrict hDband
· change g '' chain (last d) = X
rw [hlast]
exact extend_image_restrict hX
· let D := g '' C
have hDband : D ⊆ bandSupportedCumulants L := by
rintro _ ⟨x, _, rfl⟩
exact extendCumBand_mem_band L x
have hDcomp : IsIrreducibleComponent D Z := by
apply (irreducibleComponent_iff_affineComponent hDband hZ).mpr
simpa [D, f, g, restrict_image_extend] using hC
refine ⟨D, hDcomp, ?_⟩
rintro ⟨chain, hmono, hirr, hzero, hlast⟩
apply hno
refine ⟨fun i => f '' chain i,
image_strictMono_on f hf hmono
(fun i => (hmono.monotone (Fin.le_last i)).trans
(hlast.le.trans hX)), ?_, ?_, ?_⟩
· intro i
have hiband := (hmono.monotone (Fin.le_last i)).trans
(hlast.le.trans hX)
exact (irreducibleZariskiClosed_iff_affine hiband).mp (hirr i)
· change f '' chain 0 = C
rw [hzero]
simpa [D, f, g, restrict_image_extend]
· change f '' chain (last (d + 1)) = f '' X
rw [hlast]
Helpers.FiniteCumBand 21 declarations
def RetainedCumCoord
Finite coordinates (r,a) with 2 ≤ r ≤ L and a ≤ r.
Definition (Lean source)
def retainedCumCoordEquivSigma
Retained coordinates are a triangular family: at order k + 2 there are exactly k + 3 coordinate positions.
Definition (Lean source)
def retainedCumCoordEquivSigma (L : ℕ) :
RetainedCumCoord L ≃ Σ k : Fin (L - 1), Fin (k.1 + 3) where
toFun p := ⟨⟨p.val.1.val - 2, by
have hrL := p.val.1.isLt
have hr2 := p.property.1
omega⟩, ⟨p.val.2.val, by
have ha := p.property.2
have hr2 := p.property.1
change p.val.2.val < (p.val.1.val - 2) + 3
omega⟩⟩
invFun p := ⟨(⟨p.1.val + 2, by
have hk : p.1.val < L - 1 := p.1.isLt
change p.1.val + 2 < L + 1
omega⟩, ⟨p.2.val, by
have hk : p.1.val < L - 1 := p.1.isLt
have ha : p.2.val < p.1.val + 3 := p.2.isLt
change p.2.val < L + 1
omega⟩), by
show 2 ≤ p.1.val + 2
omega, by
have ha : p.2.val < p.1.val + 3 := p.2.isLt
change p.2.val ≤ p.1.val + 2
omega⟩
left_inv p := by
apply Subtype.ext
apply Prod.ext <;> apply Fin.ext <;> simp <;> omega
right_inv p := by
rcases p with ⟨⟨k, hk⟩, ⟨a, ha⟩⟩
simp
theorem card_retainedCumCoord
The finite retained band has the observable dimension q_L.
Formal statement
Proof (Lean source)
theorem card_retainedCumCoord (L : ℕ) :
card (RetainedCumCoord L) = qDim L := by
rw [Fintype.card_congr (retainedCumCoordEquivSigma L), Fintype.card_sigma]
simp only [Fintype.card_fin]
rw [Finset.sum_fin_eq_sum_range]
have hsum :
(∑ x ∈ range (L - 1), if h : x < L - 1 then x + 3 else 0) =
∑ x ∈ range (L - 1), (x + 3) := by
apply Finset.sum_congr rfl
intro x hx
rw [dif_pos (Finset.mem_range.mp hx)]
rw [hsum]
change (range (L - 1)).sum (fun x => x + 3) = qDim L
rw [Finset.sum_add_distrib, Finset.sum_range_id]
simp only [Finset.sum_const, Finset.card_range, nsmul_eq_mul]
unfold qDim
change (L - 1) * (L - 1 - 1) / 2 + (L - 1) * 3 =
L * (L + 3) / 2 - 2
by_cases hL : L < 2
· interval_cases L <;> decide
· obtain ⟨k, rfl⟩ : ∃ k, L = k + 2 := by
exact ⟨L - 2, by omega⟩
have hpoly : (k + 2) * (k + 2 + 3) =
k * (k + 1) + (6 * (k + 1) + 4) := by ring
have h1 : k + 2 - 1 = k + 1 := by omega
have h2 : k + 1 - 1 = k := by omega
rw [h1, h2, Nat.mul_comm (k + 1) k, hpoly,
Nat.add_div_of_dvd_right (Nat.two_dvd_mul_add_one k)]
omega
def restrictCumBand
Restriction of an infinite cumulant vector to its retained coordinates.
Definition (Lean source)
def extendCumBand
Extend finite retained coordinates by zero.
Definition (Lean source)
def extendCumBand (L : ℕ) (x : RetainedCumCoord L → ℂ) : CumVec ℂ :=
fun r a => if h : 2 ≤ r ∧ r ≤ L ∧ a ≤ r then
x ⟨(⟨r, by omega⟩, ⟨a, by omega⟩), h.1, h.2.2⟩ else 0
theorem extendCumBand_mem_band
Padding a finite list of retained cumulant coordinates with zeros produces a full cumulant vector that is supported on the band: every cumulant of order below two or above the truncation order is zero.
Formal statement
Proof (Lean source)
lemma extendCumBand_mem_band (L : ℕ) (x : RetainedCumCoord L → ℂ) :
extendCumBand L x ∈ bandSupportedCumulants L := by
intro r a h
simp [extendCumBand, h]
theorem restrict_extendCumBand
Reading the retained coordinates back off a zero-padded cumulant vector returns the original finite list of coordinates: padding then restricting changes nothing.
Formal statement
Proof (Lean source)
@[simp] lemma restrict_extendCumBand (L : ℕ) (x : RetainedCumCoord L → ℂ) :
restrictCumBand L (extendCumBand L x) = x := by
funext p
have hrL : p.1.1 ≤ L := by omega
simp [restrictCumBand, extendCumBand, p.2.1, hrL, p.2.2]
theorem extend_restrictCumBand
A cumulant vector that already vanishes outside the band loses nothing when it is cut down to its retained coordinates and padded back with zeros: the two operations recover the original vector exactly.
Formal statement
hypotheses
conclusion
extendCumBand L (restrictCumBand L t) = t
Proof (Lean source)
lemma extend_restrictCumBand {L : ℕ} {t : CumVec ℂ}
(ht : t ∈ bandSupportedCumulants L) :
extendCumBand L (restrictCumBand L t) = t := by
funext r a
by_cases h : 2 ≤ r ∧ r ≤ L ∧ a ≤ r
· simp [extendCumBand, restrictCumBand, h]
· rw [extendCumBand, dif_neg h, ht r a h]
def restrictCumPolynomial
Substitute zero for every off-band observable variable.
Definition (Lean source)
def restrictCumPolynomial (L : ℕ) :
MvPolynomial (ℕ × ℕ) ℂ →ₐ[ℂ] MvPolynomial (RetainedCumCoord L) ℂ :=
bind₁ fun p =>
match retainedIndex? L p with
| some q => X q
| none => 0
def extendCumPolynomial
Regard a finite-band polynomial as a polynomial in all cumulant variables.
Definition (Lean source)
def extendCumPolynomial (L : ℕ) :
MvPolynomial (RetainedCumCoord L) ℂ →ₐ[ℂ] MvPolynomial (ℕ × ℕ) ℂ :=
rename fun p => (p.1.1, p.1.2.1)
theorem eval_restrictCumPolynomial_of_band
Restricting a polynomial in all cumulant variables to the band does not change the value it takes at any cumulant vector supported on the band: substituting zero for the off-band variables and then evaluating on the retained coordinates gives the original value.
Formal statement
hypotheses
conclusion
= eval (fun p => t p.1 p.2) P
Proof (Lean source)
lemma eval_restrictCumPolynomial_of_band {L : ℕ} {t : CumVec ℂ}
(ht : t ∈ bandSupportedCumulants L) (P : MvPolynomial (ℕ × ℕ) ℂ) :
eval (restrictCumBand L t) (restrictCumPolynomial L P) =
eval (fun p => t p.1 p.2) P := by
change (MvPolynomial.eval₂Hom (id ℂ) (restrictCumBand L t))
(restrictCumPolynomial L P) =
(MvPolynomial.eval₂Hom (id ℂ) (fun p => t p.1 p.2)) P
rw [restrictCumPolynomial, MvPolynomial.eval₂Hom_bind₁]
apply DFunLike.congr_fun _ P
apply MvPolynomial.ringHom_ext
· intro c
simp
· intro p
by_cases h : 2 ≤ p.1 ∧ p.1 ≤ L ∧ p.2 ≤ p.1
· simp [retainedIndex?, h, restrictCumBand]
· simp [retainedIndex?, h, ht p.1 p.2 h]
theorem eval_extendCumPolynomial
Gives the stated evaluation formula for eval extend Cum Polynomial.
Formal statement
hypotheses
conclusion
= eval x P
Proof (Lean source)
@[simp] lemma eval_extendCumPolynomial (L : ℕ) (x : RetainedCumCoord L → ℂ)
(P : MvPolynomial (RetainedCumCoord L) ℂ) :
eval (fun p => extendCumBand L x p.1 p.2)
(extendCumPolynomial L P) = eval x P := by
rw [extendCumPolynomial, MvPolynomial.eval_rename]
apply DFunLike.congr_fun _ P
apply MvPolynomial.ringHom_ext
· intro c
simp
· intro p
have hrL : p.1.1 ≤ L := by omega
simp [extendCumBand, p.2.1, hrL, p.2.2]
theorem restrict_extendCumPolynomial
Proves the stated mathematical property of restrict extend Cum Polynomial.
Formal statement
hypotheses
L :
ℕ
P :
MvPolynomial (RetainedCumCoord L) ℂ
conclusion
restrictCumPolynomial L (extendCumPolynomial L P) = P
Proof (Lean source)
lemma restrict_extendCumPolynomial (L : ℕ)
(P : MvPolynomial (RetainedCumCoord L) ℂ) :
restrictCumPolynomial L (extendCumPolynomial L P) = P := by
apply MvPolynomial.funext
intro x
calc
eval x
(restrictCumPolynomial L (extendCumPolynomial L P)) =
eval (restrictCumBand L (extendCumBand L x))
(restrictCumPolynomial L (extendCumPolynomial L P)) := by
rw [restrict_extendCumBand]
_ = eval (fun p => extendCumBand L x p.1 p.2)
(extendCumPolynomial L P) :=
eval_restrictCumPolynomial_of_band (extendCumBand_mem_band L x) _
_ = eval x P := eval_extendCumPolynomial L x P
theorem mem_zariskiClosure_iff_mem_affineZariskiClosure
On band-supported sets, ambient closure is exactly finite affine closure.
Formal statement
hypotheses
conclusion
Proof (Lean source)
theorem mem_zariskiClosure_iff_mem_affineZariskiClosure {L : ℕ}
{A : Set (CumVec ℂ)} (hA : A ⊆ bandSupportedCumulants L)
{t : CumVec ℂ} (ht : t ∈ bandSupportedCumulants L) :
t ∈ zariskiClosure A ↔
restrictCumBand L t ∈
affineZariskiClosure (restrictCumBand L '' A) := by
constructor
· intro hclose P hP
change eval (restrictCumBand L t) P = 0
rw [← eval_extendCumPolynomial L (restrictCumBand L t) P]
rw [extend_restrictCumBand ht]
apply hclose (extendCumPolynomial L P)
intro s hs
calc
eval (fun p => s p.1 p.2) (extendCumPolynomial L P) =
eval
(fun p => extendCumBand L (restrictCumBand L s) p.1 p.2)
(extendCumPolynomial L P) := by rw [extend_restrictCumBand (hA hs)]
_ = eval (restrictCumBand L s) P :=
eval_extendCumPolynomial L (restrictCumBand L s) P
_ = 0 := by
simpa [MvPolynomial.aeval_def] using
hP (restrictCumBand L s) ⟨s, hs, rfl⟩
· intro hclose P hP
rw [← eval_restrictCumPolynomial_of_band ht P]
apply hclose (restrictCumPolynomial L P)
rintro _ ⟨s, hs, rfl⟩
simpa [MvPolynomial.aeval_def, eval_restrictCumPolynomial_of_band (hA hs)] using hP s hs
theorem zariskiClosure_subset_band
Proves the stated set-containment or membership property for zariski Closure subset band.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma zariskiClosure_subset_band {L : ℕ} {A : Set (CumVec ℂ)}
(hA : A ⊆ bandSupportedCumulants L) :
zariskiClosure A ⊆ bandSupportedCumulants L := by
intro t ht r a hout
let P : MvPolynomial (ℕ × ℕ) ℂ := X (r, a)
have hvan : ∀ s ∈ A, eval (fun p => s p.1 p.2) P = 0 := by
intro s hs
simpa [P] using hA hs r a hout
simpa [P] using ht P hvan
theorem restrictCumBand_injective_on_band
Proves that the map or coordinate assignment called the restrict Cum Band on band is injective.
Formal statement
Proof (Lean source)
lemma restrictCumBand_injective_on_band (L : ℕ) :
InjOn (restrictCumBand L) (bandSupportedCumulants L) := by
intro s hs t ht heq
rw [← extend_restrictCumBand hs, ← extend_restrictCumBand ht, heq]
theorem image_restrictCumBand_subset_iff
Proves the stated set-containment or membership property for image restrict Cum Band subset iff.
Formal statement
hypotheses
conclusion
restrictCumBand L '' A ⊆ restrictCumBand L '' B ↔ A ⊆ B
Proof (Lean source)
lemma image_restrictCumBand_subset_iff {L : ℕ}
{A B : Set (CumVec ℂ)} (hA : A ⊆ bandSupportedCumulants L)
(hB : B ⊆ bandSupportedCumulants L) :
restrictCumBand L '' A ⊆ restrictCumBand L '' B ↔ A ⊆ B := by
constructor
· intro h s hs
obtain ⟨t, ht, heq⟩ := h ⟨s, hs, rfl⟩
have := restrictCumBand_injective_on_band L (hA hs) (hB ht) heq.symm
simpa [this] using ht
· exact Set.image_mono
theorem image_restrictCumBand_inj
Proves the stated mathematical property of image restrict Cum Band inj.
Formal statement
hypotheses
L :
ℕ
hA :
A ⊆ bandSupportedCumulants L
hB :
B ⊆ bandSupportedCumulants L
h :
restrictCumBand L '' A = restrictCumBand L '' B
conclusion
A = B
Proof (Lean source)
lemma image_restrictCumBand_inj {L : ℕ}
{A B : Set (CumVec ℂ)} (hA : A ⊆ bandSupportedCumulants L)
(hB : B ⊆ bandSupportedCumulants L)
(h : restrictCumBand L '' A = restrictCumBand L '' B) : A = B := by
apply Set.Subset.antisymm
· exact (image_restrictCumBand_subset_iff hA hB).mp h.le
· exact (image_restrictCumBand_subset_iff hB hA).mp h.ge
theorem image_restrictCumBand_union
Proves the stated mathematical property of image restrict Cum Band union.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma image_restrictCumBand_union (L : ℕ) (A B : Set (CumVec ℂ)) :
restrictCumBand L '' (A ∪ B) =
restrictCumBand L '' A ∪ restrictCumBand L '' B := by
exact Set.image_union _ _ _
theorem closed_iff_affineClosed
Closed band-supported sets correspond exactly to closed finite affine sets.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma closed_iff_affineClosed {L : ℕ} {A : Set (CumVec ℂ)}
(hA : A ⊆ bandSupportedCumulants L) :
zariskiClosure A = A ↔
affineZariskiClosure (restrictCumBand L '' A) =
restrictCumBand L '' A := by
constructor
· intro hclosed
apply Set.Subset.antisymm
· intro x hx
have ht : extendCumBand L x ∈ zariskiClosure A :=
(mem_zariskiClosure_iff_mem_affineZariskiClosure hA
(extendCumBand_mem_band L x)).mpr (by simpa using hx)
exact ⟨extendCumBand L x, hclosed ▸ ht, restrict_extendCumBand L x⟩
· exact affineZariskiClosure_extensive _
· intro hclosed
apply Set.Subset.antisymm
· intro t ht
have htband := zariskiClosure_subset_band hA ht
have hfin : restrictCumBand L t ∈
affineZariskiClosure (restrictCumBand L '' A) :=
(mem_zariskiClosure_iff_mem_affineZariskiClosure hA htband).mp ht
rw [hclosed] at hfin
obtain ⟨s, hs, heq⟩ := hfin
have hts := restrictCumBand_injective_on_band L htband (hA hs) heq.symm
simpa [hts] using hs
· exact subset_zariskiClosure _
theorem irreducibleZariskiClosed_iff_affine
Irreducible closed band-supported sets correspond to irreducible closed sets in the finite retained affine space.
Formal statement
hypotheses
conclusion
Proof (Lean source)
theorem irreducibleZariskiClosed_iff_affine {L : ℕ} {A : Set (CumVec ℂ)}
(hA : A ⊆ bandSupportedCumulants L) :
IsIrreducibleZariskiClosed A ↔
IsIrreducibleAffineClosed (restrictCumBand L '' A) := by
constructor
· intro h
refine ⟨(closed_iff_affineClosed hA).mp h.1, h.2.1.image _, ?_⟩
intro U V hU hV huv
let U' := extendCumBand L '' U
let V' := extendCumBand L '' V
have hUband : U' ⊆ bandSupportedCumulants L := fun _ hx => by
obtain ⟨x, _, rfl⟩ := hx; exact extendCumBand_mem_band L x
have hVband : V' ⊆ bandSupportedCumulants L := fun _ hx => by
obtain ⟨x, _, rfl⟩ := hx; exact extendCumBand_mem_band L x
have hUclosed : zariskiClosure U' = U' := by
apply (closed_iff_affineClosed hUband).mpr
simpa [U', Set.image_image] using hU
have hVclosed : zariskiClosure V' = V' := by
apply (closed_iff_affineClosed hVband).mpr
simpa [V', Set.image_image] using hV
have hAeq : A = U' ∪ V' := by
apply image_restrictCumBand_inj hA (Set.union_subset hUband hVband)
simpa [U', V', image_restrictCumBand_union, Set.image_image] using huv
rcases h.2.2 U' V' hUclosed hVclosed hAeq with hAU | hAV
· left
simpa [U', Set.image_image] using congrArg (fun S => restrictCumBand L '' S) hAU
· right
simpa [V', Set.image_image] using congrArg (fun S => restrictCumBand L '' S) hAV
· intro h
refine ⟨(closed_iff_affineClosed hA).mpr h.1, ?_, ?_⟩
· obtain ⟨x, hx⟩ := h.2.1
obtain ⟨t, ht, _⟩ := hx
exact ⟨t, ht⟩
· intro U V hU hV huv
have hUsub : U ⊆ bandSupportedCumulants L := by
intro u hu
exact hA (huv.symm ▸ inl hu)
have hVsub : V ⊆ bandSupportedCumulants L := by
intro v hv
exact hA (huv.symm ▸ inr hv)
have hi := h.2.2 (restrictCumBand L '' U) (restrictCumBand L '' V)
((closed_iff_affineClosed hUsub).mp hU)
((closed_iff_affineClosed hVsub).mp hV)
(by simpa [image_restrictCumBand_union] using
congrArg (fun S => restrictCumBand L '' S) huv)
rcases hi with hi | hi
· exact inl (image_restrictCumBand_inj hA hUsub hi)
· exact inr (image_restrictCumBand_inj hA hVsub hi)
Helpers.FixedLoadingFiberDimension 8 declarations
def forwardFixedLoadingFiber
The part of a forward fiber with the ordered loading coordinates fixed.
Definition (Lean source)
def forwardFixedLoadingFiber (m L : ℕ) (θ : ParamSpace ℂ m) :
Set (ParamSpace ℂ m) :=
{ θ' | θ' ∈ fiberCorrespondence L (forwardCumulantMap m L)
(forwardCumulantMap m L θ) ∧ θ'.1 = θ.1 ∧ θ'.2.1 = θ.2.1 }
def reverseFixedLoadingFiber
The part of a reverse fiber with the ordered loading coordinates fixed.
Definition (Lean source)
def reverseFixedLoadingFiber (m L : ℕ) (η : ParamSpace ℂ m) :
Set (ParamSpace ℂ m) :=
{ η' | η' ∈ fiberCorrespondence L (reverseCumulantMap m L)
(reverseCumulantMap m L η) ∧ η'.1 = η.1 ∧ η'.2.1 = η.2.1 }
theorem forwardFixedLoadingFiber_subset_band
Every parameter point lying in a forward fiber with the loading coordinates held fixed is band-supported, meaning its source weights vanish at every cumulant order below two or above the truncation order.
Formal statement
hypotheses
m L :
ℕ
ParamSpace ℂ m
conclusion
forwardFixedLoadingFiber m L θ ⊆ bandSupportedParams m L
Proof (Lean source)
lemma forwardFixedLoadingFiber_subset_band {m L : ℕ} {θ : ParamSpace ℂ m} :
forwardFixedLoadingFiber m L θ ⊆ bandSupportedParams m L :=
fun _ h => h.1.1
theorem reverseFixedLoadingFiber_subset_band
Every parameter point lying in a reverse fiber with the loading coordinates held fixed is band-supported, meaning its source weights vanish at every cumulant order below two or above the truncation order.
Formal statement
hypotheses
m L :
ℕ
ParamSpace ℂ m
conclusion
reverseFixedLoadingFiber m L η ⊆ bandSupportedParams m L
Proof (Lean source)
lemma reverseFixedLoadingFiber_subset_band {m L : ℕ} {η : ParamSpace ℂ m} :
reverseFixedLoadingFiber m L η ⊆ bandSupportedParams m L :=
fun _ h => h.1.1
theorem forward_fixedLoadingFiber_dimension_of_injective
Proves that the map or coordinate assignment called the forward fixed Loading Fiber dimension of is injective.
Formal statement
hypotheses
conclusion
HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2) (forwardFixedLoadingFiber m (2 * m + 2) θ)
Proof (Lean source)
theorem forward_fixedLoadingFiber_dimension_of_injective (m : ℕ)
(θ : ParamSpace ℂ m) (hband : θ ∈ bandSupportedParams m (2 * m + 2))
(hs : Injective (fun j : Fin (m + 1) =>
(forwardLoading m θ.1 θ.2.1 j.castSucc).2)) (hm : 2 ≤ m) :
HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2)
(forwardFixedLoadingFiber m (2 * m + 2) θ) := by
apply (relativeDimension_iff_bandDimension (by omega)
forwardFixedLoadingFiber_subset_band).2
rw [encode_forwardFixedLoadingFiber m (2 * m + 2) (by omega) θ hband]
exact affineSubspace_hasAffineZariskiDimension _ _ _
(forward_loadingBandWeightKernel_finrank_of_injective m θ hs hm)
theorem reverse_fixedLoadingFiber_dimension_of_injective
Proves that the map or coordinate assignment called the reverse fixed Loading Fiber dimension of is injective.
Formal statement
hypotheses
conclusion
HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2) (reverseFixedLoadingFiber m (2 * m + 2) η)
Proof (Lean source)
theorem reverse_fixedLoadingFiber_dimension_of_injective (m : ℕ)
(η : ParamSpace ℂ m) (hband : η ∈ bandSupportedParams m (2 * m + 2))
(hs : Injective (fun j : Fin (m + 1) =>
(reverseLoading m η.1 η.2.1 j.succ).1)) (hm : 2 ≤ m) :
HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2)
(reverseFixedLoadingFiber m (2 * m + 2) η) := by
apply (relativeDimension_iff_bandDimension (by omega)
reverseFixedLoadingFiber_subset_band).2
rw [encode_reverseFixedLoadingFiber m (2 * m + 2) (by omega) η hband]
exact affineSubspace_hasAffineZariskiDimension _ _ _
(reverse_loadingBandWeightKernel_finrank_of_injective m η hs hm)
theorem forward_fixedLoadingFiber_dimension
Establishes the stated dimension formula for forward fixed Loading Fiber.
Formal statement
hypotheses
conclusion
HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2) (forwardFixedLoadingFiber m (2 * m + 2) θ)
Proof (Lean source)
theorem forward_fixedLoadingFiber_dimension (m : ℕ) (θ : ParamSpace ℂ m)
(hgen : θ ∈ genericParameterLocus m (2 * m + 2)) (hm : 2 ≤ m) :
HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2)
(forwardFixedLoadingFiber m (2 * m + 2) θ) :=
forward_fixedLoadingFiber_dimension_of_injective m θ hgen.1
(forward_slopes_injective_of_generic hgen) hm
theorem reverse_fixedLoadingFiber_dimension
Establishes the stated dimension formula for reverse fixed Loading Fiber.
Formal statement
hypotheses
conclusion
HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2) (reverseFixedLoadingFiber m (2 * m + 2) η)
Proof (Lean source)
theorem reverse_fixedLoadingFiber_dimension (m : ℕ) (η : ParamSpace ℂ m)
(hgen : η ∈ genericParameterLocus m (2 * m + 2)) (hm : 2 ≤ m) :
HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2)
(reverseFixedLoadingFiber m (2 * m + 2) η) :=
reverse_fixedLoadingFiber_dimension_of_injective m η hgen.1
(reverse_slopes_injective_of_generic hgen) hm
Helpers.FullFiberSlopeRecovery 3 declarations
theorem forward_slopes_determined_by_kernel_identity
The displayed forward common-kernel identity determines the finite-slope multiset of every same-arrow representation, including nongeneric ones.
Formal statement
hypotheses
m :
ℕ
θ :
ParamSpace ℂ m
hkernel :
∀ q : MvPolynomial (Fin 2) ℂ
if
q.IsHomogeneous (m + 2)
then
((∀ k, k ≤ m → diffApply q (dividedPowerBlock (forwardCumulantMap m (2 * m + 2) θ) (m + 2 + k)) = 0) ↔ ∃ c : ℂ, q = c • supportAnnihilator (forwardLoading m θ.1 θ.2.1))
θ' :
ParamSpace ℂ m
heq :
forwardCumulantMap m (2 * m + 2) θ' = forwardCumulantMap m (2 * m + 2) θ
conclusion
Proof (Lean source)
theorem forward_slopes_determined_by_kernel_identity (m : ℕ) (θ : ParamSpace ℂ m)
(hkernel : ∀ q : MvPolynomial (Fin 2) ℂ, q.IsHomogeneous (m + 2) →
((∀ k, k ≤ m → diffApply q
(dividedPowerBlock (forwardCumulantMap m (2 * m + 2) θ) (m + 2 + k)) = 0) ↔
∃ c : ℂ, q = c • supportAnnihilator (forwardLoading m θ.1 θ.2.1)))
(θ' : ParamSpace ℂ m)
(heq : forwardCumulantMap m (2 * m + 2) θ' =
forwardCumulantMap m (2 * m + 2) θ) :
loadingSlopeMultiset θ' = loadingSlopeMultiset θ := by
let Q' := supportAnnihilator (forwardLoading m θ'.1 θ'.2.1)
let Q := supportAnnihilator (forwardLoading m θ.1 θ.2.1)
have hhom : Q'.IsHomogeneous (m + 2) := supportAnnihilator_isHomogeneous _
have hcon : ∀ k, k ≤ m → diffApply Q'
(dividedPowerBlock (forwardCumulantMap m (2 * m + 2) θ) (m + 2 + k)) = 0 := by
have hown := forward_supportAnnihilator_in_contraction_kernel m θ' Q' hhom
⟨1, by simp [Q']⟩
rw [heq] at hown
exact hown
obtain ⟨c, hcQ⟩ := (hkernel Q' hhom).mp hcon
have hc : c ≠ 0 := by
intro hc0
have hQzero : Q' = 0 := by simpa [hc0] using hcQ
exact forward_support_ne_zero' m θ'.1 θ'.2.1 (by simpa [Q'] using hQzero)
have hdehom : fullFiberDehomX Q' = Polynomial.C c * fullFiberDehomX Q := by
have hcQ' : Q' = c • Q := by simpa [Q] using hcQ
rw [hcQ']
simp [MvPolynomial.smul_eq_C_mul, fullFiberDehomX]
have hroots : (fullFiberDehomX Q').roots = (fullFiberDehomX Q).roots := by
rw [hdehom, Polynomial.roots_C_mul _ hc]
simpa [loadingSlopeMultiset, Q', Q, roots_fullFiberDehomX_forward] using hroots
theorem reverse_slopes_determined_by_kernel_identity
Reverse-arrow mirror of forward_slopes_determined_by_kernel_identity.
Formal statement
hypotheses
m :
ℕ
η :
ParamSpace ℂ m
hkernel :
∀ q : MvPolynomial (Fin 2) ℂ
if
q.IsHomogeneous (m + 2)
then
((∀ k, k ≤ m → diffApply q (dividedPowerBlock (reverseCumulantMap m (2 * m + 2) η) (m + 2 + k)) = 0) ↔ ∃ c : ℂ, q = c • supportAnnihilator (reverseLoading m η.1 η.2.1))
η' :
ParamSpace ℂ m
heq :
reverseCumulantMap m (2 * m + 2) η' = reverseCumulantMap m (2 * m + 2) η
conclusion
Proof (Lean source)
theorem reverse_slopes_determined_by_kernel_identity (m : ℕ) (η : ParamSpace ℂ m)
(hkernel : ∀ q : MvPolynomial (Fin 2) ℂ, q.IsHomogeneous (m + 2) →
((∀ k, k ≤ m → diffApply q
(dividedPowerBlock (reverseCumulantMap m (2 * m + 2) η) (m + 2 + k)) = 0) ↔
∃ c : ℂ, q = c • supportAnnihilator (reverseLoading m η.1 η.2.1)))
(η' : ParamSpace ℂ m)
(heq : reverseCumulantMap m (2 * m + 2) η' =
reverseCumulantMap m (2 * m + 2) η) :
loadingSlopeMultiset η' = loadingSlopeMultiset η := by
let Q' := supportAnnihilator (reverseLoading m η'.1 η'.2.1)
let Q := supportAnnihilator (reverseLoading m η.1 η.2.1)
have hhom : Q'.IsHomogeneous (m + 2) := supportAnnihilator_isHomogeneous _
have hcon : ∀ k, k ≤ m → diffApply Q'
(dividedPowerBlock (reverseCumulantMap m (2 * m + 2) η) (m + 2 + k)) = 0 := by
have hown := reverse_supportAnnihilator_in_contraction_kernel m η' Q' hhom
⟨1, by simp [Q']⟩
rw [heq] at hown
exact hown
obtain ⟨c, hcQ⟩ := (hkernel Q' hhom).mp hcon
have hc : c ≠ 0 := by
intro hc0
have hQzero : Q' = 0 := by simpa [hc0] using hcQ
exact reverse_support_ne_zero' m η'.1 η'.2.1 (by simpa [Q'] using hQzero)
have hdehom : fullFiberDehomY Q' = Polynomial.C c * fullFiberDehomY Q := by
have hcQ' : Q' = c • Q := by simpa [Q] using hcQ
rw [hcQ']
simp [MvPolynomial.smul_eq_C_mul, fullFiberDehomY]
have hroots : (fullFiberDehomY Q').roots = (fullFiberDehomY Q).roots := by
rw [hdehom, Polynomial.roots_C_mul _ hc]
simpa [loadingSlopeMultiset, Q', Q, roots_fullFiberDehomY_reverse] using hroots
theorem latent_slopes_ne_zero_of_root_polynomial
A root polynomial nonzero at zero certifies that every displayed latent slope is nonzero.
Formal statement
hypotheses
conclusion
∀ i, θ.2.1 i ≠ 0
Proof (Lean source)
lemma latent_slopes_ne_zero_of_root_polynomial {m : ℕ} {θ : ParamSpace ℂ m}
{Q : Polynomial ℂ} (hQ : Q ≠ 0)
(hroots : Q.roots = loadingSlopeMultiset θ) (hzero : Q.eval 0 ≠ 0) :
∀ i, θ.2.1 i ≠ 0 := by
intro i hi
apply hzero
have hm : (0 : ℂ) ∈ Q.roots := by
rw [hroots]
rw [loadingSlopeMultiset, Multiset.mem_cons, Multiset.mem_map]
exact inr ⟨i, Finset.mem_univ i, hi⟩
exact (Polynomial.mem_roots hQ).mp hm
Helpers.GenericFiberDimension 2 declarations
theorem forward_full_fiber_dimension
Establishes the stated dimension formula for forward full fiber.
Formal statement
hypotheses
m :
ℕ
θ :
ParamSpace ℂ m
hgen :
θ ∈ genericParameterLocus m (2 * m + 2)
hrecover :
∀ θ' ∈ fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2)) (forwardCumulantMap m (2 * m + 2) θ),
hm :
2 ≤ m
conclusion
HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2) (fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2)) (forwardCumulantMap m (2 * m + 2) θ))
Proof (Lean source)
theorem forward_full_fiber_dimension (m : ℕ) (θ : ParamSpace ℂ m)
(hgen : θ ∈ genericParameterLocus m (2 * m + 2))
(hrecover : ∀ θ' ∈ fiberCorrespondence (2 * m + 2)
(forwardCumulantMap m (2 * m + 2))
(forwardCumulantMap m (2 * m + 2) θ),
loadingSlopeMultiset θ' = loadingSlopeMultiset θ)
(hm : 2 ≤ m) :
HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2)
(fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2))
(forwardCumulantMap m (2 * m + 2) θ)) := by
let L := 2 * m + 2
let d := m * (m - 1) / 2
let Z := fiberCorrespondence L (forwardCumulantMap m L)
(forwardCumulantMap m L θ)
have hZband : Z ⊆ bandSupportedParams m L := fun _ h => h.1
apply (relativeDimension_iff_bandDimension (m := m) (L := L) (d := d)
(by omega) hZband).2
have hfixedRel := forward_fixedLoadingFiber_dimension m θ hgen hm
have hfixedAff := (relativeDimension_iff_bandDimension (m := m) (L := L)
(d := d) (by omega) forwardFixedLoadingFiber_subset_band).1 hfixedRel
constructor
· obtain ⟨chain, hmono, hirr, hsub⟩ := hfixedAff.1
refine ⟨chain, hmono, hirr, ?_⟩
intro i
exact (hsub i).trans (Set.image_mono fun _ h => h.1)
· rintro ⟨chain, hmono, hirr, hsub⟩
let top : Fin (d + 2) := last (d + 1)
obtain ⟨θ₀, hθ₀, hsθ₀, htop⟩ :=
forward_irreducible_subset_fixedLoading θ hgen hrecover
(hirr top) (hsub top)
have hcomponentRel := forward_fixedLoadingFiber_dimension_of_injective
m θ₀ hθ₀.1 hsθ₀ hm
have hcomponentAff := (relativeDimension_iff_bandDimension (m := m) (L := L)
(d := d) (by omega) forwardFixedLoadingFiber_subset_band).1 hcomponentRel
apply hcomponentAff.2
refine ⟨chain, hmono, hirr, ?_⟩
intro i
exact (hmono.monotone (Fin.le_last i)).trans htop
theorem reverse_full_fiber_dimension
Establishes the stated dimension formula for reverse full fiber.
Formal statement
hypotheses
m :
ℕ
η :
ParamSpace ℂ m
hgen :
η ∈ genericParameterLocus m (2 * m + 2)
hrecover :
∀ η' ∈ fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2)) (reverseCumulantMap m (2 * m + 2) η),
hm :
2 ≤ m
conclusion
HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2) (fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2)) (reverseCumulantMap m (2 * m + 2) η))
Proof (Lean source)
theorem reverse_full_fiber_dimension (m : ℕ) (η : ParamSpace ℂ m)
(hgen : η ∈ genericParameterLocus m (2 * m + 2))
(hrecover : ∀ η' ∈ fiberCorrespondence (2 * m + 2)
(reverseCumulantMap m (2 * m + 2))
(reverseCumulantMap m (2 * m + 2) η),
loadingSlopeMultiset η' = loadingSlopeMultiset η)
(hm : 2 ≤ m) :
HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2)
(fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2))
(reverseCumulantMap m (2 * m + 2) η)) := by
let L := 2 * m + 2
let d := m * (m - 1) / 2
let Z := fiberCorrespondence L (reverseCumulantMap m L)
(reverseCumulantMap m L η)
have hZband : Z ⊆ bandSupportedParams m L := fun _ h => h.1
apply (relativeDimension_iff_bandDimension (m := m) (L := L) (d := d)
(by omega) hZband).2
have hfixedRel := reverse_fixedLoadingFiber_dimension m η hgen hm
have hfixedAff := (relativeDimension_iff_bandDimension (m := m) (L := L)
(d := d) (by omega) reverseFixedLoadingFiber_subset_band).1 hfixedRel
constructor
· obtain ⟨chain, hmono, hirr, hsub⟩ := hfixedAff.1
refine ⟨chain, hmono, hirr, ?_⟩
intro i
exact (hsub i).trans (Set.image_mono fun _ h => h.1)
· rintro ⟨chain, hmono, hirr, hsub⟩
let top : Fin (d + 2) := last (d + 1)
obtain ⟨η₀, hη₀, hsη₀, htop⟩ :=
reverse_irreducible_subset_fixedLoading η hgen hrecover
(hirr top) (hsub top)
have hcomponentRel := reverse_fixedLoadingFiber_dimension_of_injective
m η₀ hη₀.1 hsη₀ hm
have hcomponentAff := (relativeDimension_iff_bandDimension (m := m) (L := L)
(d := d) (by omega) reverseFixedLoadingFiber_subset_band).1 hcomponentRel
apply hcomponentAff.2
refine ⟨chain, hmono, hirr, ?_⟩
intro i
exact (hmono.monotone (Fin.le_last i)).trans htop
Helpers.GenericSlopes 7 declarations
theorem gamma_ne_zero_of_generic
On the generic locus the direct slope is nonzero.
Formal statement
Proof (Lean source)
lemma gamma_ne_zero_of_generic {m L : ℕ} {θ : ParamSpace ℂ m}
(hθ : θ ∈ genericParameterLocus m L) : θ.1 ≠ 0 := by
intro h
exact genericParameterLocus_prod_ne_zero hθ (by simp [h])
theorem gamma_ne_rho_of_generic
On the generic locus the direct slope differs from every latent slope.
Formal statement
hypotheses
conclusion
θ.1 ≠ θ.2.1 i
Proof (Lean source)
lemma gamma_ne_rho_of_generic {m L : ℕ} {θ : ParamSpace ℂ m}
(hθ : θ ∈ genericParameterLocus m L) (i : Fin m) : θ.1 ≠ θ.2.1 i := by
intro h
have hz : (∏ x : Fin m, (θ.1 - θ.2.1 x)) = 0 :=
Finset.prod_eq_zero (Finset.mem_univ i) (by simp [h])
exact genericParameterLocus_prod_ne_zero hθ (by simp [hz])
theorem rho_injective_of_generic
On the generic locus the latent slopes are pairwise distinct.
Formal statement
Proof (Lean source)
lemma rho_injective_of_generic {m L : ℕ} {θ : ParamSpace ℂ m}
(hθ : θ ∈ genericParameterLocus m L) : Injective θ.2.1 := by
intro i i' h
by_contra hn
rcases lt_or_gt_of_ne hn with hlt | hgt
· have hin : (∏ k : Fin m, if i < k then θ.2.1 i - θ.2.1 k else 1) = 0 :=
Finset.prod_eq_zero (Finset.mem_univ i') (by simp [hlt, h])
have hout :
(∏ k : Fin m, ∏ l : Fin m,
if k < l then θ.2.1 k - θ.2.1 l else 1) = 0 :=
Finset.prod_eq_zero (Finset.mem_univ i) hin
exact genericParameterLocus_prod_ne_zero hθ (by simp [hout])
· have hin : (∏ k : Fin m, if i' < k then θ.2.1 i' - θ.2.1 k else 1) = 0 :=
Finset.prod_eq_zero (Finset.mem_univ i) (by simp [hgt, h])
have hout :
(∏ k : Fin m, ∏ l : Fin m,
if k < l then θ.2.1 k - θ.2.1 l else 1) = 0 :=
Finset.prod_eq_zero (Finset.mem_univ i') hin
exact genericParameterLocus_prod_ne_zero hθ (by simp [hout])
theorem forward_slopes_injective_of_generic
The forward loading slopes (u_j)₂ over j = 0,…,m (the direct slope γ followed by the latent slopes ρ_i) are pairwise distinct.
Formal statement
Proof (Lean source)
lemma forward_slopes_injective_of_generic {m L : ℕ} {θ : ParamSpace ℂ m}
(hθ : θ ∈ genericParameterLocus m L) :
Injective
(fun j : Fin (m + 1) => (forwardLoading m θ.1 θ.2.1 (castSucc j)).2) := by
intro j
refine Fin.cases ?_ (fun i => ?_) j
· intro k h
refine Fin.cases (fun _ => rfl) (fun i' h' => ?_) k h
have hi' : i'.val ≠ m := Nat.ne_of_lt i'.isLt
exact ((gamma_ne_rho_of_generic hθ i')
(by simpa [forwardLoading, hi'] using h')).elim
· intro k h
have hi : i.val ≠ m := Nat.ne_of_lt i.isLt
refine Fin.cases (fun h' => ?_) (fun i' h' => ?_) k h
· exact ((gamma_ne_rho_of_generic hθ i)
(by simpa [forwardLoading, hi] using h'.symm)).elim
· have hi' : i'.val ≠ m := Nat.ne_of_lt i'.isLt
exact congrArg succ ((rho_injective_of_generic hθ)
(by simpa [forwardLoading, hi, hi'] using h'))
theorem forward_slopes_ne_zero_of_generic
With nonzero latent slopes, the forward loading slopes (u_j)₂ over j = 0,…,m are all nonzero.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma forward_slopes_ne_zero_of_generic {m L : ℕ} {θ : ParamSpace ℂ m}
(hθ : θ ∈ genericParameterLocus m L) (hρ : ∀ i, θ.2.1 i ≠ 0) :
∀ j : Fin (m + 1), (forwardLoading m θ.1 θ.2.1 (castSucc j)).2 ≠ 0 := by
intro j
refine Fin.cases ?_ (fun i => ?_) j
· simpa [forwardLoading] using gamma_ne_zero_of_generic hθ
· have hi : i.val ≠ m := Nat.ne_of_lt i.isLt
simpa [forwardLoading, hi] using hρ i
theorem reverse_slopes_injective_of_generic
The reverse loading slopes (v_j)₁ over j = 1,…,m+1 (the latent slopes σ_i followed by the direct slope δ) are pairwise distinct.
Formal statement
Proof (Lean source)
lemma reverse_slopes_injective_of_generic {m L : ℕ} {η : ParamSpace ℂ m}
(hη : η ∈ genericParameterLocus m L) :
Injective
(fun j : Fin (m + 1) => (reverseLoading m η.1 η.2.1 j.succ).1) := by
intro j
refine Fin.lastCases ?_ (fun i => ?_) j
· intro k h
refine Fin.lastCases (fun _ => rfl) (fun i' h' => ?_) k h
have hi' : i'.val ≠ m := Nat.ne_of_lt i'.isLt
exact ((gamma_ne_rho_of_generic hη i')
(by simpa [reverseLoading, hi'] using h')).elim
· intro k h
have hi : i.val ≠ m := Nat.ne_of_lt i.isLt
refine Fin.lastCases (fun h' => ?_) (fun i' h' => ?_) k h
· exact ((gamma_ne_rho_of_generic hη i)
(by simpa [reverseLoading, hi] using h'.symm)).elim
· have hi' : i'.val ≠ m := Nat.ne_of_lt i'.isLt
exact congrArg castSucc ((rho_injective_of_generic hη)
(by simpa [reverseLoading, hi, hi'] using h'))
theorem reverse_slopes_ne_zero_of_generic
With nonzero latent slopes, the reverse loading slopes (v_j)₁ over j = 1,…,m+1 are all nonzero.
Formal statement
hypotheses
conclusion
∀ j : Fin (m + 1), (reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0
Proof (Lean source)
lemma reverse_slopes_ne_zero_of_generic {m L : ℕ} {η : ParamSpace ℂ m}
(hη : η ∈ genericParameterLocus m L) (hσ : ∀ i, η.2.1 i ≠ 0) :
∀ j : Fin (m + 1), (reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0 := by
intro j
refine Fin.lastCases ?_ (fun i => ?_) j
· simpa [reverseLoading] using gamma_ne_zero_of_generic hη
· have hi : i.val ≠ m := Nat.ne_of_lt i.isLt
simpa [reverseLoading, hi] using hσ i
Helpers.LoadingWeightKernelDimension 6 declarations
def loadingOrderSynthesis
The linear weight-synthesis map attached to an arbitrary loading family.
Definition (Lean source)
def loadingOrderSynthesis {n : ℕ} (u : Fin n → ℂ × ℂ) (r : ℕ) :
(Fin n → ℂ) →ₗ[ℂ] (Fin (r + 1) → ℂ) where
toFun z a := ∑ j, z j * (u j).1 ^ (r - a.val) * (u j).2 ^ a.val
map_add' x y := by
funext a
simp only [Pi.add_apply, add_mul, Finset.sum_add_distrib]
map_smul' c x := by
funext a
simp only [Pi.smul_apply, smul_eq_mul, RingHom.id_apply]
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro j _
ring
def loadingBandWeightKernel
Fixing the loading coordinates leaves the product of the orderwise loading-synthesis kernels.
Definition (Lean source)
def loadingBandWeightKernel (m L : ℕ) (u : Fin (m + 2) → ℂ × ℂ) :
Submodule ℂ (BandParamCoord m L → ℂ) where
carrier := {x |
x (inl ()) = 0 ∧
(∀ i, x (inr (inl i)) = 0) ∧
∀ k : Fin (L - 1), loadingOrderSynthesis u (k.val + 2)
(fun j => x (inr (inr (j, k)))) = 0}
zero_mem' := by
refine ⟨rfl, fun _ => rfl, ?_⟩
intro k
change loadingOrderSynthesis u (k.val + 2) 0 = 0
exact (loadingOrderSynthesis u (k.val + 2)).map_zero
add_mem' {x y} hx hy := by
refine ⟨by simp [hx.1, hy.1], fun i => by simp [hx.2.1 i, hy.2.1 i], ?_⟩
intro k
change loadingOrderSynthesis u (k.val + 2)
((fun j => x (inr (inr (j, k)))) +
fun j => y (inr (inr (j, k)))) = 0
rw [map_add, hx.2.2 k, hy.2.2 k, add_zero]
smul_mem' c x hx := by
refine ⟨by simp [hx.1], fun i => by simp [hx.2.1 i], ?_⟩
intro k
change loadingOrderSynthesis u (k.val + 2)
(c • fun j => x (inr (inr (j, k)))) = 0
rw [map_smul, hx.2.2 k, smul_zero]
theorem forward_loadingBandWeightKernel_finrank_of_injective
Proves that the map or coordinate assignment called the forward loading Band Weight Kernel finrank of is injective.
Formal statement
Proof (Lean source)
theorem forward_loadingBandWeightKernel_finrank_of_injective (m : ℕ)
(θ : ParamSpace ℂ m)
(hs : Injective (fun j : Fin (m + 1) =>
(forwardLoading m θ.1 θ.2.1 j.castSucc).2)) (hm : 2 ≤ m) :
finrank ℂ
(loadingBandWeightKernel m (2 * m + 2) (forwardLoading m θ.1 θ.2.1)) =
m * (m - 1) / 2 := by
let s := fun j : Fin (m + 1) =>
(forwardLoading m θ.1 θ.2.1 j.castSucc).2
have heq : loadingBandWeightKernel m (2 * m + 2)
(forwardLoading m θ.1 θ.2.1) =
bandWeightKernel m (2 * m + 2) s := by
ext x
simp only [loadingBandWeightKernel, bandWeightKernel, Submodule.mem_mk,
Set.mem_setOf_eq]
dsimp [s]
constructor
· rintro ⟨hzero, hslope, horder⟩
refine ⟨hzero, hslope, ?_⟩
intro k
rw [← forward_loadingOrderSynthesis_eq]
exact horder k
· rintro ⟨hzero, hslope, horder⟩
refine ⟨hzero, hslope, ?_⟩
intro k
rw [forward_loadingOrderSynthesis_eq]
exact horder k
rw [heq]
exact bandWeightKernel_finrank_flagship m s hs hm
theorem forward_loadingBandWeightKernel_finrank
Establishes the stated dimension formula for forward loading Band Weight Kernel.
Formal statement
hypotheses
conclusion
= m * (m - 1) / 2
Proof (Lean source)
theorem forward_loadingBandWeightKernel_finrank (m : ℕ) (θ : ParamSpace ℂ m)
(hθ : θ ∈ genericParameterLocus m (2 * m + 2)) (hm : 2 ≤ m) :
finrank ℂ
(loadingBandWeightKernel m (2 * m + 2) (forwardLoading m θ.1 θ.2.1)) =
m * (m - 1) / 2 :=
forward_loadingBandWeightKernel_finrank_of_injective m θ
(forward_slopes_injective_of_generic hθ) hm
theorem reverse_loadingBandWeightKernel_finrank_of_injective
Proves that the map or coordinate assignment called the reverse loading Band Weight Kernel finrank of is injective.
Formal statement
Proof (Lean source)
theorem reverse_loadingBandWeightKernel_finrank_of_injective (m : ℕ)
(η : ParamSpace ℂ m)
(hs : Injective (fun j : Fin (m + 1) =>
(reverseLoading m η.1 η.2.1 j.succ).1)) (hm : 2 ≤ m) :
finrank ℂ
(loadingBandWeightKernel m (2 * m + 2) (reverseLoading m η.1 η.2.1)) =
m * (m - 1) / 2 := by
let s := fun j : Fin (m + 1) =>
(reverseLoading m η.1 η.2.1 j.succ).1
rw [(reverseLoadingKernelEquiv m (2 * m + 2) η.1 η.2.1).finrank_eq,
Module.finrank_pi_fintype]
calc
_ = Finset.univ.sum (fun k : Fin ((2 * m + 2) - 1) =>
(m + 1) - (k.val + 2)) := by
apply Finset.sum_congr rfl
intro k _
exact endpointOrderSynthesis_ker_finrank s hs
_ = _ := retained_kernel_sum m hm
theorem reverse_loadingBandWeightKernel_finrank
Establishes the stated dimension formula for reverse loading Band Weight Kernel.
Formal statement
hypotheses
conclusion
= m * (m - 1) / 2
Proof (Lean source)
theorem reverse_loadingBandWeightKernel_finrank (m : ℕ) (η : ParamSpace ℂ m)
(hη : η ∈ genericParameterLocus m (2 * m + 2)) (hm : 2 ≤ m) :
finrank ℂ
(loadingBandWeightKernel m (2 * m + 2) (reverseLoading m η.1 η.2.1)) =
m * (m - 1) / 2 :=
reverse_loadingBandWeightKernel_finrank_of_injective m η
(reverse_slopes_injective_of_generic hη) hm
Helpers.LowerOrderApolarKernel 6 declarations
theorem lowerForwardEvaluationsVanish
Proves the stated mathematical property of lower Forward Evaluations Vanish.
Formal statement
hypotheses
m :
ℕ
hm :
3 ≤ m
θ :
ParamSpace ℂ m
q :
MvPolynomial (Fin 2) ℂ
hq :
q.IsHomogeneous (m + 2)
hrank :
hcon :
∀ k
if
k ≤ m - 1
then
conclusion
∀ j, evalAtDir q (forwardLoading m θ.1 θ.2.1 j) = 0
Proof (Lean source)
lemma lowerForwardEvaluationsVanish (m : ℕ) (hm : 3 ≤ m) (θ : ParamSpace ℂ m)
(q : MvPolynomial (Fin 2) ℂ) (hq : q.IsHomogeneous (m + 2))
(hrank : Injective (lowerForwardWeightedContraction m θ))
(hcon : ∀ k, k ≤ m - 1 → diffApply q
(dividedPowerBlock (forwardCumulantMap m (2 * m + 1) θ) (m + 2 + k)) = 0) :
∀ j, evalAtDir q (forwardLoading m θ.1 θ.2.1 j) = 0 := by
let e : Fin (m + 2) → ℂ := fun j => evalAtDir q (forwardLoading m θ.1 θ.2.1 j)
have hstack := lowerForwardStackEquation m hm θ q hq hcon
have hminor : lowerForwardWeightedContraction m θ e =
lowerForwardWeightedContraction m θ 0 := by
funext i
refine Fin.cases ?_ (fun i' => Fin.cases ?_ (fun r => ?_) i') i
· have h := congrArg (fun p => (binaryDehom p).coeff 0) (hstack 0 (by omega))
simp [lowerForwardWeightedContraction, lowerForwardMinor_apply, mulVec,
dotProduct, e, binaryDehom] at h ⊢
simpa [mul_assoc] using h
· have h := congrArg (fun p => (binaryDehom p).coeff 0) (hstack 1 (by omega))
simp only [map_sum, map_mul, map_pow, map_zero, Polynomial.finset_sum_coeff,
Polynomial.coeff_zero] at h
simp only [lowerForwardWeightedContraction, lowerForwardMinor_apply, mulVec,
dotProduct, Pi.zero_apply, mul_zero, Finset.sum_const_zero]
simp only [Fin.val_succ]
norm_num at h ⊢
have hindex : m + 2 + 1 = m + 3 := by omega
rw [hindex] at h
dsimp [e]
convert h using 1
apply Finset.sum_congr rfl
intro j _
rw [lowerKernel_coeff_zero]
ring
· have h := congrArg (fun p => (binaryDehom p).coeff r.1)
(hstack (m - 1) (by omega))
simp only [map_sum, map_mul, map_pow, map_zero, Polynomial.finset_sum_coeff,
Polynomial.coeff_zero] at h
simp only [lowerForwardWeightedContraction, lowerForwardMinor_apply, mulVec,
dotProduct, Pi.zero_apply, mul_zero, Finset.sum_const_zero]
have hv0 : (r.succ.succ : Fin (m + 2)).val ≠ 0 := by simp
have hv1 : (r.succ.succ : Fin (m + 2)).val ≠ 1 := by simp
have hv2 : (r.succ.succ : Fin (m + 2)).val - 2 = r.val := by simp
simp only [hv0, hv1, if_false, hv2]
have hindex : m + 2 + (m - 1) = 2 * m + 1 := by omega
rw [hindex] at h
dsimp [e]
convert h using 1
apply Finset.sum_congr rfl
intro j _
simp only [lowerKernel_binaryDehom_C]
rw [← Polynomial.C_mul, Polynomial.coeff_C_mul,
coeff_binaryDehom_linForm_pow']
ring
have he : e = 0 := hrank hminor
intro j
exact congrFun he j
theorem lowerReverseEvaluationsVanish
Proves the stated mathematical property of lower Reverse Evaluations Vanish.
Formal statement
hypotheses
m :
ℕ
hm :
3 ≤ m
η :
ParamSpace ℂ m
q :
MvPolynomial (Fin 2) ℂ
hq :
q.IsHomogeneous (m + 2)
hrank :
hcon :
∀ k
if
k ≤ m - 1
then
conclusion
∀ j, evalAtDir q (reverseLoading m η.1 η.2.1 j) = 0
Proof (Lean source)
lemma lowerReverseEvaluationsVanish (m : ℕ) (hm : 3 ≤ m) (η : ParamSpace ℂ m)
(q : MvPolynomial (Fin 2) ℂ) (hq : q.IsHomogeneous (m + 2))
(hrank : Injective (lowerReverseWeightedContraction m η))
(hcon : ∀ k, k ≤ m - 1 → diffApply q
(dividedPowerBlock (reverseCumulantMap m (2 * m + 1) η) (m + 2 + k)) = 0) :
∀ j, evalAtDir q (reverseLoading m η.1 η.2.1 j) = 0 := by
let e : Fin (m + 2) → ℂ := fun j => evalAtDir q (reverseLoading m η.1 η.2.1 j)
have hstack := lowerReverseStackEquation m hm η q hq hcon
have hminor : lowerReverseWeightedContraction m η e =
lowerReverseWeightedContraction m η 0 := by
funext i
refine Fin.cases ?_ (fun i' => Fin.cases ?_ (fun r => ?_) i') i
· have h := congrArg (fun p => (binaryDehom p).coeff 0) (hstack 0 (by omega))
simp [lowerReverseWeightedContraction, lowerReverseMinor_apply, mulVec,
dotProduct, e, binaryDehom] at h ⊢
simpa [mul_assoc] using h
· have h := congrArg (fun p => (binaryDehom p).coeff 1) (hstack 1 (by omega))
simp only [map_sum, map_mul, map_pow, map_zero, Polynomial.finset_sum_coeff,
Polynomial.coeff_zero] at h
simp only [lowerReverseWeightedContraction, lowerReverseMinor_apply, mulVec,
dotProduct, Pi.zero_apply, mul_zero, Finset.sum_const_zero]
simp only [Fin.val_succ]
norm_num at h ⊢
have hindex : m + 2 + 1 = m + 3 := by omega
rw [hindex] at h
dsimp [e]
convert h using 1
apply Finset.sum_congr rfl
intro j _
rw [← Polynomial.C_mul, Polynomial.coeff_C_mul, lowerKernel_coeff_one]
ring
· have h := congrArg (fun p => (binaryDehom p).coeff (m - 1 - r.1))
(hstack (m - 1) (by omega))
simp only [map_sum, map_mul, map_pow, map_zero, Polynomial.finset_sum_coeff,
Polynomial.coeff_zero] at h
simp only [lowerReverseWeightedContraction, lowerReverseMinor_apply, mulVec,
dotProduct, Pi.zero_apply, mul_zero, Finset.sum_const_zero]
have hv0 : (r.succ.succ : Fin (m + 2)).val ≠ 0 := by simp
have hv1 : (r.succ.succ : Fin (m + 2)).val ≠ 1 := by simp
have hv2 : (r.succ.succ : Fin (m + 2)).val - 2 = r.val := by simp
simp only [hv0, hv1, if_false, hv2]
have hindex : m + 2 + (m - 1) = 2 * m + 1 := by omega
rw [hindex] at h
dsimp [e]
convert h using 1
apply Finset.sum_congr rfl
intro j _
simp only [lowerKernel_binaryDehom_C]
rw [← Polynomial.C_mul, Polynomial.coeff_C_mul,
coeff_binaryDehom_linForm_pow']
have hsub : m - 1 - (m - 1 - r.1) = r.1 := by omega
have hchoose : (m - 1).choose (m - 1 - r.1) = (m - 1).choose r.1 := by
rw [Nat.choose_symm (by omega)]
rw [hsub, hchoose]
ring
have he : e = 0 := hrank hminor
intro j
exact congrFun he j
theorem lowerForwardSupportAnnihilatorInKernel
Proves the stated mathematical property of lower Forward Support Annihilator In Kernel.
Formal statement
hypotheses
m :
ℕ
hm :
3 ≤ m
θ :
ParamSpace ℂ m
q :
MvPolynomial (Fin 2) ℂ
hq :
q.IsHomogeneous (m + 2)
hqD :
∃ c : ℂ, q = c • supportAnnihilator (forwardLoading m θ.1 θ.2.1)
conclusion
∀ k
if
k ≤ m - 1
then
Proof (Lean source)
lemma lowerForwardSupportAnnihilatorInKernel (m : ℕ) (hm : 3 ≤ m) (θ : ParamSpace ℂ m)
(q : MvPolynomial (Fin 2) ℂ) (hq : q.IsHomogeneous (m + 2))
(hqD : ∃ c : ℂ, q = c • supportAnnihilator (forwardLoading m θ.1 θ.2.1)) :
∀ k, k ≤ m - 1 → diffApply q
(dividedPowerBlock (forwardCumulantMap m (2 * m + 1) θ) (m + 2 + k)) = 0 := by
intro k hk
rw [dividedPowerBlock_forward_eq_sum_linForm_pow m (2 * m + 1) (m + 2 + k) θ
(by omega) (by omega), diffApply_sum]
apply Finset.sum_eq_zero
intro j _
rw [diffApply_C_mul, diffApply_linForm_pow q hq]
rcases hqD with ⟨c, rfl⟩
simp only [MvPolynomial.smul_eq_C_mul, evalAtDir, MvPolynomial.eval_mul,
MvPolynomial.eval_C]
have hzero := evalAtDir_supportAnnihilator_eq_zero
(forwardLoading m θ.1 θ.2.1) j
simp only [evalAtDir] at hzero
rw [hzero, mul_zero]
simp
theorem lowerReverseSupportAnnihilatorInKernel
Proves the stated mathematical property of lower Reverse Support Annihilator In Kernel.
Formal statement
hypotheses
m :
ℕ
hm :
3 ≤ m
η :
ParamSpace ℂ m
q :
MvPolynomial (Fin 2) ℂ
hq :
q.IsHomogeneous (m + 2)
hqD :
∃ c : ℂ, q = c • supportAnnihilator (reverseLoading m η.1 η.2.1)
conclusion
∀ k
if
k ≤ m - 1
then
Proof (Lean source)
lemma lowerReverseSupportAnnihilatorInKernel (m : ℕ) (hm : 3 ≤ m) (η : ParamSpace ℂ m)
(q : MvPolynomial (Fin 2) ℂ) (hq : q.IsHomogeneous (m + 2))
(hqD : ∃ c : ℂ, q = c • supportAnnihilator (reverseLoading m η.1 η.2.1)) :
∀ k, k ≤ m - 1 → diffApply q
(dividedPowerBlock (reverseCumulantMap m (2 * m + 1) η) (m + 2 + k)) = 0 := by
intro k hk
rw [dividedPowerBlock_reverse_eq_sum_linForm_pow m (2 * m + 1) (m + 2 + k) η
(by omega) (by omega), diffApply_sum]
apply Finset.sum_eq_zero
intro j _
rw [diffApply_C_mul, diffApply_linForm_pow q hq]
rcases hqD with ⟨c, rfl⟩
simp only [MvPolynomial.smul_eq_C_mul, evalAtDir, MvPolynomial.eval_mul,
MvPolynomial.eval_C]
have hzero := evalAtDir_supportAnnihilator_eq_zero
(reverseLoading m η.1 η.2.1) j
simp only [evalAtDir] at hzero
rw [hzero, mul_zero]
simp
theorem lowerForwardApolarKernelIdentity
Proves the stated mathematical property of lower Forward Apolar Kernel Identity.
Formal statement
hypotheses
m :
ℕ
hm :
3 ≤ m
θ :
ParamSpace ℂ m
hslopes :
hnonzero :
∀ j : Fin (m + 1), (forwardLoading m θ.1 θ.2.1 j.castSucc).2 ≠ 0
hrank :
conclusion
∀ q : MvPolynomial (Fin 2) ℂ
if
q.IsHomogeneous (m + 2)
then
((∀ k, k ≤ m - 1 → diffApply q (dividedPowerBlock (forwardCumulantMap m (2 * m + 1) θ) (m + 2 + k)) = 0) ↔ ∃ c : ℂ, q = c • supportAnnihilator (forwardLoading m θ.1 θ.2.1))
Proof (Lean source)
theorem lowerForwardApolarKernelIdentity (m : ℕ) (hm : 3 ≤ m) (θ : ParamSpace ℂ m)
(hslopes : Injective
(fun j : Fin (m + 1) => (forwardLoading m θ.1 θ.2.1 j.castSucc).2))
(hnonzero : ∀ j : Fin (m + 1),
(forwardLoading m θ.1 θ.2.1 j.castSucc).2 ≠ 0)
(hrank : Injective (lowerForwardWeightedContraction m θ)) :
∀ q : MvPolynomial (Fin 2) ℂ, q.IsHomogeneous (m + 2) →
((∀ k, k ≤ m - 1 → diffApply q
(dividedPowerBlock (forwardCumulantMap m (2 * m + 1) θ) (m + 2 + k)) = 0)
↔ ∃ c : ℂ, q = c • supportAnnihilator (forwardLoading m θ.1 θ.2.1)) := by
intro q hq
constructor
· intro hcon
apply forward_points_imply_supportAnnihilator_multiple m θ q hq hslopes hnonzero
exact lowerForwardEvaluationsVanish m hm θ q hq hrank hcon
· rintro ⟨c, rfl⟩ k hk
apply lowerForwardSupportAnnihilatorInKernel m hm θ _ hq ⟨c, rfl⟩ k hk
theorem lowerReverseApolarKernelIdentity
Proves the stated mathematical property of lower Reverse Apolar Kernel Identity.
Formal statement
hypotheses
m :
ℕ
hm :
3 ≤ m
η :
ParamSpace ℂ m
hslopes :
hnonzero :
∀ j : Fin (m + 1), (reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0
hrank :
conclusion
∀ q : MvPolynomial (Fin 2) ℂ
if
q.IsHomogeneous (m + 2)
then
((∀ k, k ≤ m - 1 → diffApply q (dividedPowerBlock (reverseCumulantMap m (2 * m + 1) η) (m + 2 + k)) = 0) ↔ ∃ c : ℂ, q = c • supportAnnihilator (reverseLoading m η.1 η.2.1))
Proof (Lean source)
theorem lowerReverseApolarKernelIdentity (m : ℕ) (hm : 3 ≤ m) (η : ParamSpace ℂ m)
(hslopes : Injective
(fun j : Fin (m + 1) => (reverseLoading m η.1 η.2.1 j.succ).1))
(hnonzero : ∀ j : Fin (m + 1), (reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0)
(hrank : Injective (lowerReverseWeightedContraction m η)) :
∀ q : MvPolynomial (Fin 2) ℂ, q.IsHomogeneous (m + 2) →
((∀ k, k ≤ m - 1 → diffApply q
(dividedPowerBlock (reverseCumulantMap m (2 * m + 1) η) (m + 2 + k)) = 0)
↔ ∃ c : ℂ, q = c • supportAnnihilator (reverseLoading m η.1 η.2.1)) := by
intro q hq
constructor
· intro hcon
apply reverse_points_imply_supportAnnihilator_multiple m η q hq hslopes hnonzero
exact lowerReverseEvaluationsVanish m hm η q hq hrank hcon
· rintro ⟨c, rfl⟩ k hk
apply lowerReverseSupportAnnihilatorInKernel m hm η _ hq ⟨c, rfl⟩ k hk
Helpers.LowerOrderApolarRank 27 declarations
def lowerFirstPolynomial
Defines the polynomial called the lower First Polynomial.
Definition (Lean source)
def lowerFirstPolynomial {R : Type*} [CommRing R] (m : ℕ) (j : Fin (m + 2)) :
MvPolynomial (ParamCoord m) R :=
if j.1 = m + 1 then 0 else 1
def lowerSlopePolynomial
Defines the polynomial called the lower Slope Polynomial.
Definition (Lean source)
def lowerSlopePolynomial {R : Type*} [CommRing R] (m : ℕ) (j : Fin (m + 2)) :
MvPolynomial (ParamCoord m) R :=
if h0 : j.1 = 0 then X (inl ())
else if ha : j.1 = m + 1 then 1
else X (inr (inl ⟨j.1 - 1, by omega⟩))
def lowerReverseFirstPolynomial
Defines the polynomial called the lower Reverse First Polynomial.
Definition (Lean source)
def lowerReverseFirstPolynomial {R : Type*} [CommRing R]
(m : ℕ) (j : Fin (m + 2)) : MvPolynomial (ParamCoord m) R :=
if h0 : j.1 = 0 then 1
else if ha : j.1 = m + 1 then X (inl ())
else X (inr (inl ⟨j.1 - 1, by omega⟩))
def lowerReverseSecondPolynomial
Defines the polynomial called the lower Reverse Second Polynomial.
Definition (Lean source)
def lowerReverseSecondPolynomial {R : Type*} [CommRing R]
(m : ℕ) (j : Fin (m + 2)) : MvPolynomial (ParamCoord m) R :=
if j.1 = 0 then 0 else 1
def lowerWeightPolynomial
Defines the polynomial called the lower Weight Polynomial.
Definition (Lean source)
def lowerWeightPolynomial {R : Type*} [CommRing R]
(m : ℕ) (j : Fin (m + 2)) (r : ℕ) : MvPolynomial (ParamCoord m) R :=
X (inr (inr (j, r)))
def lowerForwardContractionMinorPolynomial Definition lowerForwardContractionMinorPolynomial in the paper ↗
Selected rows for the block partition J₀={axis}, J₁={direct} and J_{m-1}={latent sources}.
Definition (Lean source)
def lowerForwardContractionMinorPolynomial (R : Type*) [CommRing R] (m : ℕ) :
Matrix (Fin (m + 2)) (Fin (m + 2)) (MvPolynomial (ParamCoord m) R) :=
fun i j =>
if i.1 = 0 then lowerWeightPolynomial m j (m + 2)
else if i.1 = 1 then
lowerWeightPolynomial m j (m + 3) * lowerFirstPolynomial m j
else lowerWeightPolynomial m j (2 * m + 1) *
C ((m - 1).choose (i.1 - 2) : R) *
lowerFirstPolynomial m j ^ (m - 1 - (i.1 - 2)) *
lowerSlopePolynomial m j ^ (i.1 - 2)
def lowerReverseContractionMinorPolynomial Definition lowerReverseContractionMinorPolynomial in the paper ↗
The coordinate-reversed selected minor. Its top block uses coefficients in reverse order so that the latent columns are an ordinary Vandermonde matrix.
Definition (Lean source)
def lowerReverseContractionMinorPolynomial (R : Type*) [CommRing R] (m : ℕ) :
Matrix (Fin (m + 2)) (Fin (m + 2)) (MvPolynomial (ParamCoord m) R) :=
fun i j =>
if i.1 = 0 then lowerWeightPolynomial m j (m + 2)
else if i.1 = 1 then
lowerWeightPolynomial m j (m + 3) * lowerReverseSecondPolynomial m j
else lowerWeightPolynomial m j (2 * m + 1) *
C ((m - 1).choose (i.1 - 2) : R) *
lowerReverseFirstPolynomial m j ^ (i.1 - 2) *
lowerReverseSecondPolynomial m j ^ (m - 1 - (i.1 - 2))
Real rank witness for the forward arrow on the shorter apolar stack: the determinant of the selected forward contraction minor, read as a polynomial in the real structural parameters. Where this polynomial does not vanish, the selected rows of the forward contraction have full rank.
Definition (Lean source)
def lowerForwardRealRankPolynomial (m : ℕ) : MvPolynomial (RealParamCoord m) ℝ :=
(lowerForwardContractionMinorPolynomial ℝ m).det
Defines the polynomial called the lower Reverse Real Rank Polynomial.
Definition (Lean source)
def lowerReverseRealRankPolynomial (m : ℕ) : MvPolynomial (RealParamCoord m) ℝ :=
(lowerReverseContractionMinorPolynomial ℝ m).det
Defines the polynomial called the lower Forward Complex Rank Polynomial.
Definition (Lean source)
def lowerForwardComplexRankPolynomial (m : ℕ) : MvPolynomial (ParamCoord m) ℂ :=
(lowerForwardContractionMinorPolynomial ℂ m).det
Defines the polynomial called the lower Reverse Complex Rank Polynomial.
Definition (Lean source)
def lowerReverseComplexRankPolynomial (m : ℕ) : MvPolynomial (ParamCoord m) ℂ :=
(lowerReverseContractionMinorPolynomial ℂ m).det
theorem lowerForwardRankPolynomial_map_ofReal
Proves the stated mathematical property of lower Forward Rank Polynomial map of Real.
Formal statement
hypotheses
m :
ℕ
conclusion
Proof (Lean source)
lemma lowerForwardRankPolynomial_map_ofReal (m : ℕ) :
map ofRealHom (lowerForwardRealRankPolynomial m) =
lowerForwardComplexRankPolynomial m := by
rw [lowerForwardRealRankPolynomial, lowerForwardComplexRankPolynomial,
RingHom.map_det]
apply congrArg det
apply Matrix.ext
intro i j
change map ofRealHom
(lowerForwardContractionMinorPolynomial ℝ m i j) =
lowerForwardContractionMinorPolynomial ℂ m i j
by_cases hi0 : i.val = 0
· have hi : i = 0 := Fin.ext hi0
subst i
simp [lowerForwardContractionMinorPolynomial, map_lowerWeightPolynomial]
by_cases hi1 : i.val = 1
· have hi : i = 1 := Fin.ext hi1
subst i
simp [lowerForwardContractionMinorPolynomial, map_lowerWeightPolynomial,
map_lowerFirstPolynomial]
· simp only [lowerForwardContractionMinorPolynomial, hi0, hi1, if_false,
map_mul, map_pow, MvPolynomial.map_C]
rw [map_lowerWeightPolynomial, map_lowerFirstPolynomial,
map_lowerSlopePolynomial]
simp
theorem lowerReverseRankPolynomial_map_ofReal
Proves the stated mathematical property of lower Reverse Rank Polynomial map of Real.
Formal statement
hypotheses
m :
ℕ
conclusion
Proof (Lean source)
lemma lowerReverseRankPolynomial_map_ofReal (m : ℕ) :
map ofRealHom (lowerReverseRealRankPolynomial m) =
lowerReverseComplexRankPolynomial m := by
rw [lowerReverseRealRankPolynomial, lowerReverseComplexRankPolynomial,
RingHom.map_det]
apply congrArg det
apply Matrix.ext
intro i j
change map ofRealHom
(lowerReverseContractionMinorPolynomial ℝ m i j) =
lowerReverseContractionMinorPolynomial ℂ m i j
by_cases hi0 : i.val = 0
· have hi : i = 0 := Fin.ext hi0
subst i
simp [lowerReverseContractionMinorPolynomial, map_lowerWeightPolynomial]
by_cases hi1 : i.val = 1
· have hi : i = 1 := Fin.ext hi1
subst i
simp [lowerReverseContractionMinorPolynomial, map_lowerWeightPolynomial,
map_lowerReverseSecondPolynomial]
· simp only [lowerReverseContractionMinorPolynomial, hi0, hi1, if_false,
map_mul, map_pow, MvPolynomial.map_C]
rw [map_lowerWeightPolynomial, map_lowerReverseFirstPolynomial,
map_lowerReverseSecondPolynomial]
simp
theorem lowerForwardRankPolynomial_eval_complexify
Gives the stated evaluation formula for lower Forward Rank Polynomial complexify.
Formal statement
Proof (Lean source)
lemma lowerForwardRankPolynomial_eval_complexify (m : ℕ) (θ : ParamSpace ℝ m) :
eval (paramEval (complexifyParam θ))
(lowerForwardComplexRankPolynomial m) =
(eval (realParamEval θ) (lowerForwardRealRankPolynomial m) : ℂ) := by
have h := MvPolynomial.map_eval ofRealHom (realParamEval θ)
(lowerForwardRealRankPolynomial m)
rw [lowerForwardRankPolynomial_map_ofReal] at h
have hcoord : ofRealHom ∘ realParamEval θ =
paramEval (complexifyParam θ) := by
funext i
rcases i with _ | i
· rfl
rcases i with i | jr <;> rfl
rw [← hcoord]
exact h.symm
theorem lowerReverseRankPolynomial_eval_complexify
Gives the stated evaluation formula for lower Reverse Rank Polynomial complexify.
Formal statement
Proof (Lean source)
lemma lowerReverseRankPolynomial_eval_complexify (m : ℕ) (η : ParamSpace ℝ m) :
eval (paramEval (complexifyParam η))
(lowerReverseComplexRankPolynomial m) =
(eval (realParamEval η) (lowerReverseRealRankPolynomial m) : ℂ) := by
have h := MvPolynomial.map_eval ofRealHom (realParamEval η)
(lowerReverseRealRankPolynomial m)
rw [lowerReverseRankPolynomial_map_ofReal] at h
have hcoord : ofRealHom ∘ realParamEval η =
paramEval (complexifyParam η) := by
funext i
rcases i with _ | i
· rfl
rcases i with i | jr <;> rfl
rw [← hcoord]
exact h.symm
def lowerForwardMinor
Defines the mathematical object called the lower Forward Minor.
Definition (Lean source)
def lowerForwardMinor (m : ℕ) (θ : ParamSpace ℂ m) :
Matrix (Fin (m + 2)) (Fin (m + 2)) ℂ :=
(lowerForwardContractionMinorPolynomial ℂ m).map (eval (paramEval θ))
def lowerReverseMinor
Defines the mathematical object called the lower Reverse Minor.
Definition (Lean source)
def lowerReverseMinor (m : ℕ) (η : ParamSpace ℂ m) :
Matrix (Fin (m + 2)) (Fin (m + 2)) ℂ :=
(lowerReverseContractionMinorPolynomial ℂ m).map (eval (paramEval η))
def lowerForwardWeightedContraction
The selected scalar rows of the contractions visible at order 2m+1. They are the k=0 constant coefficient, the k=1 first coefficient, and all coefficients of the k=m-1 block.
Definition (Lean source)
def lowerReverseWeightedContraction
The coordinate-reversed selected contraction rows.
Definition (Lean source)
theorem lowerForwardMinor_apply
Gives the stated evaluation formula for lower Forward Minor.
Formal statement
hypotheses
conclusion
lowerForwardMinor m θ i j
= if i.1 = 0 then θ.2.2 j (m + 2) else if i.1 = 1 then θ.2.2 j (m + 3) * (forwardLoading m θ.1 θ.2.1 j).1 else θ.2.2 j (2 * m + 1) * ((m - 1).choose (i.1 - 2) : ℂ) * (forwardLoading m θ.1 θ.2.1 j).1 ^ (m - 1 - (i.1 - 2)) * (forwardLoading m θ.1 θ.2.1 j).2 ^ (i.1 - 2)
Proof (Lean source)
lemma lowerForwardMinor_apply (m : ℕ) (θ : ParamSpace ℂ m)
(i j : Fin (m + 2)) :
lowerForwardMinor m θ i j =
if i.1 = 0 then θ.2.2 j (m + 2)
else if i.1 = 1 then
θ.2.2 j (m + 3) * (forwardLoading m θ.1 θ.2.1 j).1
else θ.2.2 j (2 * m + 1) * ((m - 1).choose (i.1 - 2) : ℂ) *
(forwardLoading m θ.1 θ.2.1 j).1 ^ (m - 1 - (i.1 - 2)) *
(forwardLoading m θ.1 θ.2.1 j).2 ^ (i.1 - 2) := by
unfold lowerForwardMinor
rw [Matrix.map_apply]
unfold lowerForwardContractionMinorPolynomial
split_ifs <;> simp [lowerWeightPolynomial, paramEval,
eval_lowerFirstPolynomial, eval_lowerSlopePolynomial]
theorem lowerReverseMinor_apply
Gives the stated evaluation formula for lower Reverse Minor.
Formal statement
hypotheses
conclusion
lowerReverseMinor m η i j
= if i.1 = 0 then η.2.2 j (m + 2) else if i.1 = 1 then η.2.2 j (m + 3) * (reverseLoading m η.1 η.2.1 j).2 else η.2.2 j (2 * m + 1) * ((m - 1).choose (i.1 - 2) : ℂ) * (reverseLoading m η.1 η.2.1 j).1 ^ (i.1 - 2) * (reverseLoading m η.1 η.2.1 j).2 ^ (m - 1 - (i.1 - 2))
Proof (Lean source)
lemma lowerReverseMinor_apply (m : ℕ) (η : ParamSpace ℂ m)
(i j : Fin (m + 2)) :
lowerReverseMinor m η i j =
if i.1 = 0 then η.2.2 j (m + 2)
else if i.1 = 1 then
η.2.2 j (m + 3) * (reverseLoading m η.1 η.2.1 j).2
else η.2.2 j (2 * m + 1) * ((m - 1).choose (i.1 - 2) : ℂ) *
(reverseLoading m η.1 η.2.1 j).1 ^ (i.1 - 2) *
(reverseLoading m η.1 η.2.1 j).2 ^ (m - 1 - (i.1 - 2)) := by
unfold lowerReverseMinor
rw [Matrix.map_apply]
unfold lowerReverseContractionMinorPolynomial
split_ifs <;> simp [lowerWeightPolynomial, paramEval,
eval_lowerReverseFirstPolynomial, eval_lowerReverseSecondPolynomial]
theorem lowerForwardExplicitRankData
Proves the stated mathematical property of lower Forward Explicit Rank Data.
Formal statement
hypotheses
m :
ℕ
hm :
3 ≤ m
conclusion
(∃ θ₀ : ParamSpace ℂ m, (∀ j r, (r < 2 ∨ 2 * m + 1 < r) → θ₀.2.2 j r = 0) ∧ eval (paramEval θ₀) (lowerForwardComplexRankPolynomial m) ≠ 0) ∧
∀ θ,
≠ 0 → Injective (lowerForwardWeightedContraction m θ)
Proof (Lean source)
theorem lowerForwardExplicitRankData (m : ℕ) (hm : 3 ≤ m) :
lowerForwardComplexRankPolynomial m ≠ 0 ∧
(∃ θ₀ : ParamSpace ℂ m,
(∀ j r, (r < 2 ∨ 2 * m + 1 < r) → θ₀.2.2 j r = 0) ∧
eval (paramEval θ₀) (lowerForwardComplexRankPolynomial m) ≠ 0) ∧
∀ θ, eval (paramEval θ) (lowerForwardComplexRankPolynomial m) ≠ 0 →
Injective (lowerForwardWeightedContraction m θ) := by
refine ⟨?_, ?_, ?_⟩
· intro hz
apply lowerForwardWitness_det_ne_zero m hm
change det ((eval (paramEval (lowerForwardWitness m))).mapMatrix
(lowerForwardContractionMinorPolynomial ℂ m)) = 0
rw [← RingHom.map_det, show (lowerForwardContractionMinorPolynomial ℂ m).det = 0 by
simpa [lowerForwardComplexRankPolynomial] using hz, map_zero]
· refine ⟨lowerForwardWitness m, ?_, ?_⟩
· intro j r hr
simp only [lowerForwardWitness]
rcases hr with hr | hr <;> simp [show r ≠ m + 2 by omega,
show r ≠ m + 3 by omega, show r ≠ 2 * m + 1 by omega]
· rw [lowerForwardComplexRankPolynomial, RingHom.map_det]
change (lowerForwardMinor m (lowerForwardWitness m)).det ≠ 0
exact lowerForwardWitness_det_ne_zero m hm
· intro θ hθ
apply lowerForward_injective_of_det m hm θ
change det ((eval (paramEval θ)).mapMatrix
(lowerForwardContractionMinorPolynomial ℂ m)) ≠ 0
rw [← RingHom.map_det]
simpa [lowerForwardComplexRankPolynomial] using hθ
theorem lowerReverseExplicitRankData
Proves the stated mathematical property of lower Reverse Explicit Rank Data.
Formal statement
hypotheses
m :
ℕ
hm :
3 ≤ m
conclusion
(∃ η₀ : ParamSpace ℂ m, (∀ j r, (r < 2 ∨ 2 * m + 1 < r) → η₀.2.2 j r = 0) ∧ eval (paramEval η₀) (lowerReverseComplexRankPolynomial m) ≠ 0) ∧
∀ η,
≠ 0 → Injective (lowerReverseWeightedContraction m η)
Proof (Lean source)
theorem lowerReverseExplicitRankData (m : ℕ) (hm : 3 ≤ m) :
lowerReverseComplexRankPolynomial m ≠ 0 ∧
(∃ η₀ : ParamSpace ℂ m,
(∀ j r, (r < 2 ∨ 2 * m + 1 < r) → η₀.2.2 j r = 0) ∧
eval (paramEval η₀) (lowerReverseComplexRankPolynomial m) ≠ 0) ∧
∀ η, eval (paramEval η) (lowerReverseComplexRankPolynomial m) ≠ 0 →
Injective (lowerReverseWeightedContraction m η) := by
refine ⟨?_, ?_, ?_⟩
· intro hz
apply lowerReverseWitness_det_ne_zero m hm
change det ((eval (paramEval (lowerReverseWitness m))).mapMatrix
(lowerReverseContractionMinorPolynomial ℂ m)) = 0
rw [← RingHom.map_det, show (lowerReverseContractionMinorPolynomial ℂ m).det = 0 by
simpa [lowerReverseComplexRankPolynomial] using hz, map_zero]
· refine ⟨lowerReverseWitness m, ?_, ?_⟩
· intro j r hr
simp only [lowerReverseWitness]
rcases hr with hr | hr <;> simp [show r ≠ m + 2 by omega,
show r ≠ m + 3 by omega, show r ≠ 2 * m + 1 by omega]
· rw [lowerReverseComplexRankPolynomial, RingHom.map_det]
change (lowerReverseMinor m (lowerReverseWitness m)).det ≠ 0
exact lowerReverseWitness_det_ne_zero m hm
· intro η hη
apply lowerReverse_injective_of_det m hm η
change det ((eval (paramEval η)).mapMatrix
(lowerReverseContractionMinorPolynomial ℂ m)) ≠ 0
rw [← RingHom.map_det]
simpa [lowerReverseComplexRankPolynomial] using hη
theorem lowerForwardRealRankPolynomial_ne_zero
Proves that the quantity called the lower Forward Real Rank Polynomial is nonzero.
Formal statement
Proof (Lean source)
theorem lowerForwardRealRankPolynomial_ne_zero (m : ℕ) (hm : 3 ≤ m) :
lowerForwardRealRankPolynomial m ≠ 0 := by
intro h
exact (lowerForwardExplicitRankData m hm).1
(by rw [← lowerForwardRankPolynomial_map_ofReal, h, map_zero])
theorem lowerReverseRealRankPolynomial_ne_zero
Proves that the quantity called the lower Reverse Real Rank Polynomial is nonzero.
Formal statement
Proof (Lean source)
theorem lowerReverseRealRankPolynomial_ne_zero (m : ℕ) (hm : 3 ≤ m) :
lowerReverseRealRankPolynomial m ≠ 0 := by
intro h
exact (lowerReverseExplicitRankData m hm).1
(by rw [← lowerReverseRankPolynomial_map_ofReal, h, map_zero])
theorem lowerForwardContractionRankWitness
Proves the stated mathematical property of lower Forward Contraction Rank Witness.
Formal statement
hypotheses
m :
ℕ
hm :
3 ≤ m
conclusion
∃ P : MvPolynomial (ParamCoord m) ℂ
if
P ≠ 0 ∧
(∃ θ₀ : ParamSpace ℂ m, (∀ j r, (r < 2 ∨ 2 * m + 1 < r) → θ₀.2.2 j r = 0) ∧ eval (paramEval θ₀) P ≠ 0) ∧
then
Proof (Lean source)
theorem lowerForwardContractionRankWitness (m : ℕ) (hm : 3 ≤ m) :
∃ P : MvPolynomial (ParamCoord m) ℂ, P ≠ 0 ∧
(∃ θ₀ : ParamSpace ℂ m,
(∀ j r, (r < 2 ∨ 2 * m + 1 < r) → θ₀.2.2 j r = 0) ∧
eval (paramEval θ₀) P ≠ 0) ∧
∀ θ, eval (paramEval θ) P ≠ 0 →
Injective (lowerForwardWeightedContraction m θ) := by
let P := lowerForwardComplexRankPolynomial m
refine ⟨P, ?_, ?_, ?_⟩
· intro hz
dsimp [P, lowerForwardComplexRankPolynomial] at hz
apply lowerForwardWitness_det_ne_zero m hm
change det ((eval (paramEval (lowerForwardWitness m))).mapMatrix
(lowerForwardContractionMinorPolynomial ℂ m)) = 0
rw [← RingHom.map_det, hz, map_zero]
· refine ⟨lowerForwardWitness m, ?_, ?_⟩
· intro j r hr
simp only [lowerForwardWitness]
rcases hr with hr | hr <;> simp [show r ≠ m + 2 by omega,
show r ≠ m + 3 by omega, show r ≠ 2 * m + 1 by omega]
· dsimp [P, lowerForwardComplexRankPolynomial]
rw [RingHom.map_det]
change (lowerForwardMinor m (lowerForwardWitness m)).det ≠ 0
exact lowerForwardWitness_det_ne_zero m hm
· intro θ hθ
apply lowerForward_injective_of_det m hm θ
change det ((eval (paramEval θ)).mapMatrix
(lowerForwardContractionMinorPolynomial ℂ m)) ≠ 0
rw [← RingHom.map_det]
exact hθ
theorem lowerReverseContractionRankWitness
Proves the stated mathematical property of lower Reverse Contraction Rank Witness.
Formal statement
hypotheses
m :
ℕ
hm :
3 ≤ m
conclusion
∃ P : MvPolynomial (ParamCoord m) ℂ
if
P ≠ 0 ∧
(∃ η₀ : ParamSpace ℂ m, (∀ j r, (r < 2 ∨ 2 * m + 1 < r) → η₀.2.2 j r = 0) ∧ eval (paramEval η₀) P ≠ 0) ∧
then
Proof (Lean source)
theorem lowerReverseContractionRankWitness (m : ℕ) (hm : 3 ≤ m) :
∃ P : MvPolynomial (ParamCoord m) ℂ, P ≠ 0 ∧
(∃ η₀ : ParamSpace ℂ m,
(∀ j r, (r < 2 ∨ 2 * m + 1 < r) → η₀.2.2 j r = 0) ∧
eval (paramEval η₀) P ≠ 0) ∧
∀ η, eval (paramEval η) P ≠ 0 →
Injective (lowerReverseWeightedContraction m η) := by
let P := lowerReverseComplexRankPolynomial m
refine ⟨P, ?_, ?_, ?_⟩
· intro hz
dsimp [P, lowerReverseComplexRankPolynomial] at hz
apply lowerReverseWitness_det_ne_zero m hm
change det ((eval (paramEval (lowerReverseWitness m))).mapMatrix
(lowerReverseContractionMinorPolynomial ℂ m)) = 0
rw [← RingHom.map_det, hz, map_zero]
· refine ⟨lowerReverseWitness m, ?_, ?_⟩
· intro j r hr
simp only [lowerReverseWitness]
rcases hr with hr | hr <;> simp [show r ≠ m + 2 by omega,
show r ≠ m + 3 by omega, show r ≠ 2 * m + 1 by omega]
· dsimp [P, lowerReverseComplexRankPolynomial]
rw [RingHom.map_det]
change (lowerReverseMinor m (lowerReverseWitness m)).det ≠ 0
exact lowerReverseWitness_det_ne_zero m hm
· intro η hη
apply lowerReverse_injective_of_det m hm η
change det ((eval (paramEval η)).mapMatrix
(lowerReverseContractionMinorPolynomial ℂ m)) ≠ 0
rw [← RingHom.map_det]
exact hη
Helpers.LowerOrderApolarSeparation 15 declarations
Defines the polynomial called the lower Slope Product Polynomial.
Definition (Lean source)
def lowerSlopeProductPolynomial (R : Type*) [CommRing R] (m : ℕ) :
MvPolynomial (ParamCoord m) R :=
∏ i : Fin m, X (inr (inl i))
def lowerForwardRealExceptionalPolynomial Definition lowerForwardRealExceptionalPolynomial in the paper ↗
Defines the polynomial called the lower Forward Real Exceptional Polynomial.
Definition (Lean source)
def lowerForwardRealExceptionalPolynomial (m : ℕ) :
MvPolynomial (RealParamCoord m) ℝ :=
lowerSlopeProductPolynomial ℝ m * lowerForwardRealRankPolynomial m
def lowerReverseRealExceptionalPolynomial Definition lowerReverseRealExceptionalPolynomial in the paper ↗
Defines the polynomial called the lower Reverse Real Exceptional Polynomial.
Definition (Lean source)
def lowerReverseRealExceptionalPolynomial (m : ℕ) :
MvPolynomial (RealParamCoord m) ℝ :=
lowerSlopeProductPolynomial ℝ m * lowerReverseRealRankPolynomial m
def lowerForwardComplexExceptionalPolynomial Definition lowerForwardComplexExceptionalPolynomial in the paper ↗
Defines the polynomial called the lower Forward Complex Exceptional Polynomial.
Definition (Lean source)
def lowerForwardComplexExceptionalPolynomial (m : ℕ) :
MvPolynomial (ParamCoord m) ℂ :=
lowerSlopeProductPolynomial ℂ m * lowerForwardComplexRankPolynomial m
def lowerReverseComplexExceptionalPolynomial Definition lowerReverseComplexExceptionalPolynomial in the paper ↗
Defines the polynomial called the lower Reverse Complex Exceptional Polynomial.
Definition (Lean source)
def lowerReverseComplexExceptionalPolynomial (m : ℕ) :
MvPolynomial (ParamCoord m) ℂ :=
lowerSlopeProductPolynomial ℂ m * lowerReverseComplexRankPolynomial m
theorem lowerSlopeProductPolynomial_ne_zero
Proves that the quantity called the lower Slope Product Polynomial is nonzero.
Formal statement
Proof (Lean source)
lemma lowerSlopeProductPolynomial_ne_zero (R : Type*) [CommRing R] [IsDomain R] (m : ℕ) :
lowerSlopeProductPolynomial R m ≠ 0 := by
rw [lowerSlopeProductPolynomial]
exact Finset.prod_ne_zero_iff.mpr
(fun i _ => MvPolynomial.X_ne_zero (inr (inl i)))
theorem lowerForwardRealExceptionalPolynomial_ne_zero
Proves that the quantity called the lower Forward Real Exceptional Polynomial is nonzero.
Formal statement
Proof (Lean source)
lemma lowerForwardRealExceptionalPolynomial_ne_zero (m : ℕ) (hm : 3 ≤ m) :
lowerForwardRealExceptionalPolynomial m ≠ 0 := by
exact mul_ne_zero (lowerSlopeProductPolynomial_ne_zero ℝ m)
(lowerForwardRealRankPolynomial_ne_zero m hm)
theorem lowerReverseRealExceptionalPolynomial_ne_zero
Proves that the quantity called the lower Reverse Real Exceptional Polynomial is nonzero.
Formal statement
Proof (Lean source)
lemma lowerReverseRealExceptionalPolynomial_ne_zero (m : ℕ) (hm : 3 ≤ m) :
lowerReverseRealExceptionalPolynomial m ≠ 0 := by
exact mul_ne_zero (lowerSlopeProductPolynomial_ne_zero ℝ m)
(lowerReverseRealRankPolynomial_ne_zero m hm)
theorem lowerForwardExceptional_eval_complexify
Gives the stated evaluation formula for lower Forward Exceptional complexify.
Formal statement
Proof (Lean source)
lemma lowerForwardExceptional_eval_complexify (m : ℕ) (θ : ParamSpace ℝ m) :
eval (paramEval (complexifyParam θ))
(lowerForwardComplexExceptionalPolynomial m) =
(eval (realParamEval θ)
(lowerForwardRealExceptionalPolynomial m) : ℂ) := by
rw [lowerForwardComplexExceptionalPolynomial, lowerForwardRealExceptionalPolynomial,
MvPolynomial.eval_mul, MvPolynomial.eval_mul,
lowerForwardRankPolynomial_eval_complexify]
simp [lowerSlopeProductPolynomial, paramEval, realParamEval, complexifyParam]
theorem lowerReverseExceptional_eval_complexify
Gives the stated evaluation formula for lower Reverse Exceptional complexify.
Formal statement
Proof (Lean source)
lemma lowerReverseExceptional_eval_complexify (m : ℕ) (η : ParamSpace ℝ m) :
eval (paramEval (complexifyParam η))
(lowerReverseComplexExceptionalPolynomial m) =
(eval (realParamEval η)
(lowerReverseRealExceptionalPolynomial m) : ℂ) := by
rw [lowerReverseComplexExceptionalPolynomial, lowerReverseRealExceptionalPolynomial,
MvPolynomial.eval_mul, MvPolynomial.eval_mul,
lowerReverseRankPolynomial_eval_complexify]
simp [lowerSlopeProductPolynomial, paramEval, realParamEval, complexifyParam]
theorem forwardSlopesInjective_of_realFeasible
Proves the stated mathematical property of forward Slopes Injective of real Feasible.
Formal statement
hypotheses
conclusion
Injective (fun j : Fin (m + 1) => (forwardLoading m (complexifyParam θ).1 (complexifyParam θ).2.1 j.castSucc).2)
Proof (Lean source)
lemma forwardSlopesInjective_of_realFeasible {m L : ℕ} (θ : ParamSpace ℝ m)
(hθ : θ ∈ realFeasibleRegion m L) :
Injective (fun j : Fin (m + 1) =>
(forwardLoading m (complexifyParam θ).1 (complexifyParam θ).2.1 j.castSucc).2) := by
have hγρ : ∀ k : Fin m, θ.1 ≠ θ.2.1 k := by
intro k heq
have hv : (Fin.cons θ.1 θ.2.1 : Fin (m + 1) → ℝ) 0 =
(Fin.cons θ.1 θ.2.1 : Fin (m + 1) → ℝ) k.succ := by
simpa only [Fin.cons_zero, Fin.cons_succ] using heq
have he : (0 : Fin (m + 1)) = k.succ := hθ.2.1 hv
have := congrArg Fin.val he
simp at this
have hρ : Injective θ.2.1 := by
intro k l heq
have hv : (Fin.cons θ.1 θ.2.1 : Fin (m + 1) → ℝ) k.succ =
(Fin.cons θ.1 θ.2.1 : Fin (m + 1) → ℝ) l.succ := by
simpa only [Fin.cons_succ] using heq
have he := hθ.2.1 hv
exact Fin.ext (by simpa using congrArg Fin.val he)
intro i
refine Fin.cases ?_ (fun k => ?_) i
· intro j h
refine Fin.cases (fun _ => rfl) (fun l h' => ?_) j h
have hl : l.val ≠ m := Nat.ne_of_lt l.isLt
exact ((hγρ l)
(by simpa [forwardLoading, complexifyParam, hl] using h')).elim
· intro j h
have hk : k.val ≠ m := Nat.ne_of_lt k.isLt
refine Fin.cases (fun h' => ?_) (fun l h' => ?_) j h
· exact ((hγρ k)
(by simpa [forwardLoading, complexifyParam, hk] using h'.symm)).elim
· have hl : l.val ≠ m := Nat.ne_of_lt l.isLt
exact congrArg succ (hρ
(by simpa [forwardLoading, complexifyParam, hk, hl] using h'))
theorem reverseSlopesInjective_of_realFeasible
Proves the stated mathematical property of reverse Slopes Injective of real Feasible.
Formal statement
hypotheses
conclusion
Injective (fun j : Fin (m + 1) => (reverseLoading m (complexifyParam η).1 (complexifyParam η).2.1 j.succ).1)
Proof (Lean source)
lemma reverseSlopesInjective_of_realFeasible {m L : ℕ} (η : ParamSpace ℝ m)
(hη : η ∈ realFeasibleRegion m L) :
Injective (fun j : Fin (m + 1) =>
(reverseLoading m (complexifyParam η).1 (complexifyParam η).2.1 j.succ).1) := by
have hδσ : ∀ k : Fin m, η.1 ≠ η.2.1 k := by
intro k heq
have hv : (Fin.cons η.1 η.2.1 : Fin (m + 1) → ℝ) 0 =
(Fin.cons η.1 η.2.1 : Fin (m + 1) → ℝ) k.succ := by
simpa only [Fin.cons_zero, Fin.cons_succ] using heq
have he : (0 : Fin (m + 1)) = k.succ := hη.2.1 hv
have := congrArg Fin.val he
simp at this
have hσ : Injective η.2.1 := by
intro k l heq
have hv : (Fin.cons η.1 η.2.1 : Fin (m + 1) → ℝ) k.succ =
(Fin.cons η.1 η.2.1 : Fin (m + 1) → ℝ) l.succ := by
simpa only [Fin.cons_succ] using heq
have he := hη.2.1 hv
exact Fin.ext (by simpa using congrArg Fin.val he)
intro i
refine Fin.lastCases ?_ (fun k => ?_) i
· intro j h
refine Fin.lastCases (fun _ => rfl) (fun l h' => ?_) j h
have hl : l.val ≠ m := Nat.ne_of_lt l.isLt
exact ((hδσ l) (by simpa [reverseLoading, complexifyParam, hl] using h')).elim
· intro j h
have hk : k.val ≠ m := Nat.ne_of_lt k.isLt
refine Fin.lastCases (fun h' => ?_) (fun l h' => ?_) j h
· exact ((hδσ k)
(by simpa [reverseLoading, complexifyParam, hk] using h'.symm)).elim
· have hl : l.val ≠ m := Nat.ne_of_lt l.isLt
exact congrArg castSucc (hσ
(by simpa [reverseLoading, complexifyParam, hk, hl] using h'))
theorem forwardCumulantMap_complexify
Proves the stated compatibility of forward Cumulant Map with complexification.
Formal statement
hypotheses
m L :
ℕ
θ :
ParamSpace ℝ m
conclusion
forwardCumulantMap m L (complexifyParam θ)
= fun r a => ((forwardCumulantMap m L θ r a : ℝ) : ℂ)
Proof (Lean source)
lemma forwardCumulantMap_complexify {m L : ℕ} (θ : ParamSpace ℝ m) :
forwardCumulantMap m L (complexifyParam θ) =
fun r a => ((forwardCumulantMap m L θ r a : ℝ) : ℂ) := by
funext r a
unfold forwardCumulantMap
split_ifs with h
· change (∑ j : Fin (m + 2),
(complexifyParam θ).2.2 j r *
(forwardLoading m (complexifyParam θ).1
(complexifyParam θ).2.1 j).1 ^ (r - a) *
(forwardLoading m (complexifyParam θ).1
(complexifyParam θ).2.1 j).2 ^ a) =
ofRealHom (∑ j : Fin (m + 2),
θ.2.2 j r * (forwardLoading m θ.1 θ.2.1 j).1 ^ (r - a) *
(forwardLoading m θ.1 θ.2.1 j).2 ^ a)
rw [map_sum]
apply Finset.sum_congr rfl
intro j _
by_cases hj0 : j = 0
· subst j
simp [complexifyParam, forwardLoading]
by_cases hjlast : j.val = m + 1
· simp [complexifyParam, forwardLoading, hjlast]
· simp [complexifyParam, forwardLoading, hj0, hjlast]
· simp
theorem reverseCumulantMap_complexify
Proves the stated compatibility of reverse Cumulant Map with complexification.
Formal statement
hypotheses
m L :
ℕ
η :
ParamSpace ℝ m
conclusion
reverseCumulantMap m L (complexifyParam η)
= fun r a => ((reverseCumulantMap m L η r a : ℝ) : ℂ)
Proof (Lean source)
lemma reverseCumulantMap_complexify {m L : ℕ} (η : ParamSpace ℝ m) :
reverseCumulantMap m L (complexifyParam η) =
fun r a => ((reverseCumulantMap m L η r a : ℝ) : ℂ) := by
funext r a
unfold reverseCumulantMap
split_ifs with h
· change (∑ j : Fin (m + 2),
(complexifyParam η).2.2 j r *
(reverseLoading m (complexifyParam η).1
(complexifyParam η).2.1 j).1 ^ (r - a) *
(reverseLoading m (complexifyParam η).1
(complexifyParam η).2.1 j).2 ^ a) =
ofRealHom (∑ j : Fin (m + 2),
η.2.2 j r * (reverseLoading m η.1 η.2.1 j).1 ^ (r - a) *
(reverseLoading m η.1 η.2.1 j).2 ^ a)
rw [map_sum]
apply Finset.sum_congr rfl
intro j _
by_cases hj0 : j = 0
· subst j
simp [complexifyParam, reverseLoading]
by_cases hjlast : j.val = m + 1
· simp [complexifyParam, reverseLoading, hjlast]
· simp [complexifyParam, reverseLoading, hj0, hjlast]
· simp
theorem lowerOrderApolarSeparation
At m ≥ 3, the complete cumulant truncation through order 2m+1 generically separates the two real arrows.
Formal statement
Proof (Lean source)
theorem lowerOrderApolarSeparation (m : ℕ) (hm : 3 ≤ m) :
separatesAtOrder m (2 * m + 1) := by
have hgate : TruncatedMomentInterior (2 * m + 1) :=
truncatedMomentInterior (2 * m + 1)
obtain ⟨hPf_ne, ⟨θf0, hθf0_pin, hθf0_ne⟩, hPf_inj⟩ :=
lowerForwardExplicitRankData m hm
obtain ⟨hPr_ne, ⟨θr0, hθr0_pin, hθr0_ne⟩, hPr_inj⟩ :=
lowerReverseExplicitRankData m hm
let ρprod : MvPolynomial (ParamCoord m) ℂ := lowerSlopeProductPolynomial ℂ m
let Rf := lowerForwardComplexExceptionalPolynomial m
let Rr := lowerReverseComplexExceptionalPolynomial m
have hpinρ : pinSubst m (2 * m + 1) ρprod ≠ 0 := by
dsimp [ρprod, lowerSlopeProductPolynomial]
rw [map_prod]
exact Finset.prod_ne_zero_iff.mpr (fun i _ => by
rw [pinSubst_X_slope]
exact MvPolynomial.X_ne_zero _)
have hpinRf : pinSubst m (2 * m + 1) Rf ≠ 0 := by
dsimp [Rf, lowerForwardComplexExceptionalPolynomial]
rw [map_mul]
exact mul_ne_zero hpinρ
(pinSubst_ne_zero_of_pinned_witness
(lowerForwardComplexRankPolynomial m) θf0 hθf0_pin hθf0_ne)
have hpinRr : pinSubst m (2 * m + 1) Rr ≠ 0 := by
dsimp [Rr, lowerReverseComplexExceptionalPolynomial]
rw [map_mul]
exact mul_ne_zero hpinρ
(pinSubst_ne_zero_of_pinned_witness
(lowerReverseComplexRankPolynomial m) θr0 hθr0_pin hθr0_ne)
constructor
· let excl : Set (ParamSpace ℝ m) :=
{θ | eval (realParamEval θ)
(lowerForwardRealExceptionalPolynomial m) = 0}
refine ⟨excl, ?_, ?_, ?_⟩
· exact ⟨lowerForwardRealExceptionalPolynomial m,
lowerForwardRealExceptionalPolynomial_ne_zero m hm, rfl⟩
· obtain ⟨θ, hθfeas, hθR⟩ := exists_feasible_nonvanishing hgate Rf hpinRf
refine ⟨θ, hθfeas, ?_⟩
change eval (realParamEval θ)
(lowerForwardRealExceptionalPolynomial m) ≠ 0
intro hz
apply hθR
dsimp [Rf]
rw [lowerForwardExceptional_eval_complexify, hz]
simp
· intro θ hθfeas hθout
change eval (realParamEval θ)
(lowerForwardRealExceptionalPolynomial m) ≠ 0 at hθout
have hθR : eval (paramEval (complexifyParam θ)) Rf ≠ 0 := by
dsimp [Rf]
rw [lowerForwardExceptional_eval_complexify]
exact Complex.ofReal_ne_zero.mpr hθout
have hparts :
eval (paramEval (complexifyParam θ)) ρprod ≠ 0 ∧
eval (paramEval (complexifyParam θ))
(lowerForwardComplexRankPolynomial m) ≠ 0 := by
dsimp [Rf, lowerForwardComplexExceptionalPolynomial] at hθR
rw [MvPolynomial.eval_mul] at hθR
exact mul_ne_zero_iff.mp hθR
have hρ : ∀ i, (complexifyParam θ).2.1 i ≠ 0 := by
have hp : (∏ i : Fin m, (complexifyParam θ).2.1 i) ≠ 0 := by
simpa [ρprod, lowerSlopeProductPolynomial, paramEval] using hparts.1
exact fun i => (Finset.prod_ne_zero_iff.mp hp) i (Finset.mem_univ i)
have hγ : (complexifyParam θ).1 ≠ 0 := by
simpa [complexifyParam] using Complex.ofReal_ne_zero.mpr hθfeas.1
have hslopes := forwardSlopesInjective_of_realFeasible θ hθfeas
have hnonzero : ∀ j : Fin (m + 1),
(forwardLoading m (complexifyParam θ).1
(complexifyParam θ).2.1 j.castSucc).2 ≠ 0 := by
intro j
refine Fin.cases ?_ (fun i => ?_) j
· simpa [forwardLoading] using hγ
· have hi : i.val ≠ m := Nat.ne_of_lt i.isLt
simpa [forwardLoading, hi] using hρ i
have hrank := hPf_inj (complexifyParam θ) hparts.2
intro hex
obtain ⟨η, _hηfeas, heq⟩ := hex
apply lowerForwardReverseImpossible m hm (complexifyParam θ)
hslopes hγ hρ hnonzero hrank (complexifyParam η)
rw [forwardCumulantMap_complexify, reverseCumulantMap_complexify]
exact congrArg (fun t : CumVec ℝ => fun r a => (t r a : ℂ)) heq
· let excl : Set (ParamSpace ℝ m) :=
{η | eval (realParamEval η)
(lowerReverseRealExceptionalPolynomial m) = 0}
refine ⟨excl, ?_, ?_, ?_⟩
· exact ⟨lowerReverseRealExceptionalPolynomial m,
lowerReverseRealExceptionalPolynomial_ne_zero m hm, rfl⟩
· obtain ⟨η, hηfeas, hηR⟩ := exists_feasible_nonvanishing hgate Rr hpinRr
refine ⟨η, hηfeas, ?_⟩
change eval (realParamEval η)
(lowerReverseRealExceptionalPolynomial m) ≠ 0
intro hz
apply hηR
dsimp [Rr]
rw [lowerReverseExceptional_eval_complexify, hz]
simp
· intro η hηfeas hηout
change eval (realParamEval η)
(lowerReverseRealExceptionalPolynomial m) ≠ 0 at hηout
have hηR : eval (paramEval (complexifyParam η)) Rr ≠ 0 := by
dsimp [Rr]
rw [lowerReverseExceptional_eval_complexify]
exact Complex.ofReal_ne_zero.mpr hηout
have hparts :
eval (paramEval (complexifyParam η)) ρprod ≠ 0 ∧
eval (paramEval (complexifyParam η))
(lowerReverseComplexRankPolynomial m) ≠ 0 := by
dsimp [Rr, lowerReverseComplexExceptionalPolynomial] at hηR
rw [MvPolynomial.eval_mul] at hηR
exact mul_ne_zero_iff.mp hηR
have hσ : ∀ i, (complexifyParam η).2.1 i ≠ 0 := by
have hp : (∏ i : Fin m, (complexifyParam η).2.1 i) ≠ 0 := by
simpa [ρprod, lowerSlopeProductPolynomial, paramEval] using hparts.1
exact fun i => (Finset.prod_ne_zero_iff.mp hp) i (Finset.mem_univ i)
have hδ : (complexifyParam η).1 ≠ 0 := by
simpa [complexifyParam] using Complex.ofReal_ne_zero.mpr hηfeas.1
have hslopes := reverseSlopesInjective_of_realFeasible η hηfeas
have hnonzero : ∀ j : Fin (m + 1),
(reverseLoading m (complexifyParam η).1
(complexifyParam η).2.1 j.succ).1 ≠ 0 := by
intro j
refine Fin.lastCases ?_ (fun i => ?_) j
· simpa [reverseLoading] using hδ
· have hi : i.val ≠ m := Nat.ne_of_lt i.isLt
simpa [reverseLoading, hi] using hσ i
have hrank := hPr_inj (complexifyParam η) hparts.2
intro hex
obtain ⟨θ, _hθfeas, heq⟩ := hex
apply lowerReverseForwardImpossible m hm (complexifyParam η)
hslopes hδ hσ hnonzero hrank (complexifyParam θ)
rw [reverseCumulantMap_complexify, forwardCumulantMap_complexify]
exact congrArg (fun t : CumVec ℝ => fun r a => (t r a : ℂ)) heq
Helpers.LowerOrderEmptyFiber 2 declarations
theorem lowerForwardReverseImpossible
Proves the stated mathematical property of lower Forward Reverse Impossible.
Formal statement
hypotheses
m :
ℕ
hm :
3 ≤ m
θ :
ParamSpace ℂ m
hslopes :
hγ :
θ.1 ≠ 0
hρ :
∀ i, θ.2.1 i ≠ 0
hnonzero :
∀ j : Fin (m + 1), (forwardLoading m θ.1 θ.2.1 j.castSucc).2 ≠ 0
hrank :
conclusion
∀ η : ParamSpace ℂ m,
forwardCumulantMap m (2 * m + 1) θ ≠ reverseCumulantMap m (2 * m + 1) η
Proof (Lean source)
theorem lowerForwardReverseImpossible (m : ℕ) (hm : 3 ≤ m) (θ : ParamSpace ℂ m)
(hslopes : Injective
(fun j : Fin (m + 1) => (forwardLoading m θ.1 θ.2.1 j.castSucc).2))
(hγ : θ.1 ≠ 0) (hρ : ∀ i, θ.2.1 i ≠ 0)
(hnonzero : ∀ j : Fin (m + 1),
(forwardLoading m θ.1 θ.2.1 j.castSucc).2 ≠ 0)
(hrank : Injective (lowerForwardWeightedContraction m θ)) :
∀ η : ParamSpace ℂ m,
forwardCumulantMap m (2 * m + 1) θ ≠ reverseCumulantMap m (2 * m + 1) η := by
intro η heq
let Qr := supportAnnihilator (reverseLoading m η.1 η.2.1)
let Qf := supportAnnihilator (forwardLoading m θ.1 θ.2.1)
have hQrHom : Qr.IsHomogeneous (m + 2) := supportAnnihilator_isHomogeneous _
have hQrRev : ∀ k, k ≤ m - 1 → diffApply Qr
(dividedPowerBlock (reverseCumulantMap m (2 * m + 1) η) (m + 2 + k)) = 0 :=
lowerReverseSupportAnnihilatorInKernel m hm η Qr hQrHom ⟨1, by simp [Qr]⟩
have hQrFwd : ∀ k, k ≤ m - 1 → diffApply Qr
(dividedPowerBlock (forwardCumulantMap m (2 * m + 1) θ) (m + 2 + k)) = 0 := by
simpa [heq] using hQrRev
obtain ⟨c, hc⟩ :=
(lowerForwardApolarKernelIdentity m hm θ hslopes hnonzero hrank Qr hQrHom).mp hQrFwd
have hdivQr : X (1 : Fin 2) ∣ Qr := by
simpa [Qr] using X1_dvd_supportAnnihilator_reverse η.1 η.2.1
have hnDivQf : ¬ X (1 : Fin 2) ∣ Qf := by
simpa [Qf] using not_X1_dvd_supportAnnihilator_forward θ.1 θ.2.1 hγ hρ
have hQrNe : Qr ≠ 0 := by
apply supportAnnihilator_ne_zero (reverseLoading m η.1 η.2.1)
intro j
by_cases hj0 : j.val = 0
· left
simp [reverseLoading, hj0]
· right
simp only [reverseLoading, hj0, ↓reduceDIte]
split <;> simp
by_cases hc0 : c = 0
· apply hQrNe
rw [hc, hc0]
simp
· apply hnDivQf
obtain ⟨p, hp⟩ := hdivQr
refine ⟨MvPolynomial.C c⁻¹ * p, ?_⟩
rw [hc] at hp
simp only [MvPolynomial.smul_eq_C_mul] at hp
calc
Qf = C c⁻¹ * (C c * Qf) := by
rw [← mul_assoc, ← MvPolynomial.C_mul, inv_mul_cancel₀ hc0, map_one, one_mul]
_ = C c⁻¹ * (X (1 : Fin 2) * p) := by rw [← hp]
_ = X (1 : Fin 2) * (C c⁻¹ * p) := by ring
theorem lowerReverseForwardImpossible
Proves the stated mathematical property of lower Reverse Forward Impossible.
Formal statement
hypotheses
m :
ℕ
hm :
3 ≤ m
η :
ParamSpace ℂ m
hslopes :
hδ :
η.1 ≠ 0
hσ :
∀ i, η.2.1 i ≠ 0
hnonzero :
∀ j : Fin (m + 1), (reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0
hrank :
conclusion
∀ θ : ParamSpace ℂ m,
reverseCumulantMap m (2 * m + 1) η ≠ forwardCumulantMap m (2 * m + 1) θ
Proof (Lean source)
theorem lowerReverseForwardImpossible (m : ℕ) (hm : 3 ≤ m) (η : ParamSpace ℂ m)
(hslopes : Injective
(fun j : Fin (m + 1) => (reverseLoading m η.1 η.2.1 j.succ).1))
(hδ : η.1 ≠ 0) (hσ : ∀ i, η.2.1 i ≠ 0)
(hnonzero : ∀ j : Fin (m + 1), (reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0)
(hrank : Injective (lowerReverseWeightedContraction m η)) :
∀ θ : ParamSpace ℂ m,
reverseCumulantMap m (2 * m + 1) η ≠ forwardCumulantMap m (2 * m + 1) θ := by
intro θ heq
let Qf := supportAnnihilator (forwardLoading m θ.1 θ.2.1)
let Qr := supportAnnihilator (reverseLoading m η.1 η.2.1)
have hQfHom : Qf.IsHomogeneous (m + 2) := supportAnnihilator_isHomogeneous _
have hQfFwd : ∀ k, k ≤ m - 1 → diffApply Qf
(dividedPowerBlock (forwardCumulantMap m (2 * m + 1) θ) (m + 2 + k)) = 0 :=
lowerForwardSupportAnnihilatorInKernel m hm θ Qf hQfHom ⟨1, by simp [Qf]⟩
have hQfRev : ∀ k, k ≤ m - 1 → diffApply Qf
(dividedPowerBlock (reverseCumulantMap m (2 * m + 1) η) (m + 2 + k)) = 0 := by
simpa [heq] using hQfFwd
obtain ⟨c, hc⟩ :=
(lowerReverseApolarKernelIdentity m hm η hslopes hnonzero hrank Qf hQfHom).mp hQfRev
have hdivQf : X (0 : Fin 2) ∣ Qf := by
simpa [Qf] using X0_dvd_supportAnnihilator_forward θ.1 θ.2.1
have hnDivQr : ¬ X (0 : Fin 2) ∣ Qr := by
simpa [Qr] using not_X0_dvd_supportAnnihilator_reverse η.1 η.2.1 hδ hσ
have hQfNe : Qf ≠ 0 := by
apply supportAnnihilator_ne_zero (forwardLoading m θ.1 θ.2.1)
intro j
by_cases hjlast : j.val = m + 1
· right
simp [forwardLoading, hjlast]
· left
simp only [forwardLoading]
split <;> simp_all
by_cases hc0 : c = 0
· apply hQfNe
rw [hc, hc0]
simp
· apply hnDivQr
obtain ⟨p, hp⟩ := hdivQf
refine ⟨MvPolynomial.C c⁻¹ * p, ?_⟩
rw [hc] at hp
simp only [MvPolynomial.smul_eq_C_mul] at hp
calc
Qr = C c⁻¹ * (C c * Qr) := by
rw [← mul_assoc, ← MvPolynomial.C_mul, inv_mul_cancel₀ hc0, map_one, one_mul]
_ = C c⁻¹ * (X (0 : Fin 2) * p) := by rw [← hp]
_ = X (0 : Fin 2) * (C c⁻¹ * p) := by ring
Helpers.MomentGate 3 declarations
theorem isOpen_realNonvanishingLocus
The real parameter points at which a fixed complex polynomial does not vanish after complexification form a Euclidean-open set.
Formal statement
Proof (Lean source)
lemma isOpen_realNonvanishingLocus {m : ℕ}
(P : MvPolynomial (ParamCoord m) ℂ) :
IsOpen {θ : ParamSpace ℝ m |
eval (paramEval (complexifyParam θ)) P ≠ 0} := by
have hcoord : Continuous (fun θ : ParamSpace ℝ m =>
paramEval (complexifyParam θ)) := by
apply continuous_pi
intro i
rcases i with _ | i
· exact Complex.continuous_ofReal.comp continuous_fst
rcases i with i | jr
· exact Complex.continuous_ofReal.comp
((continuous_apply i).comp continuous_snd.fst)
· exact Complex.continuous_ofReal.comp
((continuous_apply jr.2).comp
((continuous_apply jr.1).comp continuous_snd.snd))
have heval : Continuous (fun θ : ParamSpace ℝ m =>
eval (paramEval (complexifyParam θ)) P) :=
P.continuous_eval.comp hcoord
exact isOpen_compl_singleton.preimage heval
theorem pinSubst_genericParameterPolynomial_ne_zero
The generic-parameter polynomial stays nonzero after pinning: it is witnessed at the pinned parameter point whose direct slope is one, whose latent slopes are 2, 3, …, m+1, and whose in-band weights are all one.
Formal statement
Proof (Lean source)
lemma pinSubst_genericParameterPolynomial_ne_zero (m L : ℕ) :
pinSubst m L (genericParameterPolynomial m L) ≠ 0 := by
let θG : ParamSpace ℂ m :=
(1, (fun i => ((i.val + 2 : ℕ) : ℂ)),
fun _ r => if 2 ≤ r ∧ r ≤ L then 1 else 0)
apply pinSubst_ne_zero_of_pinned_witness (genericParameterPolynomial m L) θG
· intro j r hout
simp only [θG]
split_ifs with hir
· omega
· rfl
· change eval (paramEval θG)
(genericParameterPolynomial m L) ≠ 0
rw [eval_genericParameterPolynomial]
apply mul_ne_zero
· apply mul_ne_zero
· apply mul_ne_zero
· norm_num [θG]
· rw [Finset.prod_ne_zero_iff]
intro i hi
apply sub_ne_zero.mpr
intro heq
change (1 : ℂ) = ((i.val + 2 : ℕ) : ℂ) at heq
have : (1 : ℕ) = i.val + 2 := by exact_mod_cast heq
omega
· rw [Finset.prod_ne_zero_iff]
intro i hi
rw [Finset.prod_ne_zero_iff]
intro i' hi'
by_cases hii : i < i'
· simp only [hii, if_true]
apply sub_ne_zero.mpr
intro heq
change ((i.val + 2 : ℕ) : ℂ) = ((i'.val + 2 : ℕ) : ℂ) at heq
have : i.val + 2 = i'.val + 2 := by exact_mod_cast heq
omega
· simp [hii]
· rw [Finset.prod_ne_zero_iff]
intro j hj
rw [Finset.prod_ne_zero_iff]
intro r hr
have hr' : 2 ≤ r ∧ r ≤ L := Finset.mem_Icc.mp hr
simp [θG, hr']
theorem exists_feasible_nonvanishing
If the truncated-moment interior gate holds, every polynomial whose pinned form is nonzero has a nonvanishing point in the real feasible parameter region.
Formal statement
hypotheses
conclusion
(realFeasibleRegion m L ∩ {θ : ParamSpace ℝ m | eval (paramEval (complexifyParam θ)) P ≠ 0}).Nonempty
Proof (Lean source)
theorem exists_feasible_nonvanishing {m L : ℕ}
(hgate : TruncatedMomentInterior L)
(P : MvPolynomial (ParamCoord m) ℂ) (hP : pinSubst m L P ≠ 0) :
(realFeasibleRegion m L ∩
{θ : ParamSpace ℝ m |
eval (paramEval (complexifyParam θ)) P ≠ 0}).Nonempty := by
obtain ⟨c, ε, hε, hrealize⟩ := hgate
let G := genericParameterPolynomial m L
let Q := P * G
have hpinG : pinSubst m L G ≠ 0 := pinSubst_genericParameterPolynomial_ne_zero m L
have hpinQ : pinSubst m L Q ≠ 0 := by
change pinSubst m L (P * G) ≠ 0
rw [map_mul]
exact mul_ne_zero hP hpinG
let s : ParamCoord m → Set ℂ
| inl _ => Set.range Complex.ofReal
| inr (inl _) => Set.range Complex.ofReal
| inr (inr (_, r)) =>
if 2 ≤ r ∧ r ≤ L then
(fun x : ℝ => (x : ℂ)) '' Ioo (c r - ε) (c r + ε)
else Set.range Complex.ofReal
have hs : ∀ i, (s i).Infinite := by
intro i
rcases i with _ | i
· exact Set.infinite_range_of_injective Complex.ofReal_injective
rcases i with i | jr
· exact Set.infinite_range_of_injective Complex.ofReal_injective
· by_cases hir : 2 ≤ jr.2 ∧ jr.2 ≤ L
· simp only [s, hir]
apply (Set.Ioo_infinite (by linarith : c jr.2 - ε < c jr.2 + ε)).image
exact Complex.ofReal_injective.injOn
· simp only [s, hir, if_false]
exact Set.infinite_range_of_injective Complex.ofReal_injective
have hex : ∃ x : ParamCoord m → ℂ,
x ∈ pi univ s ∧
eval x (pinSubst m L Q) ≠ 0 := by
by_contra hn
apply hpinQ
apply MvPolynomial.funext_set s hs
intro x hx
change eval x (pinSubst m L Q) = 0
by_contra hne
exact hn ⟨x, hx, hne⟩
obtain ⟨x, hx, hxQ⟩ := hex
let xr : ParamCoord m → ℝ := fun i => (x i).re
have hxreal : ∀ i, ((xr i : ℝ) : ℂ) = x i := by
intro i
change (((x i).re : ℝ) : ℂ) = x i
have hxi : x i ∈ s i := hx i (Set.mem_univ i)
have hrange : x i ∈ Set.range Complex.ofReal := by
rcases i with _ | i
· simpa [s] using hxi
rcases i with i | jr
· simpa [s] using hxi
· by_cases hir : 2 ≤ jr.2 ∧ jr.2 ≤ L
· rcases (by simpa [s, hir] using hxi) with ⟨y, _, hy⟩
exact ⟨y, hy⟩
· simpa [s, hir] using hxi
rcases hrange with ⟨y, hy⟩
rw [← hy]
simp
let θ : ParamSpace ℝ m :=
(xr (inl ()),
(fun i => xr (inr (inl i))),
fun j r => if 2 ≤ r ∧ r ≤ L then xr (inr (inr (j, r))) else 0)
have heval_family : (fun i : ParamCoord m =>
MvPolynomial.aeval x
(match i with
| inr (inr jr) =>
if 2 ≤ jr.2 ∧ jr.2 ≤ L then X i
else (0 : MvPolynomial (ParamCoord m) ℂ)
| _ => X i)) = paramEval (complexifyParam θ) := by
funext i
rcases i with _ | i
· simp [paramEval, complexifyParam, θ, hxreal]
rcases i with i | jr
· simp [paramEval, complexifyParam, θ, hxreal]
· by_cases hir : 2 ≤ jr.2 ∧ jr.2 ≤ L
· simp [hir, paramEval, complexifyParam, θ, hxreal]
· simp [hir, paramEval, complexifyParam, θ]
have hQθ : eval (paramEval (complexifyParam θ)) Q ≠ 0 := by
rw [← heval_family]
change MvPolynomial.aeval (fun i : ParamCoord m =>
MvPolynomial.aeval x
(match i with
| inr (inr jr) =>
if 2 ≤ jr.2 ∧ jr.2 ≤ L then X i else 0
| _ => X i)) Q ≠ 0
rw [← MvPolynomial.aeval_bind₁]
exact hxQ
have hPθ : eval (paramEval (complexifyParam θ)) P ≠ 0 := by
have hmul := hQθ
change eval (paramEval (complexifyParam θ)) (P * G) ≠ 0 at hmul
rw [MvPolynomial.eval_mul] at hmul
exact (mul_ne_zero_iff.mp hmul).1
have hGθ : eval (paramEval (complexifyParam θ)) G ≠ 0 := by
have hmul := hQθ
change eval (paramEval (complexifyParam θ)) (P * G) ≠ 0 at hmul
rw [MvPolynomial.eval_mul] at hmul
exact (mul_ne_zero_iff.mp hmul).2
have hgenprod :
(complexifyParam θ).1 *
(∏ i : Fin m, ((complexifyParam θ).1 - (complexifyParam θ).2.1 i)) *
(∏ i : Fin m, ∏ i' : Fin m, if i < i' then
(complexifyParam θ).2.1 i - (complexifyParam θ).2.1 i' else 1) *
(∏ j : Fin (m + 2), ∏ r ∈ Icc 2 L,
(complexifyParam θ).2.2 j r) ≠ 0 := by
rw [← eval_genericParameterPolynomial]
exact hGθ
have hdirectC : (complexifyParam θ).1 ≠ 0 := by
change (complexifyParam θ).1 *
(∏ i : Fin m, ((complexifyParam θ).1 - (complexifyParam θ).2.1 i)) *
(∏ i : Fin m, ∏ i' : Fin m, if i < i' then
(complexifyParam θ).2.1 i - (complexifyParam θ).2.1 i' else 1) *
(∏ j : Fin (m + 2), ∏ r ∈ Icc 2 L,
(complexifyParam θ).2.2 j r) ≠ 0 at hgenprod
exact (mul_ne_zero_iff.mp (mul_ne_zero_iff.mp
(mul_ne_zero_iff.mp hgenprod).1).1).1
have hdirect : θ.1 ≠ 0 := by
intro hz
apply hdirectC
simp [complexifyParam, hz]
have hgamma : ∀ i : Fin m, θ.1 ≠ θ.2.1 i := by
intro i hi
change (complexifyParam θ).1 *
(∏ i : Fin m, ((complexifyParam θ).1 - (complexifyParam θ).2.1 i)) *
(∏ i : Fin m, ∏ i' : Fin m, if i < i' then
(complexifyParam θ).2.1 i - (complexifyParam θ).2.1 i' else 1) *
(∏ j : Fin (m + 2), ∏ r ∈ Icc 2 L,
(complexifyParam θ).2.2 j r) ≠ 0 at hgenprod
have hp := (mul_ne_zero_iff.mp (mul_ne_zero_iff.mp
(mul_ne_zero_iff.mp hgenprod).1).1).2
have hfac := Finset.prod_ne_zero_iff.mp hp i (Finset.mem_univ i)
apply hfac
simp [complexifyParam, hi]
have hrho : Injective θ.2.1 := by
intro i i' hii
by_contra hne
change (complexifyParam θ).1 *
(∏ i : Fin m, ((complexifyParam θ).1 - (complexifyParam θ).2.1 i)) *
(∏ i : Fin m, ∏ i' : Fin m, if i < i' then
(complexifyParam θ).2.1 i - (complexifyParam θ).2.1 i' else 1) *
(∏ j : Fin (m + 2), ∏ r ∈ Icc 2 L,
(complexifyParam θ).2.2 j r) ≠ 0 at hgenprod
have hp := (mul_ne_zero_iff.mp (mul_ne_zero_iff.mp hgenprod).1).2
rcases lt_or_gt_of_ne hne with hlt | hgt
· have hfac := Finset.prod_ne_zero_iff.mp
(Finset.prod_ne_zero_iff.mp hp i (Finset.mem_univ i)) i'
(Finset.mem_univ i')
apply hfac
simp [hlt, complexifyParam, hii]
· have hfac := Finset.prod_ne_zero_iff.mp
(Finset.prod_ne_zero_iff.mp hp i' (Finset.mem_univ i')) i
(Finset.mem_univ i)
apply hfac
simp [hgt, complexifyParam, hii]
have hslopes : Injective
(Fin.cons θ.1 θ.2.1 : Fin (m + 1) → ℝ) := by
intro i i' hii
cases i using Fin.cases with
| zero =>
cases i' using Fin.cases with
| zero => rfl
| succ b =>
change θ.1 = θ.2.1 b at hii
exact (hgamma b hii).elim
| succ a =>
cases i' using Fin.cases with
| zero =>
change θ.2.1 a = θ.1 at hii
exact (hgamma a hii.symm).elim
| succ b =>
change θ.2.1 a = θ.2.1 b at hii
simpa using hrho hii
have hpinθ : ∀ j : Fin (m + 2), ∀ r : ℕ,
(r < 2 ∨ L < r) → θ.2.2 j r = 0 := by
intro j r hout
simp only [θ]
split_ifs with hir
· omega
· rfl
have hsource : ∀ j : Fin (m + 2), ∃ ν : Measure ℝ,
IsProbabilityMeasure ν ∧ (∫ x, x ∂ν = 0) ∧ ¬ IsGaussianLaw ν ∧
MemLp (id : ℝ → ℝ) (L : ℝ≥0∞) ν ∧
∀ r, 2 ≤ r → r ≤ L → sourceCumulant ν id r = θ.2.2 j r := by
intro j
apply hrealize (fun r => θ.2.2 j r)
intro r hr2 hrL
have hxr : xr (inr (inr (j, r))) ∈
Ioo (c r - ε) (c r + ε) := by
have hm := hx (inr (inr (j, r)))
(Set.mem_univ (inr (inr (j, r))))
rcases (by simpa [s, hr2, hrL] using hm) with ⟨y, hyI, hyx⟩
have hxy : xr (inr (inr (j, r))) = y := by
change (x (inr (inr (j, r)))).re = y
rw [← hyx]
simp
simpa [hxy] using hyI
simp only [θ, hr2, hrL, and_self, if_true]
rw [abs_sub_lt_iff]
constructor <;> linarith [hxr.1, hxr.2]
refine ⟨θ, ?_, hPθ⟩
exact ⟨hdirect, hslopes, hpinθ, hsource⟩
Helpers.PinSubst 7 declarations
def pinSubst
Pinning substitutes zero for every weight coordinate outside orders two through L, while leaving all loading coordinates and retained weight coordinates fixed.
Definition (Lean source)
noncomputable def pinSubst (m L : ℕ) :
MvPolynomial (ParamCoord m) ℂ →ₐ[ℂ] MvPolynomial (ParamCoord m) ℂ :=
bind₁ (fun i : ParamCoord m =>
match i with
| inr (inr jr) =>
if 2 ≤ jr.2 ∧ jr.2 ≤ L then X i else 0
| _ => X i)
theorem pinSubst_ne_zero_of_pinned_witness
A polynomial remains nonzero after pinning whenever it is nonzero at one point whose out-of-band weight coordinates are already zero.
Formal statement
hypotheses
m L :
ℕ
P :
MvPolynomial (ParamCoord m) ℂ
θ₀ :
ParamSpace ℂ m
hpin :
∀ (j : Fin (m + 2)) (r : ℕ)
if
(r < 2 ∨ L < r)
then
θ₀.2.2 j r = 0
conclusion
pinSubst m L P ≠ 0
Proof (Lean source)
lemma pinSubst_ne_zero_of_pinned_witness {m L : ℕ}
(P : MvPolynomial (ParamCoord m) ℂ) (θ₀ : ParamSpace ℂ m)
(hpin : ∀ (j : Fin (m + 2)) (r : ℕ),
(r < 2 ∨ L < r) → θ₀.2.2 j r = 0)
(h : eval (paramEval θ₀) P ≠ 0) :
pinSubst m L P ≠ 0 := by
intro hzero
apply h
have hfamily : (fun i : ParamCoord m =>
MvPolynomial.aeval (paramEval θ₀)
(match i with
| inr (inr jr) =>
if 2 ≤ jr.2 ∧ jr.2 ≤ L then X i
else (0 : MvPolynomial (ParamCoord m) ℂ)
| _ => X i)) = paramEval θ₀ := by
funext i
rcases i with _ | i
· simp [paramEval]
rcases i with i | jr
· simp [paramEval]
· by_cases hir : 2 ≤ jr.2 ∧ jr.2 ≤ L
· simp [hir, paramEval]
· have hout : jr.2 < 2 ∨ L < jr.2 := by omega
simp [hir, paramEval, hpin jr.1 jr.2 hout]
rw [← hfamily]
change MvPolynomial.aeval (fun i : ParamCoord m =>
MvPolynomial.aeval (paramEval θ₀)
(match i with
| inr (inr jr) =>
if 2 ≤ jr.2 ∧ jr.2 ≤ L then X i else 0
| _ => X i)) P = 0
rw [← MvPolynomial.aeval_bind₁]
change eval (paramEval θ₀) (pinSubst m L P) = 0
rw [hzero]
simp
theorem pinSubst_X_slope
Pinning fixes every loading coordinate, so a latent slope variable remains the same variable.
Formal statement
Proof (Lean source)
lemma pinSubst_X_slope (m L : ℕ) (i : Fin m) :
pinSubst m L (X (inr (inl i))) =
(X (inr (inl i)) : MvPolynomial (ParamCoord m) ℂ) := by
simp [pinSubst]
def pinParam
A coordinate assignment determines a structural parameter with its loading coordinates and retained source weights unchanged and all off-band weights set to zero.
Definition (Lean source)
def pinParam (m L : ℕ) (v : ParamCoord m → ℂ) : ParamSpace ℂ m :=
(v (inl ()), fun i => v (inr (inl i)),
fun j r => if 2 ≤ r ∧ r ≤ L then v (inr (inr (j, r))) else 0)
theorem pinParam_mem_band
Every parameter obtained by pinning a coordinate assignment belongs to the paper's finite retained-band parameter space.
Formal statement
Proof (Lean source)
lemma pinParam_mem_band (m L : ℕ) (v : ParamCoord m → ℂ) :
pinParam m L v ∈ bandSupportedParams m L := by
intro j r hout
simp only [pinParam]
split_ifs with hir
· omega
· rfl
theorem eval_pinSubst
Evaluating a pinned polynomial at a coordinate assignment equals evaluating the original polynomial at the corresponding pinned parameter.
Formal statement
hypotheses
Proof (Lean source)
lemma eval_pinSubst (m L : ℕ) (v : ParamCoord m → ℂ)
(P : MvPolynomial (ParamCoord m) ℂ) :
eval v (pinSubst m L P) =
eval (paramEval (pinParam m L v)) P := by
change MvPolynomial.aeval v (bind₁ _ P) = _
rw [MvPolynomial.aeval_bind₁]
have hfamily : (fun i : ParamCoord m =>
MvPolynomial.aeval v
(match i with
| inr (inr jr) =>
if 2 ≤ jr.2 ∧ jr.2 ≤ L then X i
else (0 : MvPolynomial (ParamCoord m) ℂ)
| _ => X i)) = paramEval (pinParam m L v) := by
funext i
rcases i with _ | i
· simp [paramEval, pinParam]
rcases i with i | jr
· simp [paramEval, pinParam]
· by_cases hir : 2 ≤ jr.2 ∧ jr.2 ≤ L
· simp [hir, paramEval, pinParam]
· simp [hir, paramEval, pinParam]
rw [hfamily]
exact congrFun (MvPolynomial.aeval_eq_eval (paramEval (pinParam m L v))) P
theorem eval_pinSubst_of_mem_band
At a parameter in the paper's retained band, pinning a polynomial does not change its value.
Formal statement
hypotheses
Proof (Lean source)
lemma eval_pinSubst_of_mem_band {m L : ℕ} {θ : ParamSpace ℂ m}
(hθ : θ ∈ bandSupportedParams m L) (P : MvPolynomial (ParamCoord m) ℂ) :
eval (paramEval θ) (pinSubst m L P) =
eval (paramEval θ) P := by
rw [eval_pinSubst]
have hparam : pinParam m L (paramEval θ) = θ := by
apply Prod.ext
· rfl
apply Prod.ext
· rfl
funext j r
by_cases hir : 2 ≤ r ∧ r ≤ L
· simp [pinParam, paramEval, hir]
· have hout : r < 2 ∨ L < r := by omega
simp [pinParam, paramEval, hir, hθ j r hout]
rw [hparam]
Helpers.PolynomialRetractDimension 2 declarations The polynomial-map and retract proofs are implemented in neutral substrate; this file retains the paper namespace and method-style API.
Compatibility reexports for polynomial retract dimension
The polynomial-map and retract proofs are implemented in neutral substrate; this file retains the paper namespace and method-style API.
theorem comp
Proves the stated mathematical property of comp.
Formal statement
hypotheses
conclusion
IsPolynomialMap (g ∘ f)
Proof (Lean source)
lemma comp {ι κ τ : Type*}
{f : (ι → ℂ) → (κ → ℂ)} {g : (κ → ℂ) → (τ → ℂ)}
(hg : IsPolynomialMap g) (hf : IsPolynomialMap f) :
IsPolynomialMap (g ∘ f) :=
comp hg hf
theorem eval_comp
Gives the stated evaluation formula for eval comp.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma eval_comp {ι κ : Type*}
{f : (ι → ℂ) → (κ → ℂ)} (hf : IsPolynomialMap f)
(Q : MvPolynomial κ ℂ) :
∃ P : MvPolynomial ι ℂ, ∀ x,
eval x P = eval (f x) Q :=
eval_comp hf Q
Helpers.ReverseApolarKernel 5 declarations
def reverseWeightedContraction
The genuine weighted contraction map for the reverse loading family.
Definition (Lean source)
noncomputable def reverseWeightedContraction (m : ℕ) (η : ParamSpace ℂ m)
(e : Fin (m + 2) → ℂ) : Fin (m + 1) → MvPolynomial (Fin 2) ℂ :=
fun k => ∑ j : Fin (m + 2),
C (η.2.2 j (m + 2 + k.1)) * C (e j) *
linForm (reverseLoading m η.1 η.2.1 j) ^ k.1
theorem evalAtDir_zero_of_reverse_contractions
Common reverse contractions force all directional evaluations to vanish.
Formal statement
hypotheses
m :
ℕ
η :
ParamSpace ℂ m
q :
MvPolynomial (Fin 2) ℂ
hq :
q.IsHomogeneous (m + 2)
hrank :
hcon :
∀ k
if
k ≤ m
then
conclusion
∀ j, evalAtDir q (reverseLoading m η.1 η.2.1 j) = 0
Proof (Lean source)
lemma evalAtDir_zero_of_reverse_contractions (m : ℕ) (η : ParamSpace ℂ m)
(q : MvPolynomial (Fin 2) ℂ) (hq : q.IsHomogeneous (m + 2))
(hrank : Injective (reverseWeightedContraction m η))
(hcon : ∀ k, k ≤ m → diffApply q
(dividedPowerBlock (reverseCumulantMap m (2 * m + 2) η) (m + 2 + k)) = 0) :
∀ j, evalAtDir q (reverseLoading m η.1 η.2.1 j) = 0 := by
let e : Fin (m + 2) → ℂ := fun j => evalAtDir q (reverseLoading m η.1 η.2.1 j)
have hB : reverseWeightedContraction m η e = reverseWeightedContraction m η 0 := by
funext k
have hk : k.1 ≤ m := Nat.lt_succ_iff.mp k.2
have h := hcon k.1 hk
rw [dividedPowerBlock_reverse_eq_sum_linForm_pow m (2 * m + 2) (m + 2 + k.1) η
(by omega) (by omega), reverse_diffApply_sum] at h
simp_rw [reverse_diffApply_C_mul, diffApply_linForm_pow q hq] at h
have hfac : (descFactorial (m + 2 + k.1) (m + 2) : ℂ) ≠ 0 := by
exact_mod_cast Nat.ne_of_gt
(Nat.descFactorial_pos.mpr (by omega : m + 2 ≤ m + 2 + k.1))
rw [reverseWeightedContraction]
change (∑ j : Fin (m + 2),
C (η.2.2 j (m + 2 + k.1)) * C (e j) *
linForm (reverseLoading m η.1 η.2.1 j) ^ k.1) =
∑ j : Fin (m + 2),
C (η.2.2 j (m + 2 + k.1)) *
C ((0 : Fin (m + 2) → ℂ) j) *
linForm (reverseLoading m η.1 η.2.1 j) ^ k.1
simp only [Pi.zero_apply, map_zero, mul_zero, zero_mul, Finset.sum_const_zero]
apply (mul_eq_zero.mp ?_).resolve_left (MvPolynomial.C_ne_zero.mpr hfac)
calc
C (descFactorial (m + 2 + k.1) (m + 2) : ℂ) *
∑ j : Fin (m + 2), C (η.2.2 j (m + 2 + k.1)) *
C (e j) * linForm (reverseLoading m η.1 η.2.1 j) ^ k.1 =
∑ j : Fin (m + 2),
C (descFactorial (m + 2 + k.1) (m + 2) : ℂ) *
(C (η.2.2 j (m + 2 + k.1)) * C (e j) *
linForm (reverseLoading m η.1 η.2.1 j) ^ k.1) := by rw [Finset.mul_sum]
_ = 0 := by
convert h using 1
apply Finset.sum_congr rfl
intro j hj
dsimp [e]
ring
have he : e = 0 := hrank hB
intro j
exact congrFun he j
theorem reverse_points_imply_supportAnnihilator_multiple
Reverse interpolation in the affine chart X₁ = 1, with the omitted axis direction supplying the vanishing top coefficient.
Formal statement
hypotheses
m :
ℕ
η :
ParamSpace ℂ m
q :
MvPolynomial (Fin 2) ℂ
hq :
q.IsHomogeneous (m + 2)
hslopes :
_hnonzero :
∀ j : Fin (m + 1), (reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0
hzero :
∀ j, evalAtDir q (reverseLoading m η.1 η.2.1 j) = 0
conclusion
∃ c : ℂ, q = c • supportAnnihilator (reverseLoading m η.1 η.2.1)
Proof (Lean source)
lemma reverse_points_imply_supportAnnihilator_multiple (m : ℕ)
(η : ParamSpace ℂ m) (q : MvPolynomial (Fin 2) ℂ)
(hq : q.IsHomogeneous (m + 2))
(hslopes : Injective
(fun j : Fin (m + 1) =>
(reverseLoading m η.1 η.2.1 j.succ).1))
(_hnonzero : ∀ j : Fin (m + 1),
(reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0)
(hzero : ∀ j, evalAtDir q (reverseLoading m η.1 η.2.1 j) = 0) :
∃ c : ℂ, q = c • supportAnnihilator (reverseLoading m η.1 η.2.1) := by
let dirs : Fin (m + 2) → ℂ × ℂ := reverseLoading m η.1 η.2.1
let Q := supportAnnihilator dirs
have hQhom : Q.IsHomogeneous (m + 2) := supportAnnihilator_isHomogeneous dirs
have hQcoeff : (reverseDehom Q).coeff (m + 1) = -1 := by
simpa [Q, dirs] using reverseDehom_support_coeff m η
let c : ℂ := (reverseDehom q).coeff (m + 1) / (reverseDehom Q).coeff (m + 1)
let r : MvPolynomial (Fin 2) ℂ := q - C c * Q
have hrhom : r.IsHomogeneous (m + 2) := by
apply (MvPolynomial.homogeneousSubmodule (Fin 2) ℂ (m + 2)).sub_mem hq
exact hQhom.C_mul c
have hrtop : (reverseDehom r).coeff (m + 2) = 0 := by
dsimp [r]
rw [map_sub, map_mul]
simp only [reverseDehom, MvPolynomial.eval₂Hom_C, Polynomial.coeff_sub,
Polynomial.coeff_C_mul]
have hqtop : (reverseDehom q).coeff (m + 2) = 0 :=
reverse_axis_eval_gives_top_coeff m η q hq (hzero 0)
have hQtop : (reverseDehom Q).coeff (m + 2) = 0 := by
apply Polynomial.coeff_eq_zero_of_natDegree_lt
rw [reverseDehom_support]
have hdeg : (∏ j : Fin (m + 1),
(Polynomial.X - Polynomial.C
(reverseLoading m η.1 η.2.1 j.succ).1)).natDegree = m + 1 := by
rw [Polynomial.natDegree_prod]
· simp
· intro j hj hz
exact (Polynomial.monic_X_sub_C _).ne_zero hz
rw [Polynomial.natDegree_neg, hdeg]
omega
change (reverseDehom q).coeff (m + 2) -
c * (reverseDehom Q).coeff (m + 2) = 0
rw [hqtop, hQtop]
ring
have hrnext : (reverseDehom r).coeff (m + 1) = 0 := by
dsimp [r, c]
rw [map_sub, map_mul]
simp only [reverseDehom, MvPolynomial.eval₂Hom_C, Polynomial.coeff_sub,
Polynomial.coeff_C_mul]
have hQne : (reverseDehom Q).coeff (m + 1) ≠ 0 := by
rw [hQcoeff]
exact neg_ne_zero.mpr one_ne_zero
change (reverseDehom q).coeff (m + 1) -
((reverseDehom q).coeff (m + 1) / (reverseDehom Q).coeff (m + 1)) *
(reverseDehom Q).coeff (m + 1) = 0
rw [div_mul_cancel₀ _ hQne, sub_self]
have hrroot : ∀ j : Fin (m + 1),
Polynomial.IsRoot (reverseDehom r) (dirs j.succ).1 := by
intro j
have hQzero : evalAtDir Q (dirs j.succ) = 0 :=
evalAtDir_supportAnnihilator_eq_zero dirs j.succ
have hqzero : evalAtDir q (dirs j.succ) = 0 := by
simpa [dirs] using hzero j.succ
have hrorig : evalAtDir r (dirs j.succ) = 0 := by
change evalAtDir (q - C c * Q) (dirs j.succ) = 0
simp only [evalAtDir, MvPolynomial.eval_sub, MvPolynomial.eval_mul,
MvPolynomial.eval_C] at hqzero hQzero ⊢
rw [hqzero, hQzero]
ring
change (reverseDehom r).eval (dirs j.succ).1 = 0
rw [reverseDehom_eval]
have hsnd : (dirs j.succ).2 = 1 := by
exact reverse_succ_second m η j
change evalAtDir r ((dirs j.succ).1, 1) = 0
rw [← hsnd]
exact hrorig
have hrdehom : reverseDehom r = 0 := by
by_contra hne
have hdeg_le : (reverseDehom r).natDegree ≤ m + 2 :=
reverseDehom_natDegree_le_of_homogeneous hrhom
have hdeg_lt : (reverseDehom r).natDegree < m + 1 := by
by_contra hnot
have hge : m + 1 ≤ (reverseDehom r).natDegree := Nat.le_of_not_gt hnot
have hcases : (reverseDehom r).natDegree = m + 1 ∨
(reverseDehom r).natDegree = m + 2 := by omega
rcases hcases with hd | hd
· exact (Polynomial.leadingCoeff_ne_zero.mpr hne)
(by rw [← Polynomial.coeff_natDegree, hd, hrnext])
· exact (Polynomial.leadingCoeff_ne_zero.mpr hne)
(by rw [← Polynomial.coeff_natDegree, hd, hrtop])
have hsub : image (fun j : Fin (m + 1) => (dirs j.succ).1)
univ ⊆ (reverseDehom r).roots.toFinset := by
intro z hz
rw [mem_image] at hz
obtain ⟨j, hj, rfl⟩ := hz
simp only [Multiset.mem_toFinset, Polynomial.mem_roots hne]
exact hrroot j
have hmany : m + 1 ≤ (reverseDehom r).natDegree := by
calc
m + 1 = (image (fun j : Fin (m + 1) => (dirs j.succ).1)
univ).card := by
rw [Finset.card_image_iff.mpr (by simpa [dirs] using hslopes)]
simp
_ ≤ (reverseDehom r).roots.toFinset.card := Finset.card_le_card hsub
_ ≤ (reverseDehom r).roots.card := Multiset.toFinset_card_le _
_ ≤ (reverseDehom r).natDegree := Polynomial.card_roots' _
omega
have hrzero : r = 0 := reverseDehom_injective_on_homogeneous hrhom hrdehom
refine ⟨c, ?_⟩
have heq : q = C c * Q := sub_eq_zero.mp hrzero
simpa [Q, dirs, MvPolynomial.smul_eq_C_mul] using heq
theorem reverse_apolar_kernel_identity
The common reverse apolar kernel is the reverse support-annihilator line.
Formal statement
hypotheses
m :
ℕ
η :
ParamSpace ℂ m
hslopes :
hnonzero :
∀ j : Fin (m + 1), (reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0
hrank :
conclusion
∀ q : MvPolynomial (Fin 2) ℂ
if
q.IsHomogeneous (m + 2)
then
((∀ k, k ≤ m → diffApply q (dividedPowerBlock (reverseCumulantMap m (2 * m + 2) η) (m + 2 + k)) = 0) ↔ ∃ c : ℂ, q = c • supportAnnihilator (reverseLoading m η.1 η.2.1))
Proof (Lean source)
theorem reverse_apolar_kernel_identity (m : ℕ) (η : ParamSpace ℂ m)
(hslopes : Injective
(fun j : Fin (m + 1) =>
(reverseLoading m η.1 η.2.1 j.succ).1))
(hnonzero : ∀ j : Fin (m + 1),
(reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0)
(hrank : Injective (reverseWeightedContraction m η)) :
∀ q : MvPolynomial (Fin 2) ℂ, q.IsHomogeneous (m + 2) →
((∀ k, k ≤ m → diffApply q
(dividedPowerBlock (reverseCumulantMap m (2 * m + 2) η) (m + 2 + k)) = 0)
↔ ∃ c : ℂ, q = c • supportAnnihilator (reverseLoading m η.1 η.2.1)) := by
intro q hq
constructor
· intro hcon
apply reverse_points_imply_supportAnnihilator_multiple m η q hq hslopes hnonzero
exact evalAtDir_zero_of_reverse_contractions m η q hq hrank hcon
· exact reverse_supportAnnihilator_in_contraction_kernel m η q hq
theorem reverse_contraction_injective_of_generic_and_minor
Reverse contraction injectivity holds on the principal open set cut out by a genuine coefficient-minor determinant. The polynomial is nonzero at an explicit witness whose weights vanish outside the pinned degree band.
Formal statement
hypotheses
m :
ℕ
hm :
1 ≤ m
conclusion
∃ P : MvPolynomial (ParamCoord m) ℂ
if
P ≠ 0 ∧
(∃ θ₀ : ParamSpace ℂ m, (∀ (j : Fin (m + 2)) (r : ℕ), (r < 2 ∨ 2 * m + 2 < r) → θ₀.2.2 j r = 0) ∧ eval (paramEval θ₀) P ≠ 0) ∧
then
Proof (Lean source)
theorem reverse_contraction_injective_of_generic_and_minor (m : ℕ) (hm : 1 ≤ m) :
∃ P : MvPolynomial (ParamCoord m) ℂ, P ≠ 0 ∧
(∃ θ₀ : ParamSpace ℂ m,
(∀ (j : Fin (m + 2)) (r : ℕ), (r < 2 ∨ 2 * m + 2 < r) → θ₀.2.2 j r = 0) ∧
eval (paramEval θ₀) P ≠ 0) ∧
∀ η : ParamSpace ℂ m, eval (paramEval η) P ≠ 0 →
Injective (reverseWeightedContraction m η) := by
refine ⟨(reverseContractionMinorPolynomial m).det, ?_, ?_, ?_⟩
· intro hzero
apply reverse_witness_minor_det_ne_zero m hm
change det
((eval (paramEval (reverseWitnessParameter m))).mapMatrix
(reverseContractionMinorPolynomial m)) = 0
rw [← RingHom.map_det, hzero, map_zero]
· refine ⟨reverseWitnessParameter m, ?_, ?_⟩
· intro j r hr
simp only [reverseWitnessParameter]
rcases hr with hr | hr
· rw [if_neg (by omega), if_neg (by omega)]
· rw [if_neg (by omega), if_neg (by omega)]
· intro hzero
apply reverse_witness_minor_det_ne_zero m hm
change det
((eval (paramEval (reverseWitnessParameter m))).mapMatrix
(reverseContractionMinorPolynomial m)) = 0
rw [← RingHom.map_det]
exact hzero
· intro η hη
apply reverse_contraction_injective_of_minor_det_ne_zero m η
change det ((eval (paramEval η)).mapMatrix
(reverseContractionMinorPolynomial m)) ≠ 0
rw [← RingHom.map_det]
exact hη
Helpers.SlopeUniqueness 2 declarations This file recovers, with multiplicity, the finite forward and reverse loading slopes from the one-dimensional common apolar-contraction kernel.
This file recovers, with multiplicity, the finite forward and reverse loading slopes from the one-dimensional common apolar-contraction kernel.
theorem forward_slopes_determined_by_cumulants
At a forward parameter where the common apolar-contraction kernel is the support-annihilator line, cumulants through order 2m+2 determine the multiset of the direct and latent finite loading slopes.
Formal statement
hypotheses
m :
ℕ
θ :
ParamSpace ℂ m
hslopes :
hnonzero :
hrank :
θ'' :
ParamSpace ℂ m
heq :
forwardCumulantMap m (2 * m + 2) θ'' = forwardCumulantMap m (2 * m + 2) θ
conclusion
θ''.1 ::ₘ (Finset.univ.val.map (fun i => θ''.2.1 i))
= θ.1 ::ₘ (Finset.univ.val.map (fun i => θ.2.1 i))
Proof (Lean source)
theorem forward_slopes_determined_by_cumulants (m : ℕ) (θ : ParamSpace ℂ m)
(hslopes : Injective
(fun j : Fin (m + 1) => (forwardLoading m θ.1 θ.2.1 (castSucc j)).2))
(hnonzero : ∀ j : Fin (m + 1),
(forwardLoading m θ.1 θ.2.1 (castSucc j)).2 ≠ 0)
(hrank : Injective (forwardWeightedContraction m θ))
(θ'' : ParamSpace ℂ m)
(heq : forwardCumulantMap m (2 * m + 2) θ'' = forwardCumulantMap m (2 * m + 2) θ) :
θ''.1 ::ₘ (Finset.univ.val.map (fun i => θ''.2.1 i)) =
θ.1 ::ₘ (Finset.univ.val.map (fun i => θ.2.1 i)) := by
let Q'' := supportAnnihilator (forwardLoading m θ''.1 θ''.2.1)
let Q := supportAnnihilator (forwardLoading m θ.1 θ.2.1)
have hhom : Q''.IsHomogeneous (m + 2) :=
supportAnnihilator_isHomogeneous _
have hcon : ∀ k, k ≤ m → diffApply Q''
(dividedPowerBlock (forwardCumulantMap m (2 * m + 2) θ) (m + 2 + k)) = 0 := by
have hown := forward_supportAnnihilator_in_contraction_kernel m θ'' Q'' hhom
⟨1, by simp [Q'']⟩
rw [heq] at hown
exact hown
obtain ⟨c, hcQ⟩ :=
(forward_apolar_kernel_identity m θ hslopes hnonzero hrank Q'' hhom).mp hcon
have hc : c ≠ 0 := by
intro hc0
have hQzero : Q'' = 0 := by simpa [hc0] using hcQ
exact forward_support_ne_zero m θ''.1 θ''.2.1 (by simpa [Q''] using hQzero)
have hdehom : dehomX Q'' = Polynomial.C c * dehomX Q := by
have hcQ' : Q'' = c • Q := by simpa [Q] using hcQ
rw [hcQ']
simp [MvPolynomial.smul_eq_C_mul, dehomX]
have hroots : (dehomX Q'').roots = (dehomX Q).roots := by
rw [hdehom, Polynomial.roots_C_mul _ hc]
simpa [Q'', Q, roots_dehomX_supportAnnihilator_forward] using hroots
theorem reverse_slopes_determined_by_cumulants
At a reverse parameter where the common apolar-contraction kernel is the support-annihilator line, cumulants through order 2m+2 determine the multiset of the direct and latent finite loading slopes.
Formal statement
hypotheses
m :
ℕ
η :
ParamSpace ℂ m
hslopes :
hnonzero :
∀ j : Fin (m + 1), (reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0
hrank :
η'' :
ParamSpace ℂ m
heq :
reverseCumulantMap m (2 * m + 2) η'' = reverseCumulantMap m (2 * m + 2) η
conclusion
η''.1 ::ₘ (Finset.univ.val.map (fun i => η''.2.1 i))
= η.1 ::ₘ (Finset.univ.val.map (fun i => η.2.1 i))
Proof (Lean source)
theorem reverse_slopes_determined_by_cumulants (m : ℕ) (η : ParamSpace ℂ m)
(hslopes : Injective
(fun j : Fin (m + 1) => (reverseLoading m η.1 η.2.1 j.succ).1))
(hnonzero : ∀ j : Fin (m + 1), (reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0)
(hrank : Injective (reverseWeightedContraction m η))
(η'' : ParamSpace ℂ m)
(heq : reverseCumulantMap m (2 * m + 2) η'' = reverseCumulantMap m (2 * m + 2) η) :
η''.1 ::ₘ (Finset.univ.val.map (fun i => η''.2.1 i)) =
η.1 ::ₘ (Finset.univ.val.map (fun i => η.2.1 i)) := by
let Q'' := supportAnnihilator (reverseLoading m η''.1 η''.2.1)
let Q := supportAnnihilator (reverseLoading m η.1 η.2.1)
have hhom : Q''.IsHomogeneous (m + 2) :=
supportAnnihilator_isHomogeneous _
have hcon : ∀ k, k ≤ m → diffApply Q''
(dividedPowerBlock (reverseCumulantMap m (2 * m + 2) η) (m + 2 + k)) = 0 := by
have hown := reverse_supportAnnihilator_in_contraction_kernel m η'' Q'' hhom
⟨1, by simp [Q'']⟩
rw [heq] at hown
exact hown
obtain ⟨c, hcQ⟩ :=
(reverse_apolar_kernel_identity m η hslopes hnonzero hrank Q'' hhom).mp hcon
have hc : c ≠ 0 := by
intro hc0
have hQzero : Q'' = 0 := by simpa [hc0] using hcQ
exact reverse_support_ne_zero m η''.1 η''.2.1 (by simpa [Q''] using hQzero)
have hdehom : dehomY Q'' = Polynomial.C c * dehomY Q := by
have hcQ' : Q'' = c • Q := by simpa [Q] using hcQ
rw [hcQ']
simp [MvPolynomial.smul_eq_C_mul, dehomY]
have hroots : (dehomY Q'').roots = (dehomY Q).roots := by
rw [hdehom, Polynomial.roots_C_mul _ hc]
simpa [Q'', Q, roots_dehomY_supportAnnihilator_reverse] using hroots
Helpers.Varieties 27 declarations Quotient fibers modulo admissible swaps and Jacobian ranks
Quotient fibers modulo admissible swaps and Jacobian ranks
def zariskiClosure
Zariski closure of a set A ⊆ ℂ^{q_L} of cumulant vectors: the common zero set of every polynomial (in the coordinate ring ℂ[t_{r,a}]) that vanishes on A. Coordinates are indexed by (r, a) ∈ ℕ × ℕ.
Definition (Lean source)
def zariskiClosure (A : Set (CumVec ℂ)) : Set (CumVec ℂ) :=
{ t | ∀ P : MvPolynomial (ℕ × ℕ) ℂ,
(∀ s ∈ A, eval (fun p => s p.1 p.2) P = 0) →
eval (fun p => t p.1 p.2) P = 0 }
def ParamCoord
Coordinate index of the structural parameter space: the direct slope, the m latent slopes, and the weight family (j, r).
Definition (Lean source)
def paramEval
Evaluate the parameter coordinates of θ at a coordinate index.
Definition (Lean source)
def paramEval {m : ℕ} (θ : ParamSpace ℂ m) : ParamCoord m → ℂ
| inl _ => θ.1
| inr (inl i) => θ.2.1 i
| inr (inr jr) => θ.2.2 jr.1 jr.2
def zariskiClosureParam
Zariski closure of a set of structural parameters.
Definition (Lean source)
def zariskiClosureParam {m : ℕ} (A : Set (ParamSpace ℂ m)) : Set (ParamSpace ℂ m) :=
{ θ | ∀ P : MvPolynomial (ParamCoord m) ℂ,
(∀ s ∈ A, eval (paramEval s) P = 0) →
eval (paramEval θ) P = 0 }
def IsZariskiOpenParam
A Zariski-open subset of the parameter space (complement of a proper Zariski closed set).
Definition (Lean source)
def IsZariskiOpenParam {m : ℕ} (U : Set (ParamSpace ℂ m)) : Prop :=
∃ Z : Set (ParamSpace ℂ m), zariskiClosureParam Z = Z ∧ Z ≠ univ ∧ U = Zᶜ
def IsZariskiDenseParam
A Zariski-dense subset of the parameter space.
Definition (Lean source)
def zariskiClosureParamIn
The relative Zariski closure consists of the retained-band parameters at which every polynomial vanishing on the original set also vanishes.
Definition (Lean source)
def zariskiClosureParamIn {m : ℕ} (L : ℕ) (A : Set (ParamSpace ℂ m)) :
Set (ParamSpace ℂ m) :=
bandSupportedParams m L ∩
{ θ | ∀ P : MvPolynomial (ParamCoord m) ℂ,
(∀ s ∈ A, eval (paramEval s) P = 0) →
eval (paramEval θ) P = 0 }
A relatively Zariski-open set is the complement, within the retained-band parameter space, of a proper relatively closed set.
Definition (Lean source)
def IsZariskiOpenParamIn {m : ℕ} (L : ℕ) (U : Set (ParamSpace ℂ m)) : Prop :=
∃ Z : Set (ParamSpace ℂ m), zariskiClosureParamIn L Z = Z ∧
Z ≠ bandSupportedParams m L ∧ U = bandSupportedParams m L \ Z
A relatively Zariski-dense set has the whole retained-band parameter space as its relative Zariski closure.
Definition (Lean source)
def IsZariskiDenseParamIn {m : ℕ} (L : ℕ) (U : Set (ParamSpace ℂ m)) : Prop :=
zariskiClosureParamIn L U = bandSupportedParams m L
An irreducible Zariski-closed subset of the cumulant coordinate space: nonempty, Zariski-closed, and not the union of two proper Zariski-closed subsets. A strictly increasing chain of such sets is a chain of irreducible subvarieties (a prime chain in the coordinate ring), which is the dimension/codimension notion — Krull dimension via irreducible-component chains — that a codimension statement requires, as opposed to a chain of arbitrary Zariski-closed sets.
Definition (Lean source)
def IsIrreducibleZariskiClosed (Z : Set (CumVec ℂ)) : Prop :=
zariskiClosure Z = Z ∧ Z.Nonempty ∧
∀ Z₁ Z₂ : Set (CumVec ℂ),
zariskiClosure Z₁ = Z₁ → zariskiClosure Z₂ = Z₂ → Z = Z₁ ∪ Z₂ →
Z = Z₁ ∨ Z = Z₂
Complexification of a real structural parameter, coordinatewise.
Definition (Lean source)
def complexifyParam {m : ℕ} (p : ParamSpace ℝ m) : ParamSpace ℂ m :=
((p.1 : ℂ), (fun i => (p.2.1 i : ℂ)), (fun j r => (p.2.2 j r : ℂ)))
def complexifyCumVec
Complexification of a real cumulant coordinate vector, coordinatewise.
Definition (Lean source)
def cumulantImageVariety
Axis-conditioned cumulant-image variety C^b_{m,L}, the Zariski closure of the image of the arrow map Φ over the whole complex parameter space. The same construction gives C^right (with forwardCumulantMap) and C^left (with reverseCumulantMap). @realizes C^right_{m,L},C^left_{m,L}(Zariski closure of the arrow-map image)
Definition (Lean source)
-- @node: def:image-varieties
def cumulantImageVariety {m : ℕ} (Φ : ParamSpace ℂ m → CumVec ℂ) : Set (CumVec ℂ) :=
zariskiClosure (range Φ)
Generic full-fiber opposite-arrow compatibility locus E_m ⊆ ℂ^{q_K} (K = 2m + 2): observable vectors t whose one arrow has a generic full fiber and whose opposite arrow has a (possibly non-generic) full fiber. This is the first of the four components of def:generic-full-fiber-compatibility (bundled in genericFullFiberCompatibilityLocus). @realizes E_m,barE_m,H^right_m,H^left_m(compatibility locus E_m)
Definition (Lean source)
def genericFullFiberCompatibility (m : ℕ) : Set (CumVec ℂ) :=
-- `E_m ⊆ ℂ^{q_K}`: the observable vectors live in the paper's finite cumulant
-- coordinate space, so the `ℕ`-indexed representation must be cut down to it. Without
-- this, `E_m` (and hence `\bar E_m` and the preimages `H^b_m`) would be a cylinder over
-- unconstrained off-band cumulant coordinates.
bandSupportedCumulants (2 * m + 2) ∩
{ t |
((fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2)) t
∩ genericParameterLocus m (2 * m + 2)).Nonempty
∧ (fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2)) t).Nonempty)
∨ ((fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2)) t
∩ genericParameterLocus m (2 * m + 2)).Nonempty
∧ (fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2)) t).Nonempty) }
Zariski closure \bar E_m of the compatibility locus — the second component of the compatibility-locus construction def:generic-full-fiber-compatibility (E_m, \bar E_m, H^right_m, H^left_m). @realizes E_m,barE_m,H^right_m,H^left_m(Zariski closure \bar E_m)
Definition (Lean source)
def genericCompatibilityClosure (m : ℕ) : Set (CumVec ℂ) :=
zariskiClosure (genericFullFiberCompatibility m)
def genericCompatibilityPreimage
Parameter-level preimage H^b_m = Θ^{b,∘}_{m,K} ∩ (Φ^b)^{-1}(E_m) — the third and fourth components of def:generic-full-fiber-compatibility (H^right_m with Φ = forwardCumulantMap, H^left_m with Φ = reverseCumulantMap).
Definition (Lean source)
def genericCompatibilityPreimage {m : ℕ} (L : ℕ) (Φ : ParamSpace ℂ m → CumVec ℂ) :
Set (ParamSpace ℂ m) :=
bandSupportedParams m L ∩ genericParameterLocus m L ∩
Φ ⁻¹' (genericFullFiberCompatibility m)
def genericCompatibilityPreimageRight Definition aux_genericCompatibilityPreimageRight in the paper ↗
Right generic-locus preimage H^right_m = Θ^{right,∘}_{m,K} ∩ (Φ^right)^{-1}(E_m) — the third component of def:generic-full-fiber-compatibility.
Definition (Lean source)
def genericCompatibilityPreimageRight (m : ℕ) : Set (ParamSpace ℂ m) :=
genericCompatibilityPreimage (2 * m + 2) (forwardCumulantMap m (2 * m + 2))
Left generic-locus preimage H^left_m = Θ^{left,∘}_{m,K} ∩ (Φ^left)^{-1}(E_m) — the fourth component of def:generic-full-fiber-compatibility.
Definition (Lean source)
def genericCompatibilityPreimageLeft (m : ℕ) : Set (ParamSpace ℂ m) :=
genericCompatibilityPreimage (2 * m + 2) (reverseCumulantMap m (2 * m + 2))
def genericFullFiberCompatibilityLocus
Generic full-fiber compatibility construction — the full four-component object the paper's def:generic-full-fiber-compatibility defines, bundled so the extracted definition carries all of its parts (not only E_m):
Definition (Lean source)
-- @node: def:generic-full-fiber-compatibility
def genericFullFiberCompatibilityLocus (m : ℕ) :
Set (CumVec ℂ) × Set (CumVec ℂ) × Set (ParamSpace ℂ m) × Set (ParamSpace ℂ m) :=
(genericFullFiberCompatibility m,
genericCompatibilityClosure m,
genericCompatibilityPreimageRight m,
genericCompatibilityPreimageLeft m)
Orbit of θ under the admissible source-swap G_m action (the admissible relabelings of the middle latent block).
Definition (Lean source)
def admissibleOrbit {m : ℕ} (θ : ParamSpace ℂ m) : Set (ParamSpace ℂ m) :=
{ θ' | ∃ π : Perm (Fin m), θ' = admissibleSourceSwap m π θ }
def quotientFiber
Same-arrow quotient fiber of Φ over t: the set of G_m-orbits (admissible-source-swap classes) contained in the full fiber Φ⁻¹(t). This is the quotient of the same-arrow fiber by the admissible-swap action, not an assertion that the fiber is a single orbit.
Definition (Lean source)
def quotientFiber {m : ℕ} (L : ℕ) (Φ : ParamSpace ℂ m → CumVec ℂ) (t : CumVec ℂ) :
Set (Set (ParamSpace ℂ m)) :=
{ O | ∃ θ' ∈ fiberCorrespondence L Φ t, O = admissibleOrbit θ' }
def updateParamCoord
Update the coordinate k of a complex structural parameter θ to the value s.
Definition (Lean source)
def updateParamCoord {m : ℕ} (θ : ParamSpace ℂ m) : ParamCoord m → ℂ → ParamSpace ℂ m
| inl _, s => (s, θ.2.1, θ.2.2)
| inr (inl i), s => (θ.1, update θ.2.1 i s, θ.2.2)
| inr (inr jr), s =>
(θ.1, θ.2.1, update θ.2.2 jr.1 (update (θ.2.2 jr.1) jr.2 s))
def ActiveParam
Finite active parameter coordinates through retained order L: the direct slope, the m latent slopes, and the weights c_{jr} for r ≤ L.
Definition (Lean source)
def toParamCoord
The active parameter coordinate as a full parameter coordinate.
Definition (Lean source)
def toParamCoord {m L : ℕ} : ActiveParam m L → ParamCoord m
| inl u => inl u
| inr (inl i) => inr (inl i)
| inr (inr (j, r)) => inr (inr (j, r.1))
def jacobianMatrix
The Jacobian matrix of an arrow map Φ at θ over the retained finite coordinate band up to order L: the partial derivative of each retained output coordinate (r, a) with respect to each active parameter coordinate, taken with Mathlib's deriv (each Φ-coordinate is polynomial in one substituted scalar).
Definition (Lean source)
noncomputable def jacobianMatrix {m : ℕ} (L : ℕ) (Φ : ParamSpace ℂ m → CumVec ℂ)
(θ : ParamSpace ℂ m) :
Matrix (Fin (L + 1) × Fin (L + 1)) (ActiveParam m L) ℂ :=
fun ra k =>
deriv (fun s => Φ (updateParamCoord θ (toParamCoord k) s) ra.1 ra.2)
(paramEval θ (toParamCoord k))
def jacobianRank
The Jacobian rank of the same-arrow fiber equation of Φ at θ (through retained order L): the rank of jacobianMatrix. The quantitative value of this rank is the deferred content (interfaces I-1/I-2).
Definition (Lean source)
noncomputable def jacobianRank {m : ℕ} (L : ℕ) (Φ : ParamSpace ℂ m → CumVec ℂ)
(θ : ParamSpace ℂ m) : ℕ :=
(jacobianMatrix L Φ θ).rank
def separationHandle
Separation handle: the data used to compare the two axis-conditioned decompositions after quotienting each same-arrow fiber by G_m. It records the shared-observable equation, the two complete quotient fibers, and the two Jacobian ranks at the displayed representatives. The fixed vertical/horizontal axes are already built into forwardCumulantMap and reverseCumulantMap.
Definition (Lean source)
-- @node: def:separation-handle
noncomputable def separationHandle (m L : ℕ) (θ η : ParamSpace ℂ m) :
Prop × Set (Set (ParamSpace ℂ m)) × Set (Set (ParamSpace ℂ m)) × ℕ × ℕ :=
(forwardCumulantMap m L θ = reverseCumulantMap m L η,
quotientFiber L (forwardCumulantMap m L) (forwardCumulantMap m L θ),
quotientFiber L (reverseCumulantMap m L) (reverseCumulantMap m L η),
jacobianRank L (forwardCumulantMap m L) θ,
jacobianRank L (reverseCumulantMap m L) η)
Helpers.ZariskiLocus 8 declarations
theorem paramEval_surjective
Every assignment of the structural coordinates is represented by a parameter.
Formal statement
theorem isZariskiOpen_dense_of_poly_ne_zero
The complement of the vanishing set of a nonzero polynomial is Zariski-open and dense.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma isZariskiOpen_dense_of_poly_ne_zero {m : ℕ} (P : MvPolynomial (ParamCoord m) ℂ) (hP : P ≠ 0) :
IsZariskiOpenParam {θ : ParamSpace ℂ m | eval (paramEval θ) P ≠ 0} ∧
IsZariskiDenseParam {θ : ParamSpace ℂ m | eval (paramEval θ) P ≠ 0} := by
let U : Set (ParamSpace ℂ m) := {θ | eval (paramEval θ) P ≠ 0}
let Z : Set (ParamSpace ℂ m) := Uᶜ
have poly_eq_zero_of_eval_zero
(Q : MvPolynomial (ParamCoord m) ℂ)
(hQ : ∀ θ : ParamSpace ℂ m, eval (paramEval θ) Q = 0) : Q = 0 := by
apply MvPolynomial.funext
intro v
obtain ⟨θ, hθ⟩ := paramEval_surjective m v
rw [← hθ]
simpa using hQ θ
constructor
· refine ⟨Z, ?_, ?_, ?_⟩
· apply Set.Subset.antisymm
· intro θ hθ
have hP_vanishes : ∀ s ∈ Z, eval (paramEval s) P = 0 := by
intro s hs
simpa [Z, U] using hs
have hvanishes := hθ P hP_vanishes
simpa [Z, U] using hvanishes
· intro θ hθ Q hQ
exact hQ θ hθ
· intro hZ
apply hP
apply poly_eq_zero_of_eval_zero P
intro θ
have hθZ : θ ∈ Z := by rw [hZ]; exact Set.mem_univ θ
simpa [Z, U] using hθZ
· ext θ
simp [Z, U]
· ext θ₀
simp only [Set.mem_univ, iff_true]
intro Q hQ
have hmul_eval_zero : ∀ θ : ParamSpace ℂ m,
eval (paramEval θ) (Q * P) = 0 := by
intro θ
by_cases hθ : θ ∈ U
· rw [MvPolynomial.eval_mul, hQ θ hθ, zero_mul]
· have hPθ : eval (paramEval θ) P = 0 := by
simpa [U] using hθ
rw [MvPolynomial.eval_mul, hPθ, mul_zero]
have hmul : Q * P = 0 := poly_eq_zero_of_eval_zero (Q * P) hmul_eval_zero
have hQ : Q = 0 := (mul_eq_zero.mp hmul).resolve_right hP
simp [hQ]
def genericParameterPolynomial
The polynomial whose nonvanishing defines the generic parameter locus.
Definition (Lean source)
theorem genericParameterPolynomial_ne_zero
The polynomial defining the generic parameter restrictions is not identically zero.
Formal statement
Proof (Lean source)
lemma genericParameterPolynomial_ne_zero (m L : ℕ) : genericParameterPolynomial m L ≠ 0 := by
unfold genericParameterPolynomial
apply mul_ne_zero
· apply mul_ne_zero
· apply mul_ne_zero
· change X (inl () : ParamCoord m) ≠ 0
exact MvPolynomial.X_ne_zero _
· rw [Finset.prod_ne_zero_iff]
intro i hi
apply sub_ne_zero.mpr
intro hEq
have hCoord := MvPolynomial.X_injective hEq
simp at hCoord
· rw [Finset.prod_ne_zero_iff]
intro i hi
rw [Finset.prod_ne_zero_iff]
intro i' hi'
by_cases h : i < i'
· simp only [h, ↓reduceIte]
apply sub_ne_zero.mpr
intro hEq
have hCoord := MvPolynomial.X_injective hEq
have : i = i' := by simpa using hCoord
exact (ne_of_lt h) this
· simp [h]
· rw [Finset.prod_ne_zero_iff]
intro j hj
rw [Finset.prod_ne_zero_iff]
intro r hr
change X (inr (inr (j, r)) : ParamCoord m) ≠ 0
exact MvPolynomial.X_ne_zero _
theorem eval_genericParameterPolynomial
At any complex parameter value, the genericity polynomial equals the product of the direct slope, all slope-separation factors, and all retained cumulant coordinates.
Formal statement
hypotheses
m L :
ℕ
θ :
ParamSpace ℂ m
Proof (Lean source)
lemma eval_genericParameterPolynomial (m L : ℕ) (θ : ParamSpace ℂ m) :
eval (paramEval θ) (genericParameterPolynomial m L) =
θ.1 * (∏ i : Fin m, (θ.1 - θ.2.1 i)) *
(∏ i : Fin m, ∏ i' : Fin m, if i < i' then θ.2.1 i - θ.2.1 i' else 1) *
(∏ j : Fin (m + 2), ∏ r ∈ Icc 2 L, θ.2.2 j r) := by
have eval_pair (i i' : Fin m) :
eval (paramEval θ)
(if i < i' then X (inr (inl i)) -
X (inr (inl i')) else 1) =
if i < i' then θ.2.1 i - θ.2.1 i' else 1 := by
by_cases h : i < i' <;> simp [h, paramEval]
simp_rw [genericParameterPolynomial, MvPolynomial.eval_mul, map_prod, eval_pair]
simp [paramEval]
theorem genericParameterLocus_eq_nonvanishing_poly
The generic parameter locus is the band-supported parameter space with the genericity polynomial nonzero.
Formal statement
hypotheses
m L :
ℕ
conclusion
= bandSupportedParams m L ∩ {θ : ParamSpace ℂ m | eval (paramEval θ) (genericParameterPolynomial m L) ≠ 0}
Proof (Lean source)
lemma genericParameterLocus_eq_nonvanishing_poly (m L : ℕ) :
genericParameterLocus m L =
bandSupportedParams m L ∩
{θ : ParamSpace ℂ m |
eval (paramEval θ) (genericParameterPolynomial m L) ≠ 0} := by
ext θ
change θ ∈ bandSupportedParams m L ∧
θ.1 * (∏ i : Fin m, (θ.1 - θ.2.1 i)) *
(∏ i : Fin m, ∏ i' : Fin m, if i < i' then θ.2.1 i - θ.2.1 i' else 1) *
(∏ j : Fin (m + 2), ∏ r ∈ Icc 2 L, θ.2.2 j r) ≠ 0 ↔
θ ∈ bandSupportedParams m L ∧
eval (paramEval θ) (genericParameterPolynomial m L) ≠ 0
rw [eval_genericParameterPolynomial]
theorem isZariskiOpenIn_denseIn_of_pinSubst_ne_zero
Within the paper's finite retained-band parameter space, the nonvanishing locus of any polynomial whose pinned form is nonzero is relatively Zariski-open and dense.
Formal statement
hypotheses
conclusion
Proof (Lean source)
lemma isZariskiOpenIn_denseIn_of_pinSubst_ne_zero {m L : ℕ}
(P : MvPolynomial (ParamCoord m) ℂ) (hP : pinSubst m L P ≠ 0) :
IsZariskiOpenParamIn L
(bandSupportedParams m L ∩
{θ | eval (paramEval θ) P ≠ 0}) ∧
IsZariskiDenseParamIn L
(bandSupportedParams m L ∩
{θ | eval (paramEval θ) P ≠ 0}) := by
let Z : Set (ParamSpace ℂ m) :=
bandSupportedParams m L ∩ {θ | eval (paramEval θ) P = 0}
have hex : ∃ v : ParamCoord m → ℂ, eval v (pinSubst m L P) ≠ 0 := by
by_contra hn
apply hP
apply MvPolynomial.funext
intro v
by_contra hv
exact hn ⟨v, hv⟩
constructor
· refine ⟨Z, ?_, ?_, ?_⟩
· apply Set.Subset.antisymm
· intro θ hθ
refine ⟨hθ.1, ?_⟩
exact hθ.2 P (fun s hs => hs.2)
· intro θ hθ
refine ⟨hθ.1, ?_⟩
intro Q hQ
exact hQ θ hθ
· obtain ⟨v, hv⟩ := hex
intro hZ
have hband : pinParam m L v ∈ bandSupportedParams m L :=
pinParam_mem_band m L v
have heval : eval (paramEval (pinParam m L v)) P ≠ 0 := by
rw [← eval_pinSubst]
exact hv
have hmem : pinParam m L v ∈ Z := by
rw [hZ]
exact hband
exact heval hmem.2
· ext θ
simp [Z]
· apply Set.Subset.antisymm
· intro θ hθ
exact hθ.1
· intro θ hband
refine ⟨hband, ?_⟩
intro Q hQ
have hmul : pinSubst m L Q * pinSubst m L P = 0 := by
apply MvPolynomial.funext
intro v
rw [MvPolynomial.eval_mul, eval_pinSubst, eval_pinSubst]
by_cases hv : eval (paramEval (pinParam m L v)) P ≠ 0
· rw [hQ (pinParam m L v) ⟨pinParam_mem_band m L v, hv⟩, zero_mul]
simp
· rw [not_ne_iff.mp hv, mul_zero]
simp
have hpinQ : pinSubst m L Q = 0 :=
(mul_eq_zero.mp hmul).resolve_right hP
calc
eval (paramEval θ) Q =
eval (paramEval θ) (pinSubst m L Q) :=
(eval_pinSubst_of_mem_band hband Q).symm
_ = 0 := by rw [hpinQ]; simp
theorem isZariskiOpen_dense_genericParameterLocus
The generic retained-band parameter locus is relatively Zariski-open and dense in the paper's finite structural parameter space.
Formal statement
hypotheses
m L :
ℕ
conclusion
Proof (Lean source)
lemma isZariskiOpen_dense_genericParameterLocus (m L : ℕ) :
IsZariskiOpenParamIn L (genericParameterLocus m L) ∧
IsZariskiDenseParamIn L (genericParameterLocus m L) := by
rw [genericParameterLocus_eq_nonvanishing_poly]
apply isZariskiOpenIn_denseIn_of_pinSubst_ne_zero
let θG : ParamSpace ℂ m :=
(1, (fun i => ((i.val + 2 : ℕ) : ℂ)),
fun _ r => if 2 ≤ r ∧ r ≤ L then 1 else 0)
apply pinSubst_ne_zero_of_pinned_witness (genericParameterPolynomial m L) θG
· intro j r hout
simp only [θG]
split_ifs with hir
· omega
· rfl
· rw [eval_genericParameterPolynomial]
apply mul_ne_zero
· apply mul_ne_zero
· apply mul_ne_zero
· norm_num [θG]
· rw [Finset.prod_ne_zero_iff]
intro i hi
apply sub_ne_zero.mpr
intro heq
change (1 : ℂ) = ((i.val + 2 : ℕ) : ℂ) at heq
have : (1 : ℕ) = i.val + 2 := by exact_mod_cast heq
omega
· rw [Finset.prod_ne_zero_iff]
intro i hi
rw [Finset.prod_ne_zero_iff]
intro i' hi'
by_cases hii : i < i'
· simp only [hii, if_true]
apply sub_ne_zero.mpr
intro heq
change ((i.val + 2 : ℕ) : ℂ) = ((i'.val + 2 : ℕ) : ℂ) at heq
have : i.val + 2 = i'.val + 2 := by exact_mod_cast heq
omega
· simp [hii]
· rw [Finset.prod_ne_zero_iff]
intro j hj
rw [Finset.prod_ne_zero_iff]
intro r hr
have hr' : 2 ≤ r ∧ r ≤ L := Finset.mem_Icc.mp hr
simp [θG, hr']
Selector 39 declarations The note defines the arrow decision on the rank-open locus by *"factoring the recovered degree-n support annihilator Q_D from the contractions of the divided-power forms f_{n+k}"* (def:global-feasible-fiber-decision; wri
The apolar route: divided-power blocks and their contractions
The note defines the arrow decision on the rank-open locus by "factoring the recovered degree-n
support annihilator Q_D from the contractions of the divided-power forms f_{n+k}"
(def:global-feasible-fiber-decision; writeup.tex §thm:generic-apolar-arrow-recovery). Q_D is
therefore not just some squarefree product over a recovered support — it is the generator of the
common contraction kernel. These three primitives let the certificate say exactly that, so the
definition carries the note's own characterization of Q_D rather than a downstream consequence of
it. (They mirror dividedPowerBlock / diffApply / supportAnnihilator of
Helpers/ApolarDefs.lean, which are stated over ℂ; the certificate lives over ℝ.)
def RealParamCoord
Coordinate index of the real structural parameter space (direct slope, the m latent slopes, and the weight family (j, r)).
Definition (Lean source)
def realParamEval
Evaluate the real parameter coordinates of θ at a coordinate index.
Definition (Lean source)
def realParamEval {m : ℕ} (θ : ParamSpace ℝ m) : RealParamCoord m → ℝ
| inl _ => θ.1
| inr (inl i) => θ.2.1 i
| inr (inr jr) => θ.2.2 jr.1 jr.2
A proper real algebraic subset of the parameter space: the (real) zero locus of a nonzero real polynomial in the parameter coordinates. Nonzeroness of the polynomial makes it a proper subset (its complement is Zariski-dense), which is the paper's genericity notion — deletion of a proper real algebraic subset.
Definition (Lean source)
def IsProperRealAlgebraicSubset {m : ℕ} (excl : Set (ParamSpace ℝ m)) : Prop :=
∃ P : MvPolynomial (RealParamCoord m) ℝ, P ≠ 0 ∧
excl = { θ | eval (realParamEval θ) P = 0 }
inductive Direction
Causal direction value.
Definition (Lean source)
instance instDecidableEqDirection
Provides a procedure that decides whether two causal directions are equal.
Definition (Lean source)
deriving DecidableEq
def momentFromCumulants
Raw moments μ_r = B_r(0, k_2, …, k_r) from a centered cumulant list k (with k 1 = 0 supplied by the caller), via the exponential/Bell set-partition formula μ_r = Σ_{π} ∏_{B∈π} k_{|B|}.
Definition (Lean source)
def momentFromCumulants (k : ℕ → ℝ) (r : ℕ) : ℝ :=
∑ π : Finpartition (Finset.univ : Finset (Fin r)), ∏ B ∈ π.parts, k B.card
Finite atomic (Hankel-PSD / truncated Hamburger) certificate Q_K(k): the raw moments μ_r(k) (1 ≤ r ≤ K) are the moments of an n-atom probability law with μ_2 > 0. Its equivalence with real non-Gaussian finite-K source realizability is the external interface I-4.
Definition (Lean source)
def atomicCertificate (n K : ℕ) (k : ℕ → ℝ) : Prop :=
∃ w z : Fin n → ℝ,
(∑ h, w h = 1) ∧ (∀ h, 0 ≤ w h) ∧
(∀ r, 1 ≤ r → r ≤ K → ∑ h, w h * (z h) ^ r = momentFromCumulants k r) ∧
0 < momentFromCumulants k 2
Global feasible-fiber feasibility formula FeasFiber^b_m(t) at order K = 2m + 2 (the existential-atomic-feasibility component of the bundled def:global-feasible-fiber-decision, feasibleFiberDecision below). Its truth value is exactly the nonemptiness of R^b_{m,K}(t) ∩ F^b_{m,K}: there exist b-loading and source-cumulant coordinates λ that are real moment-feasible (λ ∈ F^b_{m,K}, which already carries the nonzero direct slope, the pairwise-distinct finite slopes, the finite-band cumulant coordinates, and the real non-Gaussian source realizability whose finite atomic Q_K reformulation is interface I-4) with Φ^b(λ) = t. By construction this def is the exact feasible-fiber equivalence; the atomic Q_K reformulation is atomicCertificate below.
Definition (Lean source)
def feasibleFiberFormula (m : ℕ) (Φ : ParamSpace ℝ m → CumVec ℝ) (t : CumVec ℝ) : Prop :=
∃ lam : ParamSpace ℝ m,
Φ lam = t ∧
lam.1 ≠ 0 ∧
Injective (Fin.cons lam.1 lam.2.1 : Fin (m + 1) → ℝ) ∧
∀ j : Fin (m + 2),
atomicCertificate (m + 2) (2 * m + 2)
(fun r => if 2 ≤ r then lam.2.2 j r else 0)
inductive PolynomialSign
Signs used by a finite polynomial sign table.
Definition (Lean source)
inductive PolynomialSign
| negative
| zero
| positive
deriving DecidableEq
instance instDecidableEqPolynomialSign
Provides a procedure that decides whether two polynomial signs are equal.
Definition (Lean source)
deriving DecidableEq
def polynomialSign
Sign of a real number.
Definition (Lean source)
noncomputable def polynomialSign (x : ℝ) : PolynomialSign :=
if x < 0 then .negative else if x = 0 then .zero else .positive
A function on cumulant vectors is given by a finite semialgebraic sign table: finitely many observable-coordinate polynomials are evaluated and their signs are looked up in a finite table.
Definition (Lean source)
def IsFiniteSemialgebraicFunction {α : Type} (f : CumVec ℝ → α) : Prop :=
∃ tests : Finset (MvPolynomial (ℕ × ℕ) ℝ),
∃ table : (tests → PolynomialSign) → α,
∀ t, f t = table (fun P => polynomialSign
(eval (fun ra => t ra.1 ra.2) P.1))
inductive FiberDecisionVariableBlock
The three variable blocks in the prescribed CAD order.
Definition (Lean source)
inductive FiberDecisionVariableBlock
| observable
| loadingAndCumulants
| atomicWitnesses
deriving DecidableEq
instance instDecidableEqFiberDecisionVariableBlock
Provides a procedure that decides whether two variable blocks of the fiber decision problem are equal.
Definition (Lean source)
deriving DecidableEq
The prescribed elimination order is t, then λ, then atomic witnesses.
Definition (Lean source)
def PrescribedFiberVariableOrder (before : FiberDecisionVariableBlock →
FiberDecisionVariableBlock → Prop) : Prop :=
before .observable .loadingAndCumulants ∧
before .observable .atomicWitnesses ∧
before .loadingAndCumulants .atomicWitnesses
A stacked cumulant vector is band-supported when it vanishes off the retained range 2 ≤ r ≤ 2m + 2, a ≤ r — the only coordinates the order-(2m+2) truncation records. Every cumulant map Φ^b_{m,2m+2} lands here (it is defined to be 0 off the band), so this is exactly the observable coordinate space the paper's decision procedure ranges over.
Definition (Lean source)
def BandSupported (m : ℕ) (t : CumVec ℝ) : Prop :=
∀ r a, ¬ (2 ≤ r ∧ r ≤ 2 * m + 2 ∧ a ≤ r) → t r a = 0
def IsOrderedFeasibleFiberCADDecision Definition aux_IsOrderedFeasibleFiberCADDecision in the paper ↗
A finite sign-table decision obtained by CAD using the paper's prescribed t, then λ, then atomic-witness variable-block order, and deciding the stated feasible-fiber formula on the band-supported observable coordinates. Keeping the order as an argument of the certificate ties it to this CAD decision rather than recording an unrelated order witness.
Definition (Lean source)
def IsOrderedFeasibleFiberCADDecision (m : ℕ) (Φ : ParamSpace ℝ m → CumVec ℝ)
(before : FiberDecisionVariableBlock → FiberDecisionVariableBlock → Prop)
(decide : CumVec ℝ → Bool) : Prop :=
PrescribedFiberVariableOrder before ∧
IsFiniteSemialgebraicFunction decide ∧
∀ t, BandSupported m t → (decide t = true ↔ feasibleFiberFormula m Φ t)
def fixedAxis
The fixed projective axis belonging to an arrow parameterization.
def directionCumulantMap
The direction-specific cumulant map used by the arrow certificate.
Definition (Lean source)
def directionCumulantMap (m : ℕ) : Direction → ParamSpace ℝ m → CumVec ℝ
| .forward => forwardCumulantMap m (2 * m + 2)
| .reverse => reverseCumulantMap m (2 * m + 2)
A genuine polynomial rank-open locus: a nonempty principal open set cut out by nonvanishing of a nonzero observable-coordinate minor.
Definition (Lean source)
def IsPolynomialRankOpen (rankOpen : Set (CumVec ℝ)) : Prop :=
∃ minor : MvPolynomial (ℕ × ℕ) ℝ,
minor ≠ 0 ∧ rankOpen.Nonempty ∧
rankOpen = { t | eval (fun ra => t ra.1 ra.2) minor ≠ 0 }
def SupportExplainsCumulantBlocks
The retained divided-power cumulant blocks of t admit the displayed m+2-direction support with order-specific source weights.
Definition (Lean source)
def SupportExplainsCumulantBlocks (m : ℕ) (t : CumVec ℝ)
(support : Fin (m + 2) → ℝ × ℝ) : Prop :=
∃ weights : Fin (m + 2) → ℕ → ℝ,
∀ r a, 2 ≤ r → r ≤ 2 * m + 2 → a ≤ r →
t r a = ∑ j, weights j r * (support j).1 ^ (r - a) * (support j).2 ^ a
Two nonzero affine representatives determine the same projective direction.
Definition (Lean source)
def ProjectivelyEquivalent (u v : ℝ × ℝ) : Prop :=
u ≠ (0, 0) ∧ ∃ c : ℝ, c ≠ 0 ∧ v = (c * u.1, c * u.2)
def ProjectivelyDistinct
A support list has pairwise distinct projective directions.
Definition (Lean source)
def ProjectivelyDistinct {n : ℕ} (support : Fin n → ℝ × ℝ) : Prop :=
∀ i j, ProjectivelyEquivalent (support i) (support j) → i = j
def SameProjectiveSupport
Equality of unordered supports in projective space, allowing an independent nonzero rescaling of every displayed affine representative.
Definition (Lean source)
def SameProjectiveSupport {n : ℕ}
(support support' : Fin n → ℝ × ℝ) : Prop :=
∀ z : ℝ × ℝ,
(∃ i, ProjectivelyEquivalent z (support i)) ↔
(∃ i, ProjectivelyEquivalent z (support' i))
On the rank-open locus the support is recovered from the simultaneous divided-power blocks: every other projectively distinct m+2-direction decomposition has the same unordered projective support.
Definition (Lean source)
def IsRecoveredSupport (m : ℕ) (t : CumVec ℝ)
(support : Fin (m + 2) → ℝ × ℝ) : Prop :=
ProjectivelyDistinct support ∧ SupportExplainsCumulantBlocks m t support ∧
∀ support' : Fin (m + 2) → ℝ × ℝ,
ProjectivelyDistinct support' → SupportExplainsCumulantBlocks m t support' →
SameProjectiveSupport support' support
def realDividedPowerBlock
Real divided-power binary form of the order-r cumulant block: f_r(x, y) = Σ_{a=0}^r C(r,a) t_{r,a} x^{r-a} y^a (with x = X 0, y = X 1).
Definition (Lean source)
noncomputable def realDividedPowerBlock (t : CumVec ℝ) (r : ℕ) : MvPolynomial (Fin 2) ℝ :=
∑ a ∈ range (r + 1),
C ((Nat.choose r a : ℝ) * t r a)
* X 0 ^ (r - a) * X 1 ^ a
def realDiffApply
The apolar contraction q(∂) f of a binary form f by the constant-coefficient differential operator with symbol q.
Definition (Lean source)
noncomputable def realDiffApply (q f : MvPolynomial (Fin 2) ℝ) : MvPolynomial (Fin 2) ℝ :=
∑ d ∈ q.support,
coeff d q •
((fun g => (pderiv (0 : Fin 2)) g)^[d 0]
((fun g => (pderiv (1 : Fin 2)) g)^[d 1] f))
def realSupportAnnihilatorPoly
The squarefree degree-n support annihilator Q_D = ∏_{ℓ ∈ D} ℓ^⊥ as a real binary form, in the same sign convention as the evaluation-form product used by the certificate below.
Definition (Lean source)
noncomputable def realSupportAnnihilatorPoly {m : ℕ} (support : Fin (m + 2) → ℝ × ℝ) :
MvPolynomial (Fin 2) ℝ :=
∏ j : Fin (m + 2),
(C (support j).1 * X 1 -
C (support j).2 * X 0)
The recovered squarefree support-annihilator certificate on the apolar rank-open locus. Q_D is characterized exactly as the note characterizes it — as the generator of the common kernel of the contractions q ↦ (q(∂) f_{n+k})_{0 ≤ k ≤ n-2} of the divided-power blocks, n = m + 2 — and it is then factored into the m+2 support directions, from which the decision is read off membership of the arrow's fixed axis.
Definition (Lean source)
def ApolarFiberDecisionCertificate (m : ℕ) (b : Direction)
(Φ : ParamSpace ℝ m → CumVec ℝ) (decide : CumVec ℝ → Bool) : Prop :=
Φ = directionCumulantMap m b ∧
∃ rankOpen : Set (CumVec ℝ),
∃ support : CumVec ℝ → Fin (m + 2) → ℝ × ℝ,
∃ annihilator : CumVec ℝ → ℝ × ℝ → ℝ,
IsPolynomialRankOpen rankOpen ∧
(∀ t ∈ rankOpen, IsRecoveredSupport m t (support t)) ∧
(∀ t ∈ rankOpen, ∀ z,
annihilator t z = ∏ j, ((support t j).1 * z.2 - (support t j).2 * z.1)) ∧
-- `Q_D` is the evaluation of the degree-`n` binary form `realSupportAnnihilatorPoly`,
(∀ t ∈ rankOpen, ∀ z : ℝ × ℝ,
annihilator t z =
eval ![z.1, z.2] (realSupportAnnihilatorPoly (support t))) ∧
-- and that form SPANS the common kernel of the contractions of the divided-power blocks
-- `f_{n+k}`, `0 ≤ k ≤ n-2` — the note's defining characterization of `Q_D`.
(∀ t ∈ rankOpen, ∀ q : MvPolynomial (Fin 2) ℝ, q.IsHomogeneous (m + 2) →
((∀ k ≤ m, realDiffApply q (realDividedPowerBlock t (m + 2 + k)) = 0) ↔
∃ c : ℝ, q = c • realSupportAnnihilatorPoly (support t))) ∧
(∀ t ∈ rankOpen, BandSupported m t →
(decide t = true ↔
feasibleFiberFormula m Φ t ∧
∃ j, ProjectivelyEquivalent (fixedAxis b) (support t j)))
Operational structure required by the paper: a finite semialgebraic real-QE/CAD decision, with the prescribed variable-block order, and its apolar support-annihilator implementation on the rank-open locus.
Definition (Lean source)
def feasibleFiberDecisionInterfaces (m : ℕ) (b : Direction)
(Φ : ParamSpace ℝ m → CumVec ℝ) : Prop :=
∃ cadDecide : CumVec ℝ → Bool,
(∃ before, IsOrderedFeasibleFiberCADDecision m Φ before cadDecide) ∧
ApolarFiberDecisionCertificate m b Φ cadDecide
def feasibleFiberDecision
Global feasible-fiber decision FeasFiber^b_m — the full object the paper's def:global-feasible-fiber-decision defines, bundled as a pair so the extracted definition carries both the existential atomic feasibility formula and the paper's operational decision structure (not only the existential Prop, which alone under-records the paper):
Definition (Lean source)
-- @node: def:global-feasible-fiber-decision
def feasibleFiberDecision (m : ℕ) (b : Direction) : (CumVec ℝ → Prop) × Prop :=
(fun t => feasibleFiberFormula m (directionCumulantMap m b) t,
feasibleFiberDecisionInterfaces m b (directionCumulantMap m b))
def directionSelector
Separate-fiber direction selector S_m(t) (the two-branch relational component of the bundled def:direction-selector, directionSelectorWithDecision below): forward when the forward feasible-fiber formula holds and the reverse fails, reverse in the mirror case, and undefined (none) otherwise. The Option-valued map encodes only the two-branch relation; any claim that S_m is an evaluable finite semialgebraic decision procedure rests on the external interface I-3 and is not encoded (the definition is noncomputable, decided classically). @realizes S_m(two-branch partial direction map)
Definition (Lean source)
noncomputable def directionSelector (m : ℕ) (t : CumVec ℝ) : Option Direction :=
if feasibleFiberFormula m (forwardCumulantMap m (2 * m + 2)) t
∧ ¬ feasibleFiberFormula m (reverseCumulantMap m (2 * m + 2)) t then
some Direction.forward
else if feasibleFiberFormula m (reverseCumulantMap m (2 * m + 2)) t
∧ ¬ feasibleFiberFormula m (forwardCumulantMap m (2 * m + 2)) t then
some Direction.reverse
else
none
def separatedSelectorDomain
The separated observable domain on which exactly one feasible arrow remains.
Definition (Lean source)
def separatedSelectorDomain (m : ℕ) : Set (CumVec ℝ) :=
{ t | (feasibleFiberFormula m (forwardCumulantMap m (2 * m + 2)) t ∧
¬ feasibleFiberFormula m (reverseCumulantMap m (2 * m + 2)) t) ∨
(feasibleFiberFormula m (reverseCumulantMap m (2 * m + 2)) t ∧
¬ feasibleFiberFormula m (forwardCumulantMap m (2 * m + 2)) t) }
def directionSelectorDecisionInterfaces Definition aux_directionSelectorDecisionInterfaces in the paper ↗
Operational selector structure: one finite semialgebraic procedure on the declared separated domain, together with the two arrow-specific apolar support-annihilator factorizations implementing its generic branches.
Definition (Lean source)
def directionSelectorDecisionInterfaces (m : ℕ) : Prop :=
∃ selDecide : CumVec ℝ → Option Direction,
IsFiniteSemialgebraicFunction selDecide ∧
(∀ t ∈ separatedSelectorDomain m, selDecide t = directionSelector m t) ∧
(∃ forwardDecide reverseDecide : CumVec ℝ → Bool,
ApolarFiberDecisionCertificate m .forward
(forwardCumulantMap m (2 * m + 2)) forwardDecide ∧
ApolarFiberDecisionCertificate m .reverse
(reverseCumulantMap m (2 * m + 2)) reverseDecide ∧
∀ t ∈ separatedSelectorDomain m,
selDecide t = if forwardDecide t then some .forward
else if reverseDecide t then some .reverse else none)
def directionSelectorWithDecision
Separate-fiber direction selector S_m — the full object the paper's def:direction-selector defines, bundled so the extracted definition carries both the two-branch selection map and the paper's operational decision structure (not only the weaker noncomputable classical two-branch relation):
Definition (Lean source)
-- @node: def:direction-selector
noncomputable def directionSelectorWithDecision (m : ℕ) :
(CumVec ℝ → Option Direction) × Prop :=
(directionSelector m, directionSelectorDecisionInterfaces m)
structure StructuralModel
Structural-model witness M: a bivariate LvLiNGAM structural model carrying its observational law P_M = law, its directed edge D(M) = edge, and a direction-specific real moment-feasible parameter list param ∈ F^b_{m,K} (with b = edge) that realizes the truncated cumulant observation T_K(P_M) through order K, together with the corresponding LvLiNGAM class membership. This carries the model / representation identity (P_M and its feasible parameters) that a bare observational measure would lose. @realizes M,P_M,D(M),M^{sep}_{m,K}(model M: law P_M, edge D(M), feasible param)
Definition (Lean source)
parameters
m K :
ℕ
fields
The observational law `P_M ∈ Laws(ℝ²)`.
law :
Measure (ℝ × ℝ)
The directed edge `D(M)`.
edge :
The model's own direction-specific real moment-feasible representation parameter.
param :
ParamSpace ℝ m
Real feasibility of `param` (nonzero edge, distinct slopes, source realizability).
feasible :
param ∈ realFeasibleRegion m K
`M` is a forward (resp. reverse) LvLiNGAM model represented by its own
feasible parameter: the parameter's slopes and source-cumulant weights are
exactly those of the sources generating `P_M`, and its simultaneous binary-form
image is the truncated cumulant of `P_M`.
realizes :
(edge = Direction.forward → ForwardLvLiNGAMRep law m K param ∧ forwardCumulantMap m K param = truncatedCumulant law fst snd K) ∧
(edge = Direction.reverse → ReverseLvLiNGAMRep law m K param ∧ reverseCumulantMap m K param = truncatedCumulant law fst snd K)
Separated nonzero-edge structural-model domain M^{sep}_{m,K}, a K-explicit set of structural models M : StructuralModel m K (each carrying its law P_M, edge D(M), and direction-specific feasible parameters). Membership imposes opposite-arrow fiber emptiness at T_K(P_M): a forward model whose reverse feasible fiber over T_K(P_M) is empty, or a reverse model whose forward feasible fiber over T_K(P_M) is empty. The domain retains the model / representation identity and the explicit truncation order K. @realizes M,P_M,D(M),M^{sep}_{m,K}(models M with empty opposite fiber at T_K(P_M))
Definition (Lean source)
-- @node: def:separated-model-domain
def separatedModelDomain (m K : ℕ) : Set (StructuralModel m K) :=
{ M |
(M.edge = Direction.forward ∧
¬ ∃ η ∈ realFeasibleRegion m K,
reverseCumulantMap m K η = truncatedCumulant M.law fst snd K)
∨ (M.edge = Direction.reverse ∧
¬ ∃ θ ∈ realFeasibleRegion m K,
forwardCumulantMap m K θ = truncatedCumulant M.law fst snd K) }
Generic arrow separation at order L: off a proper real algebraic subset of each real feasible region, no arrow value admits an opposite-region representation. The excluded set is constrained to be a proper real algebraic subset (the zero locus of a nonzero real polynomial), matching the paper's genericity notion; an arbitrary excluded set is not permitted. Helper for def:information-order.
Definition (Lean source)
def separatesAtOrder (m L : ℕ) : Prop :=
(∃ excl : Set (ParamSpace ℝ m),
IsProperRealAlgebraicSubset excl ∧
(∃ θ ∈ realFeasibleRegion m L, θ ∉ excl) ∧
∀ θ ∈ realFeasibleRegion m L, θ ∉ excl →
¬ ∃ η ∈ realFeasibleRegion m L, forwardCumulantMap m L θ = reverseCumulantMap m L η)
∧ (∃ excl : Set (ParamSpace ℝ m),
IsProperRealAlgebraicSubset excl ∧
(∃ η ∈ realFeasibleRegion m L, η ∉ excl) ∧
∀ η ∈ realFeasibleRegion m L, η ∉ excl →
¬ ∃ θ ∈ realFeasibleRegion m L, reverseCumulantMap m L η = forwardCumulantMap m L θ)
def informationOrder
Generic real information order K^star(m): the least L ≥ 2 at which the arrow is generically separated over both real feasible regions, and ⊤ = ∞ if no such L exists. @realizes K^star(m)(least separating truncation order)
Definition (Lean source)
-- @node: def:information-order
noncomputable def informationOrder (m : ℕ) : ℕ∞ :=
sInf { L : ℕ∞ | ∃ L₀ : ℕ, L = (L₀ : ℕ∞) ∧ 2 ≤ L₀ ∧ separatesAtOrder m L₀ }
TAdmissibleSwaps 1 declarations In-scope crux: admissible swaps preserve the arrow
In-scope crux: admissible swaps preserve the arrow
theorem admissibleSwaps_preserve_direction
Admissible swaps preserve direction. For each π ∈ G_m:
Formal statement
hypotheses
m L :
ℕ
hm :
hL :
ValidOrder m L
COMPLEX parameters carry the map/orbit invariance: the note states invariance and quotient behaviour for the **complex** `Θ`-fibers (`fiberCorrespondence`, `quotientFiber`, `admissibleOrbit` are all complex), so specializing those clauses to `ℝ` would understate the claim.
θc ηc :
ParamSpace ℂ m
REAL parameters carry the feasible structural-model preservation: real feasibility (`realFeasibleRegion`) and the LvLiNGAM source witnesses are real objects.
θ η :
ParamSpace ℝ m
Pforward Preverse :
Measure (ℝ × ℝ)
conclusion
(forwardCumulantMap m L (admissibleSourceSwap m π θc) = forwardCumulantMap m L θc ∧ reverseCumulantMap m L (admissibleSourceSwap m π ηc) = reverseCumulantMap m L ηc) ∧
(∀ {Ω : Type} [MeasurableSpace Ω] (μ : Measure Ω) (S : Fin (m + 2) → Ω → ℝ) (X Y : Ω → ℝ), θ ∈ realFeasibleRegion m L → IsProbabilityMeasure μ → Pforward = μ.map (fun ω => (X ω, Y ω)) → IndependentSources μ S → (∀ j, ∫ ω, S j ω ∂μ = 0) → SourceNonGaussian μ S → FiniteCumulants μ S (2 * m + 2) → ForwardAxisModel X Y S θ.1 θ.2.1 → ForwardNonCollinear θ.1 θ.2.1 → ForwardNonzeroEdge θ.1 → (∀ j, ∀ r, 2 ≤ r → r ≤ L → sourceCumulant μ (S j) r = θ.2.2 j r) → IndependentSources μ (fun i => S (permMiddle m π i)) ∧ (∀ j, ∫ ω, S (permMiddle m π j) ω ∂μ = 0) ∧ SourceNonGaussian μ (fun i => S (permMiddle m π i)) ∧ FiniteCumulants μ (fun i => S (permMiddle m π i)) (2 * m + 2) ∧ ForwardAxisModel X Y (fun i => S (permMiddle m π i)) (admissibleSourceSwap m π θ).1 (admissibleSourceSwap m π θ).2.1 ∧ ForwardNonCollinear (admissibleSourceSwap m π θ).1 (admissibleSourceSwap m π θ).2.1 ∧ ForwardNonzeroEdge (admissibleSourceSwap m π θ).1 ∧ (∀ j, ∀ r, 2 ≤ r → r ≤ L → sourceCumulant μ (S (permMiddle m π j)) r = (admissibleSourceSwap m π θ).2.2 j r) ∧ ForwardLvLiNGAM Pforward m) ∧
(∀ {Ω : Type} [MeasurableSpace Ω] (μ : Measure Ω) (S : Fin (m + 2) → Ω → ℝ) (X Y : Ω → ℝ), η ∈ realFeasibleRegion m L → IsProbabilityMeasure μ → Preverse = μ.map (fun ω => (X ω, Y ω)) → IndependentSources μ S → (∀ j, ∫ ω, S j ω ∂μ = 0) → SourceNonGaussian μ S → FiniteCumulants μ S (2 * m + 2) → ReverseAxisModel X Y S η.1 η.2.1 → ReverseNonCollinear η.1 η.2.1 → ReverseNonzeroEdge η.1 → (∀ j, ∀ r, 2 ≤ r → r ≤ L → sourceCumulant μ (S j) r = η.2.2 j r) → IndependentSources μ (fun i => S (permMiddle m π i)) ∧ (∀ j, ∫ ω, S (permMiddle m π j) ω ∂μ = 0) ∧ SourceNonGaussian μ (fun i => S (permMiddle m π i)) ∧ FiniteCumulants μ (fun i => S (permMiddle m π i)) (2 * m + 2) ∧ ReverseAxisModel X Y (fun i => S (permMiddle m π i)) (admissibleSourceSwap m π η).1 (admissibleSourceSwap m π η).2.1 ∧ ReverseNonCollinear (admissibleSourceSwap m π η).1 (admissibleSourceSwap m π η).2.1 ∧ ReverseNonzeroEdge (admissibleSourceSwap m π η).1 ∧ (∀ j, ∀ r, 2 ≤ r → r ≤ L → sourceCumulant μ (S (permMiddle m π j)) r = (admissibleSourceSwap m π η).2.2 j r) ∧ ReverseLvLiNGAM Preverse m) ∧
(∀ M : StructuralModel m L, M.edge = Direction.forward → M.param = θ → ∃ M' : StructuralModel m L, M'.law = M.law ∧ M'.edge = Direction.forward ∧ M'.param = admissibleSourceSwap m π θ) ∧
(∀ M : StructuralModel m L, M.edge = Direction.reverse → M.param = η → ∃ M' : StructuralModel m L, M'.law = M.law ∧ M'.edge = Direction.reverse ∧ M'.param = admissibleSourceSwap m π η) ∧
((∀ j : Fin (m + 2), (admissibleSourceSwapArrow m Arrow.right π θc).2.2 j = fun r => θc.2.2 (permMiddle m π j) r) ∧ (∀ j : Fin (m + 2), (admissibleSourceSwapArrow m Arrow.left π ηc).2.2 j = fun r => ηc.2.2 (permMiddle m π j) r) ∧ (∀ j : Fin (m + 2), j.val = 0 ∨ j.val = m + 1 → forwardLoading m (admissibleSourceSwap m π θc).1 (admissibleSourceSwap m π θc).2.1 j = forwardLoading m θc.1 θc.2.1 j) ∧ (∀ π' : Perm (Fin m), (admissibleSourceSwapTagged m π' (Arrow.right, θc)).1 = Arrow.right ∧ (admissibleSourceSwapTagged m π' (Arrow.left, ηc)).1 = Arrow.left) ∧ Disjoint (arrowTaggedOrbit m Arrow.right θc) (arrowTaggedOrbit m Arrow.left ηc)) ∧
(∀ σ : Perm (Fin m), forwardCumulantMap m L (admissibleSourceSwap m σ θc) = forwardCumulantMap m L θc ∧ reverseCumulantMap m L (admissibleSourceSwap m σ ηc) = reverseCumulantMap m L ηc)
Proof (Lean source)
-- @node: lem:admissible-swaps-preserve-direction
lemma admissibleSwaps_preserve_direction (m L : ℕ)
(hm : ValidComplexity m) (hL : ValidOrder m L)
(π : Perm (Fin m))
-- COMPLEX parameters carry the map/orbit invariance: the note states invariance and
-- quotient behaviour for the **complex** `Θ`-fibers (`fiberCorrespondence`,
-- `quotientFiber`, `admissibleOrbit` are all complex), so specializing those clauses
-- to `ℝ` would understate the claim.
(θc ηc : ParamSpace ℂ m)
-- REAL parameters carry the feasible structural-model preservation: real feasibility
-- (`realFeasibleRegion`) and the LvLiNGAM source witnesses are real objects.
(θ η : ParamSpace ℝ m)
(Pforward Preverse : Measure (ℝ × ℝ)) :
-- (1) map invariance (both arrows), on the COMPLEX fibers:
(forwardCumulantMap m L (admissibleSourceSwap m π θc) = forwardCumulantMap m L θc ∧
reverseCumulantMap m L (admissibleSourceSwap m π ηc) = reverseCumulantMap m L ηc) ∧
-- (2) real-feasibility preservation (both arrows):
(θ ∈ realFeasibleRegion m L → admissibleSourceSwap m π θ ∈ realFeasibleRegion m L) ∧
(η ∈ realFeasibleRegion m L → admissibleSourceSwap m π η ∈ realFeasibleRegion m L) ∧
-- (3) full forward LvLiNGAM preservation under the source relabeling
-- `S'_i = S_{π(i)}` (independence, centering, non-Gaussianity, moments,
-- noncollinearity, nonzero edge, structural equation, pushforward law):
(∀ {Ω : Type} [MeasurableSpace Ω] (μ : Measure Ω) (S : Fin (m + 2) → Ω → ℝ)
(X Y : Ω → ℝ),
-- the paper conditions model preservation on the forward parameter being
-- real-feasible (`θ ∈ F^right_{m,L}`) and on the declared valid order range:
θ ∈ realFeasibleRegion m L → IsProbabilityMeasure μ →
Pforward = μ.map (fun ω => (X ω, Y ω)) →
IndependentSources μ S → (∀ j, ∫ ω, S j ω ∂μ = 0) → SourceNonGaussian μ S →
FiniteCumulants μ S (2 * m + 2) → ForwardAxisModel X Y S θ.1 θ.2.1 →
ForwardNonCollinear θ.1 θ.2.1 → ForwardNonzeroEdge θ.1 →
-- the model's actual source cumulants ARE its parameter weights `θ.2.2`:
(∀ j, ∀ r, 2 ≤ r → r ≤ L → sourceCumulant μ (S j) r = θ.2.2 j r) →
IndependentSources μ (fun i => S (permMiddle m π i)) ∧
(∀ j, ∫ ω, S (permMiddle m π j) ω ∂μ = 0) ∧
SourceNonGaussian μ (fun i => S (permMiddle m π i)) ∧
FiniteCumulants μ (fun i => S (permMiddle m π i)) (2 * m + 2) ∧
ForwardAxisModel X Y (fun i => S (permMiddle m π i))
(admissibleSourceSwap m π θ).1 (admissibleSourceSwap m π θ).2.1 ∧
ForwardNonCollinear (admissibleSourceSwap m π θ).1 (admissibleSourceSwap m π θ).2.1 ∧
ForwardNonzeroEdge (admissibleSourceSwap m π θ).1 ∧
-- the relabeled model's source cumulants are the SWAPPED weights, so the
-- model–parameter link is transported by the swap:
(∀ j, ∀ r, 2 ≤ r → r ≤ L →
sourceCumulant μ (S (permMiddle m π j)) r = (admissibleSourceSwap m π θ).2.2 j r) ∧
-- the relabeled witnesses therefore realize the same observational law
-- inside the forward LvLiNGAM class, which is the formal direction verdict:
ForwardLvLiNGAM Pforward m) ∧
-- reverse mirror:
(∀ {Ω : Type} [MeasurableSpace Ω] (μ : Measure Ω) (S : Fin (m + 2) → Ω → ℝ)
(X Y : Ω → ℝ),
-- reverse mirror, conditioned on the reverse parameter being real-feasible
-- (`η ∈ F^left_{m,L}`) and on the declared valid order range:
η ∈ realFeasibleRegion m L → IsProbabilityMeasure μ →
Preverse = μ.map (fun ω => (X ω, Y ω)) →
IndependentSources μ S → (∀ j, ∫ ω, S j ω ∂μ = 0) → SourceNonGaussian μ S →
FiniteCumulants μ S (2 * m + 2) → ReverseAxisModel X Y S η.1 η.2.1 →
ReverseNonCollinear η.1 η.2.1 → ReverseNonzeroEdge η.1 →
-- the model's actual source cumulants ARE its parameter weights `η.2.2`:
(∀ j, ∀ r, 2 ≤ r → r ≤ L → sourceCumulant μ (S j) r = η.2.2 j r) →
IndependentSources μ (fun i => S (permMiddle m π i)) ∧
(∀ j, ∫ ω, S (permMiddle m π j) ω ∂μ = 0) ∧
SourceNonGaussian μ (fun i => S (permMiddle m π i)) ∧
FiniteCumulants μ (fun i => S (permMiddle m π i)) (2 * m + 2) ∧
ReverseAxisModel X Y (fun i => S (permMiddle m π i))
(admissibleSourceSwap m π η).1 (admissibleSourceSwap m π η).2.1 ∧
ReverseNonCollinear (admissibleSourceSwap m π η).1 (admissibleSourceSwap m π η).2.1 ∧
ReverseNonzeroEdge (admissibleSourceSwap m π η).1 ∧
-- the relabeled model's source cumulants are the SWAPPED weights:
(∀ j, ∀ r, 2 ≤ r → r ≤ L →
sourceCumulant μ (S (permMiddle m π j)) r = (admissibleSourceSwap m π η).2.2 j r) ∧
-- reverse mirror: the same observational law remains represented in the
-- reverse LvLiNGAM class, hence its structural arrow stays `Y → X`:
ReverseLvLiNGAM Preverse m) ∧
-- (4) explicit structural-model direction verdicts. These clauses state the
-- paper's `D(M) = X → Y` / `D(M) = Y → X` conclusion on the actual model
-- carrier, rather than leaving direction implicit in class membership. The
-- relabeled model has the same observational law and the swapped feasible
-- parameter, while its `edge` field records the unchanged causal direction.
(∀ M : StructuralModel m L,
M.edge = Direction.forward → M.param = θ →
∃ M' : StructuralModel m L,
M'.law = M.law ∧ M'.edge = Direction.forward ∧
M'.param = admissibleSourceSwap m π θ) ∧
(∀ M : StructuralModel m L,
M.edge = Direction.reverse → M.param = η →
∃ M' : StructuralModel m L,
M'.law = M.law ∧ M'.edge = Direction.reverse ∧
M'.param = admissibleSourceSwap m π η) ∧
-- (5) arrow-tagged quotient/orbit distinctness. The admissible `G_m` swap
-- relabels the source WEIGHT family, so each relabeled source's cumulants are
-- exactly the original weights `θ.2.2` (resp. `η.2.2`) at the permuted index —
-- linking the actual sources' cumulants to `θ.2.2`/`η.2.2`. The boundary loading
-- directions (indices `0`, `m+1`) are fixed by the swap. And for EVERY pair of
-- admissible swaps on the two arrows (`Arrow.right` for `θ`, `Arrow.left` for `η`)
-- the forward fixed vertical axis differs from the reverse fixed horizontal axis:
-- no admissible swap converts a forward axis pattern into a reverse one, so the
-- two arrow-tagged `G_m`-orbits are never identified:
((∀ j : Fin (m + 2),
(admissibleSourceSwapArrow m Arrow.right π θc).2.2 j
= fun r => θc.2.2 (permMiddle m π j) r) ∧
(∀ j : Fin (m + 2),
(admissibleSourceSwapArrow m Arrow.left π ηc).2.2 j
= fun r => ηc.2.2 (permMiddle m π j) r) ∧
(∀ j : Fin (m + 2), j.val = 0 ∨ j.val = m + 1 →
forwardLoading m (admissibleSourceSwap m π θc).1 (admissibleSourceSwap m π θc).2.1 j
= forwardLoading m θc.1 θc.2.1 j) ∧
-- arrow-tag preservation: the `G_m` action on `Arrow × ParamSpace` fixes the tag
-- `b`, so every image of a right-tagged (resp. left-tagged) parameter stays
-- right-tagged (resp. left-tagged):
(∀ π' : Perm (Fin m),
(admissibleSourceSwapTagged m π' (Arrow.right, θc)).1 = Arrow.right ∧
(admissibleSourceSwapTagged m π' (Arrow.left, ηc)).1 = Arrow.left) ∧
-- hence the right-tagged and left-tagged `G_m`-orbits are DISJOINT: no admissible
-- swap converts a forward-tagged parameter into a reverse-tagged one, so
-- quotienting a same-arrow fiber by `G_m` never identifies opposite arrows:
Disjoint (arrowTaggedOrbit m Arrow.right θc) (arrowTaggedOrbit m Arrow.left ηc)) ∧
-- (6) same-arrow map invariance under every relabeling `σ`, on the COMPLEX fibers:
(∀ σ : Perm (Fin m),
forwardCumulantMap m L (admissibleSourceSwap m σ θc) = forwardCumulantMap m L θc ∧
reverseCumulantMap m L (admissibleSourceSwap m σ ηc) = reverseCumulantMap m L ηc) := by
refine ⟨⟨forwardCumulantMap_admissibleSourceSwap m L π θc,
reverseCumulantMap_admissibleSourceSwap m L π ηc⟩,
realFeasibleRegion_admissibleSourceSwap m L π θ,
realFeasibleRegion_admissibleSourceSwap m L π η, ?_, ?_, ?_, ?_, ?_, ?_⟩
· intro Ω inst μ S X Y _hθ hprob hP hind hcenter hng hfinite haxis hnc hedge hcum
have hind' : IndependentSources μ (fun i => S (permMiddle m π i)) :=
hind.precomp (permMiddleEquiv m π).injective
have hcenter' : ∀ j, ∫ ω, S (permMiddle m π j) ω ∂μ = 0 :=
fun j => hcenter (permMiddle m π j)
have hng' : SourceNonGaussian μ (fun i => S (permMiddle m π i)) :=
fun j => hng (permMiddle m π j)
have hfinite' : FiniteCumulants μ (fun i => S (permMiddle m π i)) (2 * m + 2) :=
fun j => hfinite (permMiddle m π j)
have haxis' := forwardAxisModel_admissibleSourceSwap m π θ S X Y haxis
have hnc' : ForwardNonCollinear (admissibleSourceSwap m π θ).1
(admissibleSourceSwap m π θ).2.1 :=
finCons_comp_perm_injective θ.1 θ.2.1 π hnc
have hcum' : ∀ j r, 2 ≤ r → r ≤ L →
sourceCumulant μ (S (permMiddle m π j)) r =
(admissibleSourceSwap m π θ).2.2 j r := by
intro j r hr2 hrL
exact hcum (permMiddle m π j) r hr2 hrL
refine ⟨hind', hcenter', hng', hfinite', haxis', hnc', hedge, hcum', ?_⟩
exact ⟨Ω, inst, μ, (fun i => S (permMiddle m π i)), X, Y,
(admissibleSourceSwap m π θ).1, (admissibleSourceSwap m π θ).2.1,
hprob, hind', hfinite', hng', hcenter', haxis', hnc', hedge, hP⟩
· intro Ω inst μ S X Y _hη hprob hP hind hcenter hng hfinite haxis hnc hedge hcum
have hind' : IndependentSources μ (fun i => S (permMiddle m π i)) :=
hind.precomp (permMiddleEquiv m π).injective
have hcenter' : ∀ j, ∫ ω, S (permMiddle m π j) ω ∂μ = 0 :=
fun j => hcenter (permMiddle m π j)
have hng' : SourceNonGaussian μ (fun i => S (permMiddle m π i)) :=
fun j => hng (permMiddle m π j)
have hfinite' : FiniteCumulants μ (fun i => S (permMiddle m π i)) (2 * m + 2) :=
fun j => hfinite (permMiddle m π j)
have haxis' := reverseAxisModel_admissibleSourceSwap m π η S X Y haxis
have hnc' : ReverseNonCollinear (admissibleSourceSwap m π η).1
(admissibleSourceSwap m π η).2.1 :=
finCons_comp_perm_injective η.1 η.2.1 π hnc
have hcum' : ∀ j r, 2 ≤ r → r ≤ L →
sourceCumulant μ (S (permMiddle m π j)) r =
(admissibleSourceSwap m π η).2.2 j r := by
intro j r hr2 hrL
exact hcum (permMiddle m π j) r hr2 hrL
refine ⟨hind', hcenter', hng', hfinite', haxis', hnc', hedge, hcum', ?_⟩
exact ⟨Ω, inst, μ, (fun i => S (permMiddle m π i)), X, Y,
(admissibleSourceSwap m π η).1, (admissibleSourceSwap m π η).2.1,
hprob, hind', hfinite', hng', hcenter', haxis', hnc', hedge, hP⟩
· intro M hedge hparam
subst θ
obtain ⟨hrep, hmap⟩ := M.realizes.1 hedge
rcases hrep with
⟨Ω, inst, μ, S, X, Y, hprob, hind, hfinite, hng, hcenter, haxis, hnc,
hnonzero, hcum, hP⟩
letI : MeasurableSpace Ω := inst
have hind' : IndependentSources μ (fun i => S (permMiddle m π i)) :=
hind.precomp (permMiddleEquiv m π).injective
have hfinite' : FiniteCumulants μ (fun i => S (permMiddle m π i)) (2 * m + 2) :=
fun j => hfinite (permMiddle m π j)
have hng' : SourceNonGaussian μ (fun i => S (permMiddle m π i)) :=
fun j => hng (permMiddle m π j)
have hcenter' : ∀ j, ∫ ω, S (permMiddle m π j) ω ∂μ = 0 :=
fun j => hcenter (permMiddle m π j)
have haxis' := forwardAxisModel_admissibleSourceSwap m π M.param S X Y haxis
have hnc' : ForwardNonCollinear (admissibleSourceSwap m π M.param).1
(admissibleSourceSwap m π M.param).2.1 :=
finCons_comp_perm_injective M.param.1 M.param.2.1 π hnc
have hcum' : ∀ j r, 2 ≤ r → r ≤ L →
sourceCumulant μ (S (permMiddle m π j)) r =
(admissibleSourceSwap m π M.param).2.2 j r := by
intro j r hr2 hrL
exact hcum (permMiddle m π j) r hr2 hrL
refine ⟨{
law := M.law
edge := Direction.forward
param := admissibleSourceSwap m π M.param
feasible := realFeasibleRegion_admissibleSourceSwap m L π M.param M.feasible
realizes := ?_
}, rfl, rfl, rfl⟩
constructor
· intro _
constructor
· exact ⟨Ω, inst, μ, (fun i => S (permMiddle m π i)), X, Y,
hprob, hind', hfinite', hng', hcenter', haxis', hnc', hnonzero, hcum', hP⟩
· exact (forwardCumulantMap_admissibleSourceSwap m L π M.param).trans hmap
· intro hcontra
simp at hcontra
· intro M hedge hparam
subst η
obtain ⟨hrep, hmap⟩ := M.realizes.2 hedge
rcases hrep with
⟨Ω, inst, μ, S, X, Y, hprob, hind, hfinite, hng, hcenter, haxis, hnc,
hnonzero, hcum, hP⟩
letI : MeasurableSpace Ω := inst
have hind' : IndependentSources μ (fun i => S (permMiddle m π i)) :=
hind.precomp (permMiddleEquiv m π).injective
have hfinite' : FiniteCumulants μ (fun i => S (permMiddle m π i)) (2 * m + 2) :=
fun j => hfinite (permMiddle m π j)
have hng' : SourceNonGaussian μ (fun i => S (permMiddle m π i)) :=
fun j => hng (permMiddle m π j)
have hcenter' : ∀ j, ∫ ω, S (permMiddle m π j) ω ∂μ = 0 :=
fun j => hcenter (permMiddle m π j)
have haxis' := reverseAxisModel_admissibleSourceSwap m π M.param S X Y haxis
have hnc' : ReverseNonCollinear (admissibleSourceSwap m π M.param).1
(admissibleSourceSwap m π M.param).2.1 :=
finCons_comp_perm_injective M.param.1 M.param.2.1 π hnc
-- … truncated; follow the source link for the rest …
TApolar 1 declarations
Generic apolar arrow recovery. With n = m + 2 and K = 2n - 2 = 2m + 2, there are Zariski-open dense parameter loci U^right ⊆ Θ^{right,∘}_{m,K} and U^left ⊆ Θ^{left,∘}_{m,K}, each meeting its real feasible region, on which the full opposite-arrow fiber is empty: for every θ ∈ U^right the reverse fiber over Φ^right_{m,K}(θ) is empty, and dually for U^left. Recovery is by factoring the degree-n support annihilator Q_D and reading its fixed axis.
Formal statement
hypotheses
m :
ℕ
hm :
conclusion
∃ Ur Ul : Set (ParamSpace ℂ m),
Ur ⊆ genericParameterLocus m (2 * m + 2) ∧
Ul ⊆ genericParameterLocus m (2 * m + 2) ∧
IsZariskiOpenParamIn (2 * m + 2) Ur ∧
IsZariskiDenseParamIn (2 * m + 2) Ur ∧
IsZariskiOpenParamIn (2 * m + 2) Ul ∧
IsZariskiDenseParamIn (2 * m + 2) Ul ∧
(∃ O : Set (ParamSpace ℝ m), IsOpen O ∧ (O ∩ realFeasibleRegion m (2 * m + 2)).Nonempty ∧ ∀ θ ∈ O ∩ realFeasibleRegion m (2 * m + 2), complexifyParam θ ∈ Ur) ∧
(∃ O : Set (ParamSpace ℝ m), IsOpen O ∧ (O ∩ realFeasibleRegion m (2 * m + 2)).Nonempty ∧ ∀ η ∈ O ∩ realFeasibleRegion m (2 * m + 2), complexifyParam η ∈ Ul) ∧
(∀ θ ∈ Ur, fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2)) (forwardCumulantMap m (2 * m + 2) θ) = (∅ : Set (ParamSpace ℂ m)) ∧ (∃ QD : Polynomial ℂ, QD ≠ 0 ∧ Squarefree QD ∧ QD.roots = θ.1 ::ₘ (Finset.univ.val.map (fun i => θ.2.1 i)) ∧ QD.eval 0 ≠ 0 ∧ (∀ θ'' ∈ genericParameterLocus m (2 * m + 2), forwardCumulantMap m (2 * m + 2) θ'' = forwardCumulantMap m (2 * m + 2) θ → θ''.1 ::ₘ (Finset.univ.val.map (fun i => θ''.2.1 i)) = θ.1 ::ₘ (Finset.univ.val.map (fun i => θ.2.1 i)))) ∧ (let f := fun r => dividedPowerBlock (forwardCumulantMap m (2 * m + 2) θ) r; let QD2 := supportAnnihilator (forwardLoading m θ.1 θ.2.1); QD2 ≠ 0 ∧ (X (0 : Fin 2) ∣ QD2) ∧ ¬ (X (1 : Fin 2) ∣ QD2) ∧ (∀ q : MvPolynomial (Fin 2) ℂ, q.IsHomogeneous (m + 2) → ((∀ k, k ≤ m → diffApply q (f (m + 2 + k)) = 0) ↔ ∃ c : ℂ, q = c • QD2)))) ∧
(∀ η ∈ Ul, fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2)) (reverseCumulantMap m (2 * m + 2) η) = (∅ : Set (ParamSpace ℂ m)) ∧ (∃ QD : Polynomial ℂ, QD ≠ 0 ∧ Squarefree QD ∧ QD.roots = η.1 ::ₘ (Finset.univ.val.map (fun i => η.2.1 i)) ∧ QD.eval 0 ≠ 0 ∧ (∀ η'' ∈ genericParameterLocus m (2 * m + 2), reverseCumulantMap m (2 * m + 2) η'' = reverseCumulantMap m (2 * m + 2) η → η''.1 ::ₘ (Finset.univ.val.map (fun i => η''.2.1 i)) = η.1 ::ₘ (Finset.univ.val.map (fun i => η.2.1 i)))) ∧ (let f := fun r => dividedPowerBlock (reverseCumulantMap m (2 * m + 2) η) r; let QD2 := supportAnnihilator (reverseLoading m η.1 η.2.1); QD2 ≠ 0 ∧ (X (1 : Fin 2) ∣ QD2) ∧ ¬ (X (0 : Fin 2) ∣ QD2) ∧ (∀ q : MvPolynomial (Fin 2) ℂ, q.IsHomogeneous (m + 2) → ((∀ k, k ≤ m → diffApply q (f (m + 2 + k)) = 0) ↔ ∃ c : ℂ, q = c • QD2))))
Proof (Lean source)
-- @node: thm:generic-apolar-arrow-recovery
theorem generic_apolar_arrow_recovery (m : ℕ) (hm : ValidComplexity m) :
∃ Ur Ul : Set (ParamSpace ℂ m),
Ur ⊆ genericParameterLocus m (2 * m + 2) ∧
Ul ⊆ genericParameterLocus m (2 * m + 2) ∧
IsZariskiOpenParamIn (2 * m + 2) Ur ∧ IsZariskiDenseParamIn (2 * m + 2) Ur ∧
IsZariskiOpenParamIn (2 * m + 2) Ul ∧ IsZariskiDenseParamIn (2 * m + 2) Ul ∧
-- each open locus meets its real feasible region in a nonempty *relatively
-- Euclidean-open* set (not merely at a single feasible witness):
(∃ O : Set (ParamSpace ℝ m), IsOpen O ∧
(O ∩ realFeasibleRegion m (2 * m + 2)).Nonempty ∧
∀ θ ∈ O ∩ realFeasibleRegion m (2 * m + 2), complexifyParam θ ∈ Ur) ∧
(∃ O : Set (ParamSpace ℝ m), IsOpen O ∧
(O ∩ realFeasibleRegion m (2 * m + 2)).Nonempty ∧
∀ η ∈ O ∩ realFeasibleRegion m (2 * m + 2), complexifyParam η ∈ Ul) ∧
-- forward locus: empty reverse fiber, and the common-kernel / support-annihilator
-- recovery — the squarefree degree-`n` support annihilator `Q_D`, whose roots
-- are exactly the forward finite-slope set `D = {γ, ρ_i}` (factorization recovery
-- of `D`), omits the horizontal fixed axis (`Q_D(0) ≠ 0`), and is determined by
-- `t = Φ^right(θ)` (the common contraction kernel is the single line `⟨Q_D⟩`):
(∀ θ ∈ Ur,
fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2))
(forwardCumulantMap m (2 * m + 2) θ) = (∅ : Set (ParamSpace ℂ m)) ∧
(∃ QD : Polynomial ℂ, QD ≠ 0 ∧ Squarefree QD ∧
QD.roots = θ.1 ::ₘ (Finset.univ.val.map (fun i => θ.2.1 i)) ∧
QD.eval 0 ≠ 0 ∧
(∀ θ'' ∈ genericParameterLocus m (2 * m + 2),
forwardCumulantMap m (2 * m + 2) θ'' = forwardCumulantMap m (2 * m + 2) θ →
θ''.1 ::ₘ (Finset.univ.val.map (fun i => θ''.2.1 i)) =
θ.1 ::ₘ (Finset.univ.val.map (fun i => θ.2.1 i)))) ∧
-- divided-power blocks, the degree-`n` support annihilator on ALL `n = m+2`
-- projective directions, the common contraction-kernel identity `ker = ⟨Q_D⟩`,
-- and the vertical(contained)-vs-horizontal(omitted) fixed axis:
(let f := fun r => dividedPowerBlock (forwardCumulantMap m (2 * m + 2) θ) r;
let QD2 := supportAnnihilator (forwardLoading m θ.1 θ.2.1);
QD2 ≠ 0 ∧
(X (0 : Fin 2) ∣ QD2) ∧ ¬ (X (1 : Fin 2) ∣ QD2) ∧
(∀ q : MvPolynomial (Fin 2) ℂ, q.IsHomogeneous (m + 2) →
((∀ k, k ≤ m → diffApply q (f (m + 2 + k)) = 0) ↔ ∃ c : ℂ, q = c • QD2)))) ∧
-- reverse locus: empty forward fiber, and the mirror `Q_D` recovery (roots are
-- the reverse finite-slope set `{δ, σ_i}`, omitting the vertical fixed axis):
(∀ η ∈ Ul,
fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2))
(reverseCumulantMap m (2 * m + 2) η) = (∅ : Set (ParamSpace ℂ m)) ∧
(∃ QD : Polynomial ℂ, QD ≠ 0 ∧ Squarefree QD ∧
QD.roots = η.1 ::ₘ (Finset.univ.val.map (fun i => η.2.1 i)) ∧
QD.eval 0 ≠ 0 ∧
(∀ η'' ∈ genericParameterLocus m (2 * m + 2),
reverseCumulantMap m (2 * m + 2) η'' = reverseCumulantMap m (2 * m + 2) η →
η''.1 ::ₘ (Finset.univ.val.map (fun i => η''.2.1 i)) =
η.1 ::ₘ (Finset.univ.val.map (fun i => η.2.1 i)))) ∧
-- mirror: horizontal axis contained, vertical omitted, same kernel identity:
(let f := fun r => dividedPowerBlock (reverseCumulantMap m (2 * m + 2) η) r;
let QD2 := supportAnnihilator (reverseLoading m η.1 η.2.1);
QD2 ≠ 0 ∧
(X (1 : Fin 2) ∣ QD2) ∧ ¬ (X (0 : Fin 2) ∣ QD2) ∧
(∀ q : MvPolynomial (Fin 2) ℂ, q.IsHomogeneous (m + 2) →
((∀ k, k ≤ m → diffApply q (f (m + 2 + k)) = 0) ↔ ∃ c : ℂ, q = c • QD2)))) := by
-- the former substrate gate, now discharged in-run:
have hgate : TruncatedMomentInterior (2 * m + 2) := truncatedMomentInterior (2 * m + 2)
obtain ⟨Pf, hPf_ne, ⟨θf0, hθf0_pin, hθf0_ne⟩, hPf_inj⟩ :=
forward_contraction_injective_of_generic_and_minor m hm
obtain ⟨Pr, hPr_ne, ⟨θr0, hθr0_pin, hθr0_ne⟩, hPr_inj⟩ :=
reverse_contraction_injective_of_generic_and_minor m hm
let ρprod : MvPolynomial (ParamCoord m) ℂ :=
∏ i : Fin m, X (inr (inl i))
let Rf := genericParameterPolynomial m (2 * m + 2) * ρprod * Pf
let Rr := genericParameterPolynomial m (2 * m + 2) * ρprod * Pr
let Ur : Set (ParamSpace ℂ m) :=
bandSupportedParams m (2 * m + 2) ∩ {θ | eval (paramEval θ) Rf ≠ 0}
let Ul : Set (ParamSpace ℂ m) :=
bandSupportedParams m (2 * m + 2) ∩ {η | eval (paramEval η) Rr ≠ 0}
have hρprod_ne : ρprod ≠ 0 := by
dsimp [ρprod]
apply Finset.prod_ne_zero_iff.mpr
exact fun i _ => MvPolynomial.X_ne_zero _
have hRf_ne : Rf ≠ 0 := by
dsimp [Rf]
exact mul_ne_zero
(mul_ne_zero (genericParameterPolynomial_ne_zero m (2 * m + 2)) hρprod_ne) hPf_ne
have hRr_ne : Rr ≠ 0 := by
dsimp [Rr]
exact mul_ne_zero
(mul_ne_zero (genericParameterPolynomial_ne_zero m (2 * m + 2)) hρprod_ne) hPr_ne
have hpinρ : pinSubst m (2 * m + 2) ρprod ≠ 0 := by
dsimp [ρprod]
rw [map_prod]
apply Finset.prod_ne_zero_iff.mpr
intro i _
rw [pinSubst_X_slope]
exact MvPolynomial.X_ne_zero _
have hpinRf : pinSubst m (2 * m + 2) Rf ≠ 0 := by
dsimp [Rf]
rw [map_mul, map_mul]
exact mul_ne_zero
(mul_ne_zero (pinSubst_genericParameterPolynomial_ne_zero m (2 * m + 2)) hpinρ)
(pinSubst_ne_zero_of_pinned_witness Pf θf0 hθf0_pin hθf0_ne)
have hpinRr : pinSubst m (2 * m + 2) Rr ≠ 0 := by
dsimp [Rr]
rw [map_mul, map_mul]
exact mul_ne_zero
(mul_ne_zero (pinSubst_genericParameterPolynomial_ne_zero m (2 * m + 2)) hpinρ)
(pinSubst_ne_zero_of_pinned_witness Pr θr0 hθr0_pin hθr0_ne)
have forward_data : ∀ θ ∈ Ur,
θ ∈ genericParameterLocus m (2 * m + 2) ∧
(∀ i, θ.2.1 i ≠ 0) ∧
θ.1 ≠ 0 ∧
Injective (forwardWeightedContraction m θ) ∧
Injective
(fun j : Fin (m + 1) => (forwardLoading m θ.1 θ.2.1 (castSucc j)).2) ∧
(∀ j : Fin (m + 1),
(forwardLoading m θ.1 θ.2.1 (castSucc j)).2 ≠ 0) := by
intro θ hθ
have hθne := hθ.2
change eval (paramEval θ) Rf ≠ 0 at hθne
dsimp [Rf] at hθne
rw [MvPolynomial.eval_mul, MvPolynomial.eval_mul] at hθne
obtain ⟨hGρ, hP⟩ := mul_ne_zero_iff.mp hθne
obtain ⟨hG, hRP⟩ := mul_ne_zero_iff.mp hGρ
have hgen : θ ∈ genericParameterLocus m (2 * m + 2) := by
rw [genericParameterLocus_eq_nonvanishing_poly]
exact ⟨hθ.1, hG⟩
have hρ : ∀ i, θ.2.1 i ≠ 0 := by
have hprod : (∏ i : Fin m, θ.2.1 i) ≠ 0 := by
simpa [ρprod, paramEval] using hRP
rw [Finset.prod_ne_zero_iff] at hprod
exact fun i => hprod i (Finset.mem_univ i)
exact ⟨hgen, hρ, gamma_ne_zero_of_generic hgen, hPf_inj θ hP,
forward_slopes_injective_of_generic hgen,
forward_slopes_ne_zero_of_generic hgen hρ⟩
have reverse_data : ∀ η ∈ Ul,
η ∈ genericParameterLocus m (2 * m + 2) ∧
(∀ i, η.2.1 i ≠ 0) ∧
η.1 ≠ 0 ∧
Injective (reverseWeightedContraction m η) ∧
Injective
(fun j : Fin (m + 1) => (reverseLoading m η.1 η.2.1 j.succ).1) ∧
(∀ j : Fin (m + 1), (reverseLoading m η.1 η.2.1 j.succ).1 ≠ 0) := by
intro η hη
have hηne := hη.2
change eval (paramEval η) Rr ≠ 0 at hηne
dsimp [Rr] at hηne
rw [MvPolynomial.eval_mul, MvPolynomial.eval_mul] at hηne
obtain ⟨hGρ, hP⟩ := mul_ne_zero_iff.mp hηne
obtain ⟨hG, hRP⟩ := mul_ne_zero_iff.mp hGρ
have hgen : η ∈ genericParameterLocus m (2 * m + 2) := by
rw [genericParameterLocus_eq_nonvanishing_poly]
exact ⟨hη.1, hG⟩
have hσ : ∀ i, η.2.1 i ≠ 0 := by
have hprod : (∏ i : Fin m, η.2.1 i) ≠ 0 := by
simpa [ρprod, paramEval] using hRP
rw [Finset.prod_ne_zero_iff] at hprod
exact fun i => hprod i (Finset.mem_univ i)
exact ⟨hgen, hσ, gamma_ne_zero_of_generic hgen, hPr_inj η hP,
reverse_slopes_injective_of_generic hgen,
reverse_slopes_ne_zero_of_generic hgen hσ⟩
refine ⟨Ur, Ul, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
· intro θ hθ
exact (forward_data θ hθ).1
· intro η hη
exact (reverse_data η hη).1
· exact (isZariskiOpenIn_denseIn_of_pinSubst_ne_zero Rf hpinRf).1
· exact (isZariskiOpenIn_denseIn_of_pinSubst_ne_zero Rf hpinRf).2
· exact (isZariskiOpenIn_denseIn_of_pinSubst_ne_zero Rr hpinRr).1
· exact (isZariskiOpenIn_denseIn_of_pinSubst_ne_zero Rr hpinRr).2
· let O : Set (ParamSpace ℝ m) :=
{θ | eval (paramEval (complexifyParam θ)) Rf ≠ 0}
refine ⟨O, isOpen_realNonvanishingLocus Rf, ?_, ?_⟩
· obtain ⟨θ, hfeas, hne⟩ := exists_feasible_nonvanishing hgate Rf hpinRf
exact ⟨θ, hne, hfeas⟩
· intro θ hθ
refine ⟨?_, hθ.1⟩
intro j r hr
simp [complexifyParam, hθ.2.2.2.1 j r hr]
· let O : Set (ParamSpace ℝ m) :=
{η | eval (paramEval (complexifyParam η)) Rr ≠ 0}
refine ⟨O, isOpen_realNonvanishingLocus Rr, ?_, ?_⟩
· obtain ⟨η, hfeas, hne⟩ := exists_feasible_nonvanishing hgate Rr hpinRr
exact ⟨η, hne, hfeas⟩
· intro η hη
refine ⟨?_, hη.1⟩
intro j r hr
simp [complexifyParam, hη.2.2.2.1 j r hr]
· intro θ hθ
obtain ⟨hgen, hρ, hγ, hrank, hslopes, hnonzero⟩ := forward_data θ hθ
refine ⟨forward_reverse_fiber_empty m θ hslopes hγ hρ hnonzero hrank, ?_, ?_⟩
· refine ⟨qDefault (rtsF θ), qDefault_ne_zero _, qDefault_squarefree _ ?_, ?_,
qDefault_eval_zero_ne _ ?_, ?_⟩
· exact rtsF_nodup θ hgen hρ
· simpa [rtsF] using qDefault_roots (rtsF θ)
· exact zero_notMem_rtsF θ hgen hρ
· intro θ'' _hθ'' heq
exact forward_slopes_determined_by_cumulants m θ hslopes hnonzero hrank θ'' heq
· dsimp only
refine ⟨supportAnnihilator_ne_zero (forwardLoading m θ.1 θ.2.1) ?_,
X0_dvd_supportAnnihilator_forward θ.1 θ.2.1,
not_X1_dvd_supportAnnihilator_forward θ.1 θ.2.1 hγ hρ, ?_⟩
· intro j
by_cases h0 : j.val = 0
· left
simp [forwardLoading, h0]
by_cases hlast : j.val = m + 1
· right
simp [forwardLoading, hlast]
· left
simp [forwardLoading, h0, hlast]
· exact forward_apolar_kernel_identity m θ hslopes hnonzero hrank
· intro η hη
obtain ⟨hgen, hσ, hδ, hrank, hslopes, hnonzero⟩ := reverse_data η hη
refine ⟨reverse_forward_fiber_empty m η hslopes hδ hσ hnonzero hrank, ?_, ?_⟩
· refine ⟨qDefault (rtsF η), qDefault_ne_zero _, qDefault_squarefree _ ?_, ?_,
qDefault_eval_zero_ne _ ?_, ?_⟩
· exact rtsF_nodup η hgen hσ
· simpa [rtsF] using qDefault_roots (rtsF η)
· exact zero_notMem_rtsF η hgen hσ
· intro η'' _hη'' heq
exact reverse_slopes_determined_by_cumulants m η hslopes hnonzero hrank η'' heq
· dsimp only
refine ⟨supportAnnihilator_ne_zero (reverseLoading m η.1 η.2.1) ?_,
X1_dvd_supportAnnihilator_reverse η.1 η.2.1,
not_X0_dvd_supportAnnihilator_reverse η.1 η.2.1 hδ hσ, ?_⟩
· intro j
by_cases h0 : j.val = 0
· left
simp [reverseLoading, h0]
· right
simp only [reverseLoading, h0, ↓reduceDIte]
split <;> simp
· exact reverse_apolar_kernel_identity m η hslopes hnonzero hrank
TExceptionalLocus 1 declarations
Exceptional-locus codimension one. For every m ≥ 1, the complex exceptional closure has codimension exactly one in both arrow-image varieties; for m ≥ 2 it therefore does not have the formerly conjectured codimension m. The two generic parameter preimages are exactly the band-supported generic points retaining a complete opposite-arrow fiber, and the m=1 and m=2 incidence systems project exactly to E_m.
Formal statement
hypotheses
m :
ℕ
hm :
conclusion
HasCodimensionIn 1 (genericCompatibilityClosure m) (cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ∧
HasCodimensionIn 1 (genericCompatibilityClosure m) (cumulantImageVariety (reverseCumulantMap m (2 * m + 2))) ∧
(2 ≤ m → ¬ HasCodimensionIn m (genericCompatibilityClosure m) (cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ∧ ¬ HasCodimensionIn m (genericCompatibilityClosure m) (cumulantImageVariety (reverseCumulantMap m (2 * m + 2)))) ∧
(∀ θ : ParamSpace ℂ m, θ ∈ genericCompatibilityPreimageRight m ↔ θ ∈ bandSupportedParams m (2 * m + 2) ∧ θ ∈ genericParameterLocus m (2 * m + 2) ∧ (fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2)) (forwardCumulantMap m (2 * m + 2) θ)).Nonempty) ∧
(∀ eta : ParamSpace ℂ m, eta ∈ genericCompatibilityPreimageLeft m ↔ eta ∈ bandSupportedParams m (2 * m + 2) ∧ eta ∈ genericParameterLocus m (2 * m + 2) ∧ (fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2)) (reverseCumulantMap m (2 * m + 2) eta)).Nonempty) ∧
(m = 1 → genericFullFiberCompatibility m = { t : CumVec ℂ | ∃ p ∈ (workedCompatibilitySystems m).1, forwardCumulantMap m (2 * m + 2) p.1 = t }) ∧
(m = 2 → genericFullFiberCompatibility m = { t : CumVec ℂ | ∃ p ∈ (workedCompatibilitySystems m).1, forwardCumulantMap m (2 * m + 2) p.1 = t })
Proof (Lean source)
-- @node: thm:exceptional-locus-codimension-one
theorem exceptionalLocusCodimensionOne (m : ℕ) (hm : ValidComplexity m) :
HasCodimensionIn 1 (genericCompatibilityClosure m)
(cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ∧
HasCodimensionIn 1 (genericCompatibilityClosure m)
(cumulantImageVariety (reverseCumulantMap m (2 * m + 2))) ∧
(2 ≤ m →
¬ HasCodimensionIn m (genericCompatibilityClosure m)
(cumulantImageVariety (forwardCumulantMap m (2 * m + 2))) ∧
¬ HasCodimensionIn m (genericCompatibilityClosure m)
(cumulantImageVariety (reverseCumulantMap m (2 * m + 2)))) ∧
(∀ θ : ParamSpace ℂ m,
θ ∈ genericCompatibilityPreimageRight m ↔
θ ∈ bandSupportedParams m (2 * m + 2) ∧
θ ∈ genericParameterLocus m (2 * m + 2) ∧
(fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2))
(forwardCumulantMap m (2 * m + 2) θ)).Nonempty) ∧
(∀ eta : ParamSpace ℂ m,
eta ∈ genericCompatibilityPreimageLeft m ↔
eta ∈ bandSupportedParams m (2 * m + 2) ∧
eta ∈ genericParameterLocus m (2 * m + 2) ∧
(fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2))
(reverseCumulantMap m (2 * m + 2) eta)).Nonempty) ∧
(m = 1 → genericFullFiberCompatibility m =
{ t : CumVec ℂ | ∃ p ∈ (workedCompatibilitySystems m).1,
forwardCumulantMap m (2 * m + 2) p.1 = t }) ∧
(m = 2 → genericFullFiberCompatibility m =
{ t : CumVec ℂ | ∃ p ∈ (workedCompatibilitySystems m).1,
forwardCumulantMap m (2 * m + 2) p.1 = t }) := by
apply exceptionalLocusCodimensionOne_of_commonAxis_certificates m hm
apply commonAxisFiniteHeightOneCertificates_of_exact_forward_dimensions m hm
exact ⟨restrict_forwardCommonAxisImageClosure_dimension_expected m hm,
restrict_forwardCumulantImageVariety_dimension_expected m hm⟩
TGenericSeparation 1 declarations
Generic arrow recovery and fiber obstruction. At K = 2m+2, relative Zariski-open dense loci meet the real feasible regions in nonempty relatively Euclidean-open sets. On them the unordered loading directions are recovered and the full opposite-arrow fiber is empty. Nevertheless a direct/latent source-pair swap lies in the same-arrow fiber but outside the admissible G_m-orbit; for m ≥ 2 the complete same-arrow fiber has exact relative Zariski dimension m(m-1)/2 from the independent low-order weight kernels.
Formal statement
hypotheses
m :
ℕ
hm :
conclusion
∃ Ur Ul : Set (ParamSpace ℂ m),
Ur ⊆ genericParameterLocus m (2 * m + 2) ∧
Ul ⊆ genericParameterLocus m (2 * m + 2) ∧
IsZariskiOpenParamIn (2 * m + 2) Ur ∧
IsZariskiDenseParamIn (2 * m + 2) Ur ∧
IsZariskiOpenParamIn (2 * m + 2) Ul ∧
IsZariskiDenseParamIn (2 * m + 2) Ul ∧
(∃ O : Set (ParamSpace ℝ m), IsOpen O ∧ (O ∩ realFeasibleRegion m (2 * m + 2)).Nonempty ∧ ∀ θ ∈ O ∩ realFeasibleRegion m (2 * m + 2), complexifyParam θ ∈ Ur) ∧
(∃ O : Set (ParamSpace ℝ m), IsOpen O ∧ (O ∩ realFeasibleRegion m (2 * m + 2)).Nonempty ∧ ∀ eta ∈ O ∩ realFeasibleRegion m (2 * m + 2), complexifyParam eta ∈ Ul) ∧
(∀ θ ∈ Ur, (∀ θ' ∈ fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2)) (forwardCumulantMap m (2 * m + 2) θ), loadingSlopeMultiset θ' = loadingSlopeMultiset θ) ∧ fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2)) (forwardCumulantMap m (2 * m + 2) θ) = ∅ ∧ (∀ i : Fin m, ∃ θ' ∈ genericParameterLocus m (2 * m + 2), IsForwardDirectLatentSwap i θ θ' ∧ forwardCumulantMap m (2 * m + 2) θ' = forwardCumulantMap m (2 * m + 2) θ ∧ θ' ∉ admissibleOrbit θ) ∧ (2 ≤ m → HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2) (fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2)) (forwardCumulantMap m (2 * m + 2) θ)))) ∧
(∀ eta ∈ Ul, (∀ eta' ∈ fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2)) (reverseCumulantMap m (2 * m + 2) eta), loadingSlopeMultiset eta' = loadingSlopeMultiset eta) ∧ fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2)) (reverseCumulantMap m (2 * m + 2) eta) = ∅ ∧ (∀ i : Fin m, ∃ eta' ∈ genericParameterLocus m (2 * m + 2), IsReverseDirectLatentSwap i eta eta' ∧ reverseCumulantMap m (2 * m + 2) eta' = reverseCumulantMap m (2 * m + 2) eta ∧ eta' ∉ admissibleOrbit eta) ∧ (2 ≤ m → HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2) (fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2)) (reverseCumulantMap m (2 * m + 2) eta))))
Proof (Lean source)
theorem genericArrowRecoveryAndFiberObstruction (m : ℕ) (hm : ValidComplexity m) :
∃ Ur Ul : Set (ParamSpace ℂ m),
Ur ⊆ genericParameterLocus m (2 * m + 2) ∧
Ul ⊆ genericParameterLocus m (2 * m + 2) ∧
IsZariskiOpenParamIn (2 * m + 2) Ur ∧
IsZariskiDenseParamIn (2 * m + 2) Ur ∧
IsZariskiOpenParamIn (2 * m + 2) Ul ∧
IsZariskiDenseParamIn (2 * m + 2) Ul ∧
(∃ O : Set (ParamSpace ℝ m), IsOpen O ∧
(O ∩ realFeasibleRegion m (2 * m + 2)).Nonempty ∧
∀ θ ∈ O ∩ realFeasibleRegion m (2 * m + 2), complexifyParam θ ∈ Ur) ∧
(∃ O : Set (ParamSpace ℝ m), IsOpen O ∧
(O ∩ realFeasibleRegion m (2 * m + 2)).Nonempty ∧
∀ eta ∈ O ∩ realFeasibleRegion m (2 * m + 2), complexifyParam eta ∈ Ul) ∧
(∀ θ ∈ Ur,
(∀ θ' ∈ fiberCorrespondence (2 * m + 2)
(forwardCumulantMap m (2 * m + 2))
(forwardCumulantMap m (2 * m + 2) θ),
loadingSlopeMultiset θ' = loadingSlopeMultiset θ) ∧
fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2))
(forwardCumulantMap m (2 * m + 2) θ) = ∅ ∧
(∀ i : Fin m, ∃ θ' ∈ genericParameterLocus m (2 * m + 2),
IsForwardDirectLatentSwap i θ θ' ∧
forwardCumulantMap m (2 * m + 2) θ' =
forwardCumulantMap m (2 * m + 2) θ ∧
θ' ∉ admissibleOrbit θ) ∧
(2 ≤ m → HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2)
(fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2))
(forwardCumulantMap m (2 * m + 2) θ)))) ∧
(∀ eta ∈ Ul,
(∀ eta' ∈ fiberCorrespondence (2 * m + 2)
(reverseCumulantMap m (2 * m + 2))
(reverseCumulantMap m (2 * m + 2) eta),
loadingSlopeMultiset eta' = loadingSlopeMultiset eta) ∧
fiberCorrespondence (2 * m + 2) (forwardCumulantMap m (2 * m + 2))
(reverseCumulantMap m (2 * m + 2) eta) = ∅ ∧
(∀ i : Fin m, ∃ eta' ∈ genericParameterLocus m (2 * m + 2),
IsReverseDirectLatentSwap i eta eta' ∧
reverseCumulantMap m (2 * m + 2) eta' =
reverseCumulantMap m (2 * m + 2) eta ∧
eta' ∉ admissibleOrbit eta) ∧
(2 ≤ m → HasRelativeZariskiDimension (2 * m + 2) (m * (m - 1) / 2)
(fiberCorrespondence (2 * m + 2) (reverseCumulantMap m (2 * m + 2))
(reverseCumulantMap m (2 * m + 2) eta)))) := by
obtain ⟨Ur, Ul, hUr, hUl, hUro, hUrd, hUlo, hUld, hrealr, hreall,
hforward, hreverse⟩ := generic_apolar_arrow_recovery m hm
refine ⟨Ur, Ul, hUr, hUl, hUro, hUrd, hUlo, hUld, hrealr, hreall, ?_, ?_⟩
· intro θ hθ
rcases hforward θ hθ with
⟨hempty, ⟨Q, hQne, _hQsq, hQroots, hQzero, _hgenericRecovery⟩, hkernelData⟩
dsimp only at hkernelData
rcases hkernelData with ⟨_hQ2ne, _hvertical, _hhorizontal, hkernel⟩
have hrecover : ∀ θ' ∈ fiberCorrespondence (2 * m + 2)
(forwardCumulantMap m (2 * m + 2))
(forwardCumulantMap m (2 * m + 2) θ),
loadingSlopeMultiset θ' = loadingSlopeMultiset θ := by
intro θ' hθ'
have heq : forwardCumulantMap m (2 * m + 2) θ' =
forwardCumulantMap m (2 * m + 2) θ := by
funext r a
by_cases hb : 2 ≤ r ∧ r ≤ 2 * m + 2 ∧ a ≤ r
· exact hθ'.2 r a hb.1 hb.2.1 hb.2.2
· simp [forwardCumulantMap, hb]
exact forward_slopes_determined_by_kernel_identity m θ hkernel θ' heq
have hρ : ∀ i, θ.2.1 i ≠ 0 :=
latent_slopes_ne_zero_of_root_polynomial hQne hQroots hQzero
refine ⟨hrecover, hempty, ?_, ?_⟩
· intro i
let θ' := forwardDirectLatentSwap i θ
refine ⟨θ', forwardDirectLatentSwap_generic i θ (hUr hθ) (hρ i),
forwardDirectLatentSwap_spec i θ, forwardCumulantMap_directLatentSwap i θ, ?_⟩
exact forwardDirectLatentSwap_not_mem_admissibleOrbit i θ
(gamma_ne_rho_of_generic (hUr hθ) i)
· intro hm2
exact forward_full_fiber_dimension m θ (hUr hθ) hrecover hm2
· intro η hη
rcases hreverse η hη with
⟨hempty, ⟨Q, hQne, _hQsq, hQroots, hQzero, _hgenericRecovery⟩, hkernelData⟩
dsimp only at hkernelData
rcases hkernelData with ⟨_hQ2ne, _hhorizontal, _hvertical, hkernel⟩
have hrecover : ∀ η' ∈ fiberCorrespondence (2 * m + 2)
(reverseCumulantMap m (2 * m + 2))
(reverseCumulantMap m (2 * m + 2) η),
loadingSlopeMultiset η' = loadingSlopeMultiset η := by
intro η' hη'
have heq : reverseCumulantMap m (2 * m + 2) η' =
reverseCumulantMap m (2 * m + 2) η := by
funext r a
by_cases hb : 2 ≤ r ∧ r ≤ 2 * m + 2 ∧ a ≤ r
· exact hη'.2 r a hb.1 hb.2.1 hb.2.2
· simp [reverseCumulantMap, hb]
exact reverse_slopes_determined_by_kernel_identity m η hkernel η' heq
have hσ : ∀ i, η.2.1 i ≠ 0 :=
latent_slopes_ne_zero_of_root_polynomial hQne hQroots hQzero
refine ⟨hrecover, hempty, ?_, ?_⟩
· intro i
let η' := reverseDirectLatentSwap i η
refine ⟨η', reverseDirectLatentSwap_generic i η (hUl hη) (hσ i),
reverseDirectLatentSwap_spec i η, reverseCumulantMap_directLatentSwap i η, ?_⟩
exact reverseDirectLatentSwap_not_mem_admissibleOrbit i η
(gamma_ne_rho_of_generic (hUl hη) i)
· intro hm2
exact reverse_full_fiber_dimension m η (hUl hη) hrecover hm2
TInfoOrder 1 declarations
Improved real information order. For every m ≥ 3, generic real opposite-arrow separation already holds at order 2m+1. Hence K^star(m) ≤ 2m+1, and in particular it is not equal to 2m+2.
Formal statement
hypotheses
m :
ℕ
hm :
3 ≤ m
conclusion
separatesAtOrder m (2 * m + 1) ∧
informationOrder m ≤ ((2 * m + 1 : ℕ) : ℕ∞) ∧
informationOrder m ≠ ((2 * m + 2 : ℕ) : ℕ∞)
Proof (Lean source)
theorem improvedRealInformationOrder (m : ℕ) (hm : 3 ≤ m) :
separatesAtOrder m (2 * m + 1) ∧
informationOrder m ≤ ((2 * m + 1 : ℕ) : ℕ∞) ∧
informationOrder m ≠ ((2 * m + 2 : ℕ) : ℕ∞) := by
have hsep : separatesAtOrder m (2 * m + 1) := by
exact lowerOrderApolarSeparation m hm
refine ⟨hsep, ?_, ?_⟩
· apply sInf_le
exact ⟨2 * m + 1, rfl, by omega, hsep⟩
· intro heq
have hle : informationOrder m ≤ ((2 * m + 1 : ℕ) : ℕ∞) := by
apply sInf_le
exact ⟨2 * m + 1, rfl, by omega, hsep⟩
rw [heq] at hle
have := ENat.coe_le_coe.mp hle
omega