Documentation

Tdaf.Analysis.Convex.Optimization.Program

Ordinary convex programs and Lagrange multipliers #

An ordinary convex program minimises f₀ over C = dom f₀ subject to finitely many convex inequalities fᵢ x ≤ 0 and finitely many affine constraints. The main result is the existence of Kuhn–Tucker vectors under Slater's condition: if the optimal value is not -∞ and some point of ri C satisfies every non-affine constraint strictly, then non-negative multipliers exist for which the infimum of the Lagrangian equals the optimal value.

The two families of constraints are kept apart by role. Those indexed by ι are the ones Slater's condition asks a strict inequality of — the indices where fᵢ is not affine — and are EReal-valued convex functions; those indexed by κ are affine maps E →ᵃ[ℝ] ℝ asked only for a weak inequality. That is the split the theorem of the alternative is stated against, so the existence theorem applies it directly and the affine-only case is ι = Empty.

Main definitions #

Main results #

Implementation notes #

The standing hypothesis hsub : dom f₀ ⊆ dom (f i) makes every fᵢ finite on C; that is what turns the multiplier inequality into one between real numbers, which may be divided by the multiplier of the objective.

References #

[^1]: R. T. Rockafellar, Convex Analysis, Princeton University Press, 1970, §28.

def Tdaf.ConvexAnalysis.feasibleSet {E : Type u_1} [AddCommGroup E] [Module ℝ E] {ι : Type u_2} {κ : Type u_3} (f : ι → E → EReal) (b : κ → E →ᵃ[ℝ] ℝ) :
Set E

The set of feasible solutions of the constraint system fᵢ x ≤ 0, bⱼ x ≤ 0.

Equations
Instances For
    @[simp]
    theorem Tdaf.ConvexAnalysis.mem_feasibleSet {E : Type u_1} [AddCommGroup E] [Module ℝ E] {ι : Type u_2} {κ : Type u_3} {f : ι → E → EReal} {b : κ → E →ᵃ[ℝ] ℝ} {x : E} :
    x ∈ feasibleSet f b ↔ (∀ (i : ι), f i x ≤ 0) ∧ ∀ (j : κ), (b j) x ≤ 0
    noncomputable def Tdaf.ConvexAnalysis.programLagrangian {E : Type u_1} [AddCommGroup E] [Module ℝ E] {ι : Type u_2} {κ : Type u_3} [Fintype ι] [Fintype κ] (f₀ : E → EReal) (f : ι → E → EReal) (b : κ → E →ᵃ[ℝ] ℝ) (l : ι → ℝ) (μ : κ → ℝ) :
    E → EReal

    The Lagrangian of an ordinary convex program at the multipliers (l, μ), namely f₀ + λ₁f₁ + ⋯ + λ_m f_m. The perturbational Lagrangian of a bifunction is lagrangian.

    Equations
    Instances For
      theorem Tdaf.ConvexAnalysis.programLagrangian_apply {E : Type u_1} [AddCommGroup E] [Module ℝ E] {ι : Type u_2} {κ : Type u_3} [Fintype ι] [Fintype κ] (f₀ : E → EReal) (f : ι → E → EReal) (b : κ → E →ᵃ[ℝ] ℝ) (l : ι → ℝ) (μ : κ → ℝ) (x : E) :
      programLagrangian f₀ f b l μ x = f₀ x + ∑ i : ι, ↑(l i) * f i x + ↑(∑ j : κ, μ j * (b j) x)
      noncomputable def Tdaf.ConvexAnalysis.optimalValue {E : Type u_1} [AddCommGroup E] [Module ℝ E] {ι : Type u_2} {κ : Type u_3} (f₀ : E → EReal) (f : ι → E → EReal) (b : κ → E →ᵃ[ℝ] ℝ) :

      The optimal value of the program: the infimum of the objective over the feasible set.

      Equations
      Instances For
        theorem Tdaf.ConvexAnalysis.optimalValue_le {E : Type u_1} [AddCommGroup E] [Module ℝ E] {ι : Type u_2} {κ : Type u_3} {f₀ : E → EReal} {f : ι → E → EReal} {b : κ → E →ᵃ[ℝ] ℝ} {x : E} (hx : x ∈ feasibleSet f b) :
        optimalValue f₀ f b ≤ f₀ x
        structure Tdaf.ConvexAnalysis.IsKuhnTuckerVector {E : Type u_1} [AddCommGroup E] [Module ℝ E] {ι : Type u_2} {κ : Type u_3} [Fintype ι] [Fintype κ] (f₀ : E → EReal) (f : ι → E → EReal) (b : κ → E →ᵃ[ℝ] ℝ) (l : ι → ℝ) (μ : κ → ℝ) :

        (l, μ) is a vector of Kuhn–Tucker coefficients: the multipliers are non-negative, and the infimum of the Lagrangian is finite and equal to the optimal value. This is the direct definition, not the equivalent perturbational inequality p u + ⟨λ, u⟩ ≥ p 0.

        • nonneg (i : ι) : 0 ≤ l i

          The multipliers of the convex constraints are non-negative.

        • nonneg_affine (j : κ) : 0 ≤ μ j

          The multipliers of the affine inequality constraints are non-negative.

        • ne_bot : ⨅ (x : E), programLagrangian f₀ f b l μ x ≠ ⊥

          The infimum of the Lagrangian is not -∞.

        • ne_top : ⨅ (x : E), programLagrangian f₀ f b l μ x ≠ ⊤

          The infimum of the Lagrangian is not +∞.

        • iInf_eq : ⨅ (x : E), programLagrangian f₀ f b l μ x = optimalValue f₀ f b

          The infimum of the Lagrangian is the optimal value in the program.

        Instances For
          theorem Tdaf.ConvexAnalysis.coe_mul_nonpos {c : ℝ} (hc : 0 ≤ c) {z : EReal} (hz : z ≤ 0) :
          ↑c * z ≤ 0

          A non-negative real multiple of a non-positive EReal is non-positive; the coefficient 0 is harmless under the convention 0 · ∞ = 0.

          theorem Tdaf.ConvexAnalysis.sum_coe_mul_neg {ι : Type u_2} [Fintype ι] {l : ι → ℝ} (hl : ∀ (i : ι), 0 ≤ l i) {v : ι → EReal} (hv : ∀ (i : ι), v i < 0) {i₀ : ι} (hi₀ : l i₀ ≠ 0) :
          ∑ i : ι, ↑(l i) * v i < 0

          A non-negatively weighted sum of strictly negative values with one non-zero weight is strictly negative; this rules out a vanishing multiplier on the objective.

          theorem Tdaf.ConvexAnalysis.programLagrangian_le_of_mem_feasibleSet {E : Type u_1} [AddCommGroup E] [Module ℝ E] {ι : Type u_2} {κ : Type u_3} [Fintype ι] [Fintype κ] {f₀ : E → EReal} {f : ι → E → EReal} {b : κ → E →ᵃ[ℝ] ℝ} {l : ι → ℝ} {μ : κ → ℝ} (hl : ∀ (i : ι), 0 ≤ l i) (hμ : ∀ (j : κ), 0 ≤ μ j) {x : E} (hx : x ∈ feasibleSet f b) :
          programLagrangian f₀ f b l μ x ≤ f₀ x

          On the feasible set every constraint term is non-positive, so L ≤ f₀.

          theorem Tdaf.ConvexAnalysis.programLagrangian_eq_top {E : Type u_1} [AddCommGroup E] [Module ℝ E] {ι : Type u_2} {κ : Type u_3} [Fintype ι] [Fintype κ] {f₀ : E → EReal} {f : ι → E → EReal} {b : κ → E →ᵃ[ℝ] ℝ} {l : ι → ℝ} {μ : κ → ℝ} (hl : ∀ (i : ι), 0 ≤ l i) (hbot : ∀ (i : ι) (x : E), f i x ≠ ⊥) {x : E} (hx : f₀ x = ⊤) :
          programLagrangian f₀ f b l μ x = ⊤

          Off dom f₀ the Lagrangian is +∞: no constraint term can be -∞, since the fᵢ never take -∞ and the multipliers are non-negative.

          theorem Tdaf.ConvexAnalysis.programLagrangian_eq_coe {E : Type u_1} [AddCommGroup E] [Module ℝ E] {ι : Type u_2} {κ : Type u_3} [Fintype ι] [Fintype κ] {f₀ : E → EReal} {f : ι → E → EReal} {b : κ → E →ᵃ[ℝ] ℝ} {l : ι → ℝ} {μ : κ → ℝ} {x : E} {r₀ : ℝ} (h₀ : f₀ x = ↑r₀) {r : ι → ℝ} (hr : ∀ (i : ι), f i x = ↑(r i)) :
          programLagrangian f₀ f b l μ x = ↑(r₀ + ∑ i : ι, l i * r i + ∑ j : κ, μ j * (b j) x)

          The Lagrangian where objective and constraints are all finite, as a single real number.

          theorem Tdaf.ConvexAnalysis.exists_isKuhnTuckerVector_of_slater {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] {ι : Type u_2} {κ : Type u_3} [Fintype ι] [Fintype κ] {f₀ : E → EReal} {f : ι → E → EReal} {b : κ → E →ᵃ[ℝ] ℝ} (hf₀ : ConvexFn f₀) (hp₀ : Proper f₀) (hf : ∀ (i : ι), ConvexFn (f i)) (hp : ∀ (i : ι), Proper (f i)) (hsub : ∀ (i : ι), dom f₀ ⊆ dom (f i)) (hbot : optimalValue f₀ f b ≠ ⊥) (hslater : ∃ x ∈ intrinsicInterior ℝ (dom f₀), (∀ (i : ι), f i x < 0) ∧ ∀ (j : κ), (b j) x ≤ 0) :
          ∃ (l : ι → ℝ) (μ : κ → ℝ), IsKuhnTuckerVector f₀ f b l μ

          Existence of Kuhn–Tucker coefficients under Slater's condition. If the optimal value is not -∞ and the program has a feasible solution in ri C, C = dom f₀, satisfying strictly every constraint of the first family, then a vector of Kuhn–Tucker coefficients exists.

          theorem Tdaf.ConvexAnalysis.exists_isKuhnTuckerVector_of_affine {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] {ι : Type u_2} {κ : Type u_3} [Fintype ι] [Fintype κ] {f₀ : E → EReal} {f : ι → E → EReal} {b : κ → E →ᵃ[ℝ] ℝ} [IsEmpty ι] (hf₀ : ConvexFn f₀) (hp₀ : Proper f₀) (hbot : optimalValue f₀ f b ≠ ⊥) (hfeas : ∃ x ∈ intrinsicInterior ℝ (dom f₀), ∀ (j : κ), (b j) x ≤ 0) :
          ∃ (l : ι → ℝ) (μ : κ → ℝ), IsKuhnTuckerVector f₀ f b l μ

          With only affine constraints a feasible solution in ri C suffices: the existence theorem with an empty family of strict constraints.

          theorem Tdaf.ConvexAnalysis.affineMap_segment {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] (g : E →ᵃ[ℝ] ℝ) (y z : E) (a : ℝ) :
          g ((1 - a) • y + a • z) = (1 - a) * g y + a * g z

          An affine map along the segment from y to z, as used in the prolongation of a Slater point.

          theorem Tdaf.ConvexAnalysis.exists_isKuhnTuckerVector_of_mem_dom {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] {ι : Type u_2} {κ : Type u_3} [Fintype ι] [Fintype κ] {f₀ : E → EReal} {f : ι → E → EReal} {b : κ → E →ᵃ[ℝ] ℝ} (hf₀ : ConvexFn f₀) (hp₀ : Proper f₀) (hf : ∀ (i : ι), ConvexFn (f i)) (hp : ∀ (i : ι), Proper (f i)) (hsub : ∀ (i : ι), dom f₀ ⊆ dom (f i)) (hri : ∀ (i : ι), intrinsicInterior ℝ (dom f₀) ⊆ intrinsicInterior ℝ (dom (f i))) (hbot : optimalValue f₀ f b ≠ ⊥) (hslater : ∃ x ∈ dom f₀, (∀ (i : ι), f i x < 0) ∧ ∀ (j : κ), (b j) x < 0) :
          ∃ (l : ι → ℝ) (μ : κ → ℝ), IsKuhnTuckerVector f₀ f b l μ

          When every constraint holds strictly at some point of C, that point need not lie in ri C: prolonging it towards a relative interior point produces a Slater point.

          The book states this for a program with no affine constraints; affine constraints are allowed here, at the price of asking strict inequality of them too, which is what survives the prolongation. The hypothesis hri is what following fᵢ along the segment needs.

          theorem Tdaf.ConvexAnalysis.exists_multipliers_of_slater_eq {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] {ι : Type u_2} [Fintype ι] {f₀ : E → EReal} {f : ι → E → EReal} {σ : Type u_4} [Fintype σ] {a : σ → E →ᵃ[ℝ] ℝ} (hf₀ : ConvexFn f₀) (hp₀ : Proper f₀) (hf : ∀ (i : ι), ConvexFn (f i)) (hp : ∀ (i : ι), Proper (f i)) (hsub : ∀ (i : ι), dom f₀ ⊆ dom (f i)) (hbot : optimalValue f₀ f (Sum.elim a fun (k : σ) => -a k) ≠ ⊥) (hslater : ∃ x ∈ intrinsicInterior ℝ (dom f₀), (∀ (i : ι), f i x < 0) ∧ ∀ (k : σ), (a k) x = 0) :
          ∃ (l : ι → ℝ) (ρ : σ → ℝ), (∀ (i : ι), 0 ≤ l i) ∧ ⨅ (x : E), f₀ x + ∑ i : ι, ↑(l i) * f i x + ↑(∑ k : σ, ρ k * (a k) x) = ⨅ x ∈ {x : E | (∀ (i : ι), f i x ≤ 0) ∧ ∀ (k : σ), (a k) x = 0}, f₀ x

          The same for a program whose affine constraints are equations. Their multipliers are then of unrestricted sign, obtained as μ' - μ'' from the two inequalities each equation splits into.