Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Theorem 1, p. 8 — Algorithm 2 terminates with J = J(L), Ĵ = J(L⊥) and maximum support solutions (corrected: k = max{1, ⌈log₂log₂(1/m)⌉+1}, rescalings ≤ 2n(2^k − 1 + k))

Proved
ProjRescale.MaxSupport.theorem_1

by mikedeng1 · Oct 24, 2026 · Mathlib 0df444a (Lean v4.33.1)

condition-measurelinear-feasibilitymaximum-supportp2o-batch-pfp2ap2o-correctedp2o-gran-per-chapterp2o-plan-paperp2o-v1rescaling-algorithm

Let n≥1n \ge 1n≥1 and let L⊆RnL \subseteq \mathbb R^nL⊆Rn be a linear subspace. Write

m=min⁡{σ(L),σ(L⊥)},k=max⁡{1, ⌈log⁡2log⁡2(1/m)⌉+1}.m = \min\{\sigma(L), \sigma(L^\perp)\}, \qquad k = \max\big\{1,\ \lceil \log_2 \log_2(1/m) \rceil + 1\big\}.m=min{σ(L),σ(L⊥)},k=max{1, ⌈log2​log2​(1/m)⌉+1}.

Run Algorithm 2 (Maximum support) on LLL, with any admissible behaviour of the basic procedure inside each call of Algorithm 1. Then:

  1. (progress) every non-halted state reachable by the algorithm has an admissible next step;
  2. (termination) there is no infinite execution;
  3. (main iterations, (6)) no execution starts a main iteration beyond the kkk-th;
  4. (rescaling steps, (7)) the total number of rescaling steps performed is at most
2n (2k−1+k);2n\,(2^k - 1 + k);2n(2k−1+k);
  1. (correctness) upon termination with outputs (x,J)(x, J)(x,J) and (x^,J^)(\hat x, \hat J)(x^,J^), the algorithm has identified J=J(L)J = J(L)J=J(L) and J^=J(L⊥)\hat J = J(L^\perp)J^=J(L⊥), and found x∈L∩R+nx \in L \cap \mathbb R^n_+x∈L∩R+n​ and x^∈L⊥∩R+n\hat x \in L^\perp \cap \mathbb R^n_+x^∈L⊥∩R+n​ with xj>0x_j > 0xj​>0 for all j∈Jj \in Jj∈J and x^j>0\hat x_j > 0x^j​>0 for all j∈J^j \in \hat Jj∈J^.

Here J(L)J(L)J(L) is the maximum support index set and σ(L)\sigma(L)σ(L) the condition measure of LLL (with σ(L)=1\sigma(L) = 1σ(L)=1 when J(L)=∅J(L) = \emptysetJ(L)=∅), so m∈(0,1]m \in (0,1]m∈(0,1]. The theorem says that a maximum support solution of the pair of feasibility problems x∈L∩R+nx \in L \cap \mathbb R^n_+x∈L∩R+n​, x^∈L⊥∩R+n\hat x \in L^\perp \cap \mathbb R^n_+x^∈L⊥∩R+n​ is found after O(log⁡log⁡(1/m))O(\log\log(1/m))O(loglog(1/m)) guessing rounds and O(nlog⁡(1/m))O(n\log(1/m))O(nlog(1/m)) rescaling steps, with no knowledge of σ(L)\sigma(L)σ(L) or σ(L⊥)\sigma(L^\perp)σ(L⊥).

Formalization Note Algorithm 2 is the transition relation A2Step L started at A2Init n (σ=1/2\sigma = 1/2σ=1/2, main iteration 1), with the two calls of Algorithm 1 run step by step inside it; iter is the index of the current main iteration and rescalings the number of rescaling steps performed so far (including those of a running call). Clauses 3 and 4 bound these counters at every reachable state, which is the same as bounding them at termination because both counters only increase. ⌈⋅⌉\lceil\cdot\rceil⌈⋅⌉ in kkk is Int.ceil followed by Int.toNat, and log⁡2\log_2log2​ is Real.logb 2.

