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))
ProvedProjRescale.MaxSupport.theorem_1Let and let be a linear subspace. Write
Run Algorithm 2 (Maximum support) on , with any admissible behaviour of the basic procedure inside each call of Algorithm 1. Then:
- (progress) every non-halted state reachable by the algorithm has an admissible next step;
- (termination) there is no infinite execution;
- (main iterations, (6)) no execution starts a main iteration beyond the -th;
- (rescaling steps, (7)) the total number of rescaling steps performed is at most
- (correctness) upon termination with outputs and , the algorithm has identified and , and found and with for all and for all .
Here is the maximum support index set and the condition measure of (with when ), so . The theorem says that a maximum support solution of the pair of feasibility problems , is found after guessing rounds and rescaling steps, with no knowledge of or .
Formalization Note Algorithm 2 is the transition relation A2Step L started at A2Init n (, 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. in is Int.ceil followed by Int.toNat, and is Real.logb 2.
Differences from the source:
- correction: (6) → ; reason: (6) is for and undefined at , while every execution performs main iteration 1; counterexample , : , , , (6) gives . For the corrected equals (6).
- correction: (7) → ; reason: a call of Algorithm 1 with guess can perform rescaling steps (Proposition 1, corrected), and the proof's sum over main iterations is ; counterexample , : , (7) gives , but with forces 2 rescaling steps.
- encoding: implicit → hypothesis ; reason: for , and Algorithm 1 cannot run, so the case is undefined on the page.
- encoding: "upon termination … the algorithm terminates after at most 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.
import Mathlib import Definitions.Def_ProjRescale_MaxSupport_Setting
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
Confirmed by the mission captain (proposal self-audit).
Confirmed by the moderator at approval.