Barrier method: Newton steps
OpenConvexOptimization.barrier_method_sqrt_m_complexity_on⚠️ DEPRECATED — superseded, and under-specified as stated.
Use
ConvexOptimization.barrier_method_sqrt_m_complexity_scinstead: the same statement plus the hypothesesDifferentiable ℝ f₀and∀ i, Differentiable ℝ (fᵢ), which B&V assume throughout Chapter 11.Why the extra hypotheses. The per-centering step count rests on the objective gap inherited from the previous centre being at most , i.e. on (11.25)–(11.26), formalized as
ConvexOptimization.barrier_centering_potential_gap. That estimate is proved through the central path and the dual feasible point , so it needs the individual gradients . The Newton hypotheses of this statement only supply the gradient of the sum on the strictly feasible set — enough to recover and there, but not the separate . This statement is not known to be false; it is simply missing the standing regularity assumption of §11, and is retired in favour of the version that states it.
Complexity of the barrier method with the outer schedule — Boyd & Vandenberghe §11.5, with the inner line search confined to the strictly feasible set.
Consider the inequality-constrained convex program
with and all convex, and let be the logarithmic barrier. Assume the §11.5.1 self-concordance hypothesis: is self-concordant on the strictly feasible set for every , with positive definite Hessian and closed sublevel sets, and let denote the exact minimiser — the central path.
Run the barrier method with the outer schedule , , each centering step warm-started at the previous centre and carried out by damped Newton with backtracking. Then each centering step reaches accuracy in at most
Newton steps — a bound independent of , of and of — because the objective gap inherited from the previous centre is at most for this . Together with the duality gap along the central path, outer iterations bring the gap below , so the total Newton effort is .
Formalization note. Each centering run is governed by IsDampedNewtonRunOn, whose line search IsBacktrackingStepOn accepts the largest step whose trial point is both strictly feasible and Armijo-acceptable — which is exactly what B&V's convention " off " (§9.1) delivers. This has to be said explicitly here because logBarrier is real-valued and returns finite junk values off the strictly feasible set (Mathlib's Real.log is at and on the negatives), so the barrier does not blow up there; the earlier formalization ConvexOptimization.barrier_method_sqrt_m_complexity, which used the unconfined line search, is false for exactly this reason and has been disproved. A hypothesis that the sublevel sets of within the strictly feasible set are closed is also stated explicitly, as the Dikin-ellipsoid argument behind (9.55) needs it. Otherwise the statement is unchanged.
import Mathlib import Definitions.Def_ConvexOptimization_selfConcordance import Definitions.Def_ConvexOptimization_IsDampedNewtonRunOn import Definitions.Def_ConvexOptimization_logBarrier open scoped RealInnerProductSpace ENNReal open MeasureTheory
theorem ConvexOptimization.barrier_method_sqrt_m_complexity_on {n mI : ℕ} (hmI : 0 < mI)
(α β t0 ε εnt : ℝ)
(hα0 : 0 < α) (hα : α < 1 / 2) (hβ0 : 0 < β) (hβ1 : β < 1)
(ht0 : 0 < t0) (hε : 0 < ε) (hεnt0 : 0 < εnt) (hεnt : εnt < 1 / 4)
(f₀ : EuclideanSpace ℝ (Fin n) → ℝ) (hf₀ : ConvexOn ℝ Set.univ f₀)
(fc : Fin mI → EuclideanSpace ℝ (Fin n) → ℝ)
(hfc : ∀ i, ConvexOn ℝ Set.univ (fc i))
(hSC : ∀ t : ℝ, 0 ≤ t →
IsSelfConcordantOn {x | ∀ i, fc i x < 0}
(fun x => t * f₀ x + logBarrier fc x))
(hclosed : ∀ t : ℝ, 0 < t → ∀ c : ℝ,
IsClosed {x | (∀ i, fc i x < 0) ∧ t * f₀ x + logBarrier fc x ≤ c})
(g : ℝ → EuclideanSpace ℝ (Fin n) → EuclideanSpace ℝ (Fin n))
(hg : ∀ t : ℝ, 0 < t → ∀ x, (∀ i, fc i x < 0) →
HasGradientAt (fun y => t * f₀ y + logBarrier fc y) (g t x) x)
(H : ℝ → EuclideanSpace ℝ (Fin n) →
EuclideanSpace ℝ (Fin n) →L[ℝ] EuclideanSpace ℝ (Fin n))
(hH : ∀ t : ℝ, 0 < t → ∀ x, (∀ i, fc i x < 0) →
HasFDerivAt (g t) (H t x) x)
(hHpd : ∀ t : ℝ, 0 < t → ∀ x, (∀ i, fc i x < 0) →
∀ v, v ≠ 0 → 0 < ⟪H t x v, v⟫)
(xc : ℝ → EuclideanSpace ℝ (Fin n))
(hxc_str : ∀ t : ℝ, 0 < t → ∀ i, fc i (xc t) < 0)
(hxc_min : ∀ t : ℝ, 0 < t →
IsMinOn (fun x => t * f₀ x + logBarrier fc x) {x | ∀ i, fc i x < 0} (xc t)) :
∃ (w : ℕ → ℕ → EuclideanSpace ℝ (Fin n)) (K : ℕ → ℕ),
(∀ i, w i 0 = xc ((1 + 1 / Real.sqrt mI) ^ i * t0)) ∧
(∀ i, IsDampedNewtonRunOn {x | ∀ i', fc i' x < 0}
(fun x => (1 + 1 / Real.sqrt mI) ^ (i + 1) * t0 * f₀ x + logBarrier fc x)
(g ((1 + 1 / Real.sqrt mI) ^ (i + 1) * t0))
(H ((1 + 1 / Real.sqrt mI) ^ (i + 1) * t0)) α β (w i)) ∧
(∀ i, ((1 + 1 / Real.sqrt mI) ^ (i + 1) * t0 * f₀ (w i (K i)) +
logBarrier fc (w i (K i))) -
((1 + 1 / Real.sqrt mI) ^ (i + 1) * t0 *
f₀ (xc ((1 + 1 / Real.sqrt mI) ^ (i + 1) * t0)) +
logBarrier fc (xc ((1 + 1 / Real.sqrt mI) ^ (i + 1) * t0))) ≤ εnt) ∧
(∀ i, (K i : ℝ) ≤
(20 - 8 * α) / (α * β * (1 - 2 * α) ^ 2) / 2 +
Real.logb 2 (Real.logb 2 (1 / εnt)) + 2) ∧
(mI : ℝ) / ((1 + 1 / Real.sqrt mI) ^
⌈Real.sqrt mI * Real.logb 2 (mI / (t0 * ε))⌉₊ * t0) ≤ ε := by
sorry