Differences from the source:

  • correction: (6) k=⌈log⁡2log⁡2(1/m)⌉+1k = \lceil\log_2\log_2(1/m)\rceil + 1k=⌈log2​log2​(1/m)⌉+1 → k=max⁡{1,⌈log⁡2log⁡2(1/m)⌉+1}k = \max\{1, \lceil\log_2\log_2(1/m)\rceil + 1\}k=max{1,⌈log2​log2​(1/m)⌉+1}; reason: (6) is ≤0\le 0≤0 for m∈(2−1/2,1)m \in (2^{-1/2}, 1)m∈(2−1/2,1) and undefined at m=1m = 1m=1, while every execution performs main iteration 1; counterexample n=2n = 2n=2, L=span{(1,0.8)}L = \mathrm{span}\{(1, 0.8)\}L=span{(1,0.8)}: σ(L)=0.8\sigma(L) = 0.8σ(L)=0.8, J(L⊥)=∅J(L^\perp) = \emptysetJ(L⊥)=∅, m=0.8m = 0.8m=0.8, (6) gives ⌈−1.64⌉+1=0\lceil -1.64\rceil + 1 = 0⌈−1.64⌉+1=0. For m≤2−1/2m \le 2^{-1/2}m≤2−1/2 the corrected kkk equals (6).
  • correction: (7) 4n⌈log⁡2(1/m)⌉4n\lceil\log_2(1/m)\rceil4n⌈log2​(1/m)⌉ → 2n(2k−1+k)2n(2^k - 1 + k)2n(2k−1+k); reason: a call of Algorithm 1 with guess σ\sigmaσ can perform n(⌊log⁡2(1/σ)⌋+1)n(\lfloor\log_2(1/\sigma)\rfloor + 1)n(⌊log2​(1/σ)⌋+1) rescaling steps (Proposition 1, corrected), and the proof's sum over main iterations is ∑i=1k2n(2i−1+1)=2n(2k−1+k)\sum_{i=1}^k 2n(2^{i-1} + 1) = 2n(2^k - 1 + k)∑i=1k​2n(2i−1+1)=2n(2k−1+k); counterexample n=1n = 1n=1, L=RL = \mathbb RL=R: m=1m = 1m=1, (7) gives 000, but J(L⊥,1/2)\mathcal J(L^\perp, 1/2)J(L⊥,1/2) with L⊥={0}L^\perp = \{0\}L⊥={0} forces 2 rescaling steps.
  • encoding: n≥1n \ge 1n≥1 implicit → hypothesis 0<n0 < n0<n; reason: for n=0n = 0n=0, Δ({1,…,n})=∅\Delta(\{1,\dots,n\}) = \emptysetΔ({1,…,n})=∅ and Algorithm 1 cannot run, so the case is undefined on the page.
  • encoding: "upon termination … the algorithm terminates after at most kkk main iterations … the total number of rescaling steps … is bounded above by" → progress, no infinite execution, the counter bounds at every reachable state, and correctness at every reachable halted state of the transition relation, over every admissible basic-procedure answer; reason: the basic procedure is any procedure satisfying step 3 of Algorithm 1, so the claim is about every execution.
Preamble
import Mathlib
import Definitions.Def_ProjRescale_MaxSupport_Setting
Formal statement
namespace ProjRescale.MaxSupport

/-- Theorem 1, p. 8, corrected. Write `m = min{σ(L), σ(L⊥)}` and
`k = max{1, ⌈log₂ log₂(1/m)⌉ + 1}`. For every admissible behaviour of the basic procedure,
Algorithm 2 can always continue until it halts, has no infinite execution, never starts a main
iteration beyond `k`, performs at most `2n(2^k − 1 + k)` rescaling steps in total, and upon
termination returns `J = J(L)`, `Ĵ = J(L⊥)` and `x ∈ L ∩ ℝⁿ₊`, `x̂ ∈ L⊥ ∩ ℝⁿ₊` with `x_J > 0`,
`x̂_Ĵ > 0`. -/
theorem theorem_1 (n : ℕ) (hn : 0 < n) (L : Submodule ℝ (E n)) :
    (∀ s, Relation.ReflTransGen (A2Step L) (A2Init n) s → ¬ s.IsDone →
        ∃ s', A2Step L s s') ∧
      (¬ ∃ f : ℕ → A2State n, f 0 = A2Init n ∧ ∀ t, A2Step L (f t) (f (t + 1))) ∧
      (∀ s, Relation.ReflTransGen (A2Step L) (A2Init n) s →
        s.iter ≤ kIter (min (condMeasure L) (condMeasure Lᗮ))) ∧
      (∀ s, Relation.ReflTransGen (A2Step L) (A2Init n) s →
        s.rescalings ≤ 2 * n * (2 ^ kIter (min (condMeasure L) (condMeasure Lᗮ)) - 1 +
          kIter (min (condMeasure L) (condMeasure Lᗮ)))) ∧
      (∀ i R x J xh Jh, Relation.ReflTransGen (A2Step L) (A2Init n) (.done i R x J xh Jh) →
        (J = maxSupp L ∧ x ∈ L ∧ x ∈ nonneg n ∧ ∀ j ∈ J, 0 < x j) ∧
          (Jh = maxSupp Lᗮ ∧ xh ∈ Lᗮ ∧ xh ∈ nonneg n ∧ ∀ j ∈ Jh, 0 < xh j)) := by sorry

end ProjRescale.MaxSupport
Source
Peña & Soheili, Projection and rescaling algorithm for finding maximum support solutions to polyhedral conic systems, arXiv:2003.08911v3, p. 8, Theorem 1 (Equations (6) and (7)), Algorithm 2
Human review
  • Endorsed by Shuze Chen · Oct 24, 2026

    Confirmed by the moderator at approval.

  • Endorsed by mikedeng1 · Oct 24, 2026

    Confirmed by the mission captain (proposal self-audit).

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me