Encyclopedia Cost Cost Ndim Block Reduction E

ARTICLE 3 claims 3 theorems

Cost Ndim Block Reduction E

One small vector, e, is the probe that lets a high-dimensional recognition space be checked for a hidden flatness, and it turns out to be the key to a general proof.

Verify this page

The indicator vector

In linear algebra, a standard basis vector is a vector with a 1 in one coordinate and 0 in every other. The declaration e is exactly that object: it is the indicator vector that picks out a single coordinate. For a space of any dimension n, the vector e i0 has a 1 in position i0 and 0 elsewhere. It is the simplest possible test direction one can apply to a matrix or an operator.

Its role here is to act as a probe. The framework's library works with a projector, a linear map built from a metric and a coupling parameter. To ask what the projector does along a particular direction, one feeds it the indicator vector for that direction. The dot product of any vector α with e i0 simply returns the i0-th component of α, a fact the library records as a theorem. This is the algebraic hinge that lets a full n-dimensional expression collapse to a single entry.

The payoff is a block-reduction identity. The library proves that for any dimension n, if α is supported on only two coordinates i0 and i1, and if the background has t i1 = 0, then the (i0, i0) entry of the n-dimensional projector, evaluated on e i0, equals exactly a known 2-dimensional closed form. This is an equality of real numbers computed from the genuinely n-dimensional definitions, not an approximation and not an isomorphism up to relabeling. The n-dimensional object provably is the 2D form on this slice.

That equality is what carries the non-parallelism theorem to arbitrary dimension. The 2D scalar law, whose derivative is never zero under the stated conditions, transports directly to the general setting. The library's theorem PApply_not_parallel_gen states that as the i0-th coordinate varies, the projector's entry obeys exactly that 2D law, and its derivative is never zero. Hence the projector fails to be parallel along the i0 direction at every point of the slice, for every ambient dimension n ≥ 2. The indicator vector e is the instrument that makes this general statement possible: without it, there is no clean way to extract a single component from the n-dimensional operator.

In Recognition Science, this is the component-level architecture the review panel identified as correct. The physical picture is that a 2-sparse structure, a coupling that touches only two coordinates, can be embedded in a high-dimensional recognition space, and its local geometric behavior is exactly the 2D behavior, no matter how many other coordinates are present and fixed. The other n − 2 coordinates need not even be at equilibrium; only the condition t i1 = 0 is required. The declaration e is the small, concrete tool that makes this reduction exact.

THEOREM dot_e · IndisputableMonolith/Cost/Ndim/BlockReduction.lean
dot_e · IndisputableMonolith/Cost/Ndim/BlockReduction.lean:79 
@[simp] theorem dot_e {n : ℕ} (α : Vec n) (i0 : Fin n) : dot α (e i0) = α i0 := by
  unfold dot e
  rw [Finset.sum_eq_single i0]
  · simp
  · intro b _ hb
    simp [hb]
  · intro h
    exact absurd (Finset.mem_univ i0) h
THEOREM PApply_e_eq_P00Gen · IndisputableMonolith/Cost/Ndim/BlockReduction.lean
PApply_e_eq_P00Gen · IndisputableMonolith/Cost/Ndim/BlockReduction.lean:133 
/-- **The block-reduction identity.** For any ambient dimension `n`, any `α` supported
on two indices `i0 ≠ i1` with `α i0 ≠ 0`, any `λ ≠ 0`, and any background `t` with
`t i1 = 0`, the `(i0, i0)` entry of the abstract, `n`-dimensional projector `P_λ =
PApply lam (Dinv t) α` — applied to the indicator direction `e i0` — equals exactly the
2D closed form `P00Gen (α i0) (α i1) (t i0)` of `ScalarCertificates.lean`. This is the
algebraic content behind "the `n`-dimensional projector reduces to the 2D one on the
2-sparse slice": no approximation, no isomorphism-up-to-relabeling, an equality of
real numbers computed from the genuinely `n`-dimensional definitions. -/
theorem PApply_e_eq_P00Gen {n : ℕ} (t : Vec n) (α : Vec n) (lam : ℝ)
    (i0 i1 : Fin n) (hne : i0 ≠ i1) (h2 : TwoSparse α i0 i1)
    (ha : α i0 ≠ 0) (hlam : lam ≠ 0) (ht1 : t i1 = 0) :
    PApply lam (Dinv t) α (e i0) i0 = P00Gen (α i0) (α i1) (t i0) := by
  have hc : (0 : ℝ) < Real.cosh (t i0) := Real.cosh_pos _
  have hc' : Real.cosh (t i0) ≠ 0 := ne_of_gt hc
  have ha2 : (0 : ℝ) < α i0 ^ 2 := sq_pos_of_ne_zero ha
  have hAA : AApply lam (Dinv t) α (e i0) i0
      = lam * ((Real.cosh (t i0))⁻¹ * α i0) * α i0 := by
    show lam * sharp (Dinv t) α i0 * dot α (e i0) = _
    rw [sharp_Dinv_apply, dot_e]
  have hmu : mu lam (Dinv t) α
      = lam * ((Real.cosh (t i0))⁻¹ * α i0 ^ 2 + α i1 ^ 2) := by
    rw [mu_Dinv_twoSparse t α lam i0 i1 hne h2, ht1, Real.cosh_zero]
    norm_num
  have hmu_pos_part : (0 : ℝ) < (Real.cosh (t i0))⁻¹ * α i0 ^ 2 + α i1 ^ 2 := by
    have h1 : (0 : ℝ) < (Real.cosh (t i0))⁻¹ * α i0 ^ 2 := mul_pos (inv_pos.mpr hc) ha2
    nlinarith [sq_nonneg (α i1)]
  have hdenom_pos : (0 : ℝ) < α i0 ^ 2 + α i1 ^ 2 * Real.cosh (t i0) := by
    nlinarith [sq_nonneg (α i1), mul_nonneg (sq_nonneg (α i1)) (le_of_lt hc)]
  have hPapply : PApply lam (Dinv t) α (e i0) i0
      = (mu lam (Dinv t) α)⁻¹ * AApply lam (Dinv t) α (e i0) i0 := by
    show (mu lam (Dinv t) α)⁻¹ • AApply lam (Dinv t) α (e i0) i0 = _
    rw [smul_eq_mul]
  rw [hPapply, hAA, hmu]
  unfold P00Gen
  rw [eq_div_iff (ne_of_gt hdenom_pos)]
  field_simp
THEOREM PApply_not_parallel_gen · IndisputableMonolith/Cost/Ndim/BlockReduction.lean
PApply_not_parallel_gen · IndisputableMonolith/Cost/Ndim/BlockReduction.lean:170 
/-- **Theorem 1a, arbitrary ambient dimension `n`** (panel-greenlit general-`n`
extension). Embed a 2-sparse `α = (…, α i0, …, α i1, …, 0, …)` supported on indices
`i0 ≠ i1` inside an `n`-dimensional recognition space, and consider the slice `t` with
`t i1 = 0` (all other `n - 2` coordinates arbitrary and fixed). As the `i0`-th
coordinate varies, the `(i0, i0)` entry of the genuinely `n`-dimensional projector
`P_λ` obeys *exactly* the 2D scalar law `dP00Gen`, and — for `α i0 ≠ 0`, `α i1 ≠ 0` —
that derivative is never zero. Hence `P_λ` fails to be `D`-parallel along the `i0`
direction at every point of the slice, for every ambient dimension `n ≥ 2`, not just
`n = 2`. This is the direct general-`n` lift of `ScalarCertificates.dP00Gen_ne_zero`. -/
theorem PApply_not_parallel_gen {n : ℕ} (t : Vec n) (α : Vec n) (lam : ℝ)
    (i0 i1 : Fin n) (hne : i0 ≠ i1) (h2 : TwoSparse α i0 i1)
    (ha : α i0 ≠ 0) (hb : α i1 ≠ 0) (hlam : lam ≠ 0) (ht1 : t i1 = 0) (s : ℝ) :
    HasDerivAt (fun s' => PApply lam (Dinv (Function.update t i0 s')) α (e i0) i0)
        (dP00Gen (α i0) (α i1) s) s
      ∧ (s ≠ 0 → dP00Gen (α i0) (α i1) s ≠ 0) := by
  have hfun_eq : (fun s' => PApply lam (Dinv (Function.update t i0 s')) α (e i0) i0)
      = P00Gen (α i0) (α i1) := by
    funext s'
    have ht1' : Function.update t i0 s' i1 = 0 := by
      rw [Function.update_of_ne (Ne.symm hne)]
      exact ht1
    have hred := PApply_e_eq_P00Gen (Function.update t i0 s') α lam i0 i1 hne h2 ha hlam ht1'
    rwa [Function.update_self] at hred
  refine ⟨?_, fun hs => dP00Gen_ne_zero (α i0) (α i1) s ha hb hs⟩
  rw [hfun_eq]
  exact hasDerivAt_P00Gen (α i0) (α i1) s ha

What this page does not claim

This does not claim that the full n-dimensional projector equals the 2D one on the entire space, only on the 2-sparse slice with t i1 = 0. This does not claim that the indicator vector e is a physical object; it is a mathematical probe. This does not claim that the other n − 2 coordinates are at equilibrium; they are arbitrary and fixed.

Verify this page

Every tagged claim above names its theorem. To check one yourself rather than trust this page, elaborate the source module with Lean 4 and audit its axiom basis:

$ lake env lean IndisputableMonolith/Cost/Ndim/BlockReduction.lean
expected axiom basis: [propext, Classical.choice, Quot.sound] (the Lean kernel's standard three; no RS-specific axioms)

A page whose claims cannot be reproduced this way does not ship. In production, every anchor links to the exact declaration in the public source release, and this block carries the build receipt for the page itself.

Derived articles

This page is generated by a question-recursion engine: the questions its answers raise become the next pages. The current agenda, with open targets marked red:

MACHINE LAYER · GROUNDED CLAIM TABLE · CLICK TO EXPAND