Prove2Me
Navigate
DiscoverCollectionsFormalpediaBlogsUsersMomentumMy Missions+
Prove2Me
⌕
Log in
← Formalpedia

Chapter 10, Theorem 1 — multistage Jensen lower bound via aggregation

Disproved
StochasticProg.MultistageBounds.thm1_multistage_jensen_lower_bound

by mikedeng1 · Sep 19, 2026 · Mathlib 0df444a (Lean v4.33.1)

aggregationjensen-inequalitylinear-optimizationmultistagestochastic-programming

Chapter 10, Theorem 1 (Birge & Louveaux, p. 419): the multistage generalization of Chapter 8's two-period Jensen lower bound — the optimal value of the aggregated multistage problem (1.2) never exceeds the optimal value of the exact multistage problem (1.1), provided the aggregation is built from genuine conditional expectations of the exact data and every two aggregated nodes that "have a common outcome at time t" are assigned the same aggregated data.

Fix a stage count H, dimensions n, m, an exact scenario tree TFine : Tree H and a coarser, aggregated scenario tree TCoarse : Tree H (in the sense of the companion Tree definition), and instances fine : Instance H n m TFine, coarse : Instance H n m TCoarse. Let agg : TFine.Node → TCoarse.Node send every exact node to the aggregated node of its block Sᵗᵢ, respecting the tree structure: agg sends the exact root to the aggregated root, preserves stage, and commutes with the ancestor map. Suppose the shared, deterministic data agree — fine.W = coarse.W and fine.c j = coarse.c (agg j) for every exact node j (Birge & Louveaux's "cᵗ = cᵗ" and "Wᵗ known and not random", p. 418) — and that the aggregated technology/right-hand-side data are the genuine probability-weighted conditional expectations of the exact data over each aggregation fiber,

picoarse hicoarse=∑j:agg(j)=ipjfine hjfine,picoarse Ticoarse=∑j:agg(j)=ipjfine Tjfine(stage(i)≠0),p^{\mathrm{coarse}}_i\, h^{\mathrm{coarse}}_i = \sum_{j : \mathrm{agg}(j) = i} p^{\mathrm{fine}}_j\, h^{\mathrm{fine}}_j, \qquad p^{\mathrm{coarse}}_i\, T^{\mathrm{coarse}}_i = \sum_{j : \mathrm{agg}(j) = i} p^{\mathrm{fine}}_j\, T^{\mathrm{fine}}_j \quad (\mathrm{stage}(i) \ne 0),picoarse​hicoarse​=j:agg(j)=i∑​pjfine​hjfine​,picoarse​Ticoarse​=j:agg(j)=i∑​pjfine​Tjfine​(stage(i)=0),

i.e. (hˉit,Tˉit)=ESit[(ht,Tt)](\bar h^t_i, \bar T^t_i) = \mathbb E^{S^t_i}[(h^t,T^t)](hˉit​,Tˉit​)=ESit​[(ht,Tt)], exactly Birge & Louveaux's definitions preceding the theorem (p. 418). Finally — the theorem's own extra hypothesis, stated with a label type Θ and curOutcome : TCoarse.Node → Θ recording each aggregated node's current-period outcome — suppose that whenever two aggregated nodes i, i' at the same stage share a current-period outcome (curOutcome i = curOutcome i'), their aggregated data already coincide: coarse.h i = coarse.h i' and coarse.Tmat i = coarse.Tmat i'. This is the book's "E^{S^t_i}[(h^t,T^t)] = (\bar h^t_i,\bar T^t_i) = E^{S^t_j}[(h^t,T^t)] for all S^t_i and S^t_j that have a common outcome at time t."

Then, for zFine/zCoarse the optimal values of (1.1)/(1.2) (each characterized as a lower bound over the feasible tree-wide decisions, attained at some feasible point),

zcoarse  ≤  zfine.z^{\mathrm{coarse}} \;\le\; z^{\mathrm{fine}} .zcoarse≤zfine.

Formalization Note The book's own printed statement of the hypothesis has a shift: "such that (ωt−1,ωt) ∈ Stj if and only if there exist some (ω̂t−1,ωt) ∈ Stj" repeats S^t_j on both sides of the "if and only if" where the sentence's own subject ("S^t_i and S^t_j that have a common outcome") requires the left side to range over S^t_i — confirmed as the book's own printed text (not an artefact of text extraction) by rendering PDF page 436 directly; see STATUS.md. This formalization reads the corrected clause as: S^t_i and S^t_j project onto the same set of period-t outcomes, abstracted here to an arbitrary label type Θ (curOutcome) rather than a literal projection onto a product-space coordinate, since the aggregated tree alone (without also formalizing the exact per-period outcome spaces Ω_t as a product) does not otherwise have a "period-t outcome" object to project onto. zFine/zCoarse are hypothesis-characterized (a lower bound over the feasible set, attained), not sInf-defined, to avoid the real infimum's junk value 0 on an unbounded-below or empty feasible set (reference/FAITHFULNESS_TRAPS.md trap 5) — neither problem's constraints are shown bounded or nonempty a priori by the hypotheses above.

Preamble
import Mathlib
import Definitions.Def_StochasticProg_MultistageBounds_Tree
import Definitions.Def_StochasticProg_MultistageBounds_Instance
Formal statement
namespace StochasticProg.MultistageBounds

open scoped Matrix

variable {H n m : ℕ}

/-- Chapter 10, Theorem 1 (Birge & Louveaux, p. 419): the aggregated multistage problem (1.2)
provides a lower bound on the exact multistage problem (1.1), provided the aggregated data are
genuinely conditional expectations of the exact data (`hCoarse_h`/`hCoarse_T`) *and* two
aggregated nodes that share a common current-period outcome receive the same aggregated data
(`hCommonOutcome`, the theorem's own extra hypothesis: "`E^{Sti}[(ht,Tt)] = (h̄ti,T̄ti) =
E^{Stj}[(ht,Tt)]` for all `Sti` and `Stj` that have a common outcome at time `t`"). Without
`hCommonOutcome`, (1.2)'s conditional-expectation form need not actually be a bound (p. 419,
two paragraphs before the theorem statement: "If not, then the conditional expectation form in
(1.2) may not actually achieve a bound"). `agg` sends every exact node to the aggregated node
of its `St_i`; `curOutcome` labels each aggregated node by the current-period outcome its `St_i`
shares with any node it has "a common outcome at time `t`" with — this is a deliberate
generalization of the book's literal `(ωt−1,ωt) ∈ Sti ⟺ ∃ω̂t−1,(ω̂t−1,ωt) ∈ Stj` clause (the PDF's
own printed text repeats `Stj` on both sides of that "if and only if", a genuine typo in the
book, confirmed against a fresh render of the page rather than assumed from OCR — see
`STATUS.md`; the natural reading replaces the first `Stj` with `Sti`, i.e. `Sti` and `Stj`
project to the same set of period-`t` outcomes), abstracted to an arbitrary label type `Θ`
rather than a literal product-space projection. -/
theorem thm1_multistage_jensen_lower_bound
    (TFine TCoarse : Tree H)
    (fine : Instance H n m TFine) (coarse : Instance H n m TCoarse)
    (agg : TFine.Node → TCoarse.Node)
    (hagg_root : agg TFine.root = TCoarse.root)
    (hagg_stage : ∀ j : TFine.Node, TCoarse.stage (agg j) = TFine.stage j)
    (hagg_anc : ∀ j : TFine.Node, (TFine.stage j).val ≠ 0 →
      agg (TFine.anc j) = TCoarse.anc (agg j))
    (hW_agree : fine.W = coarse.W)
    (hc_agree : ∀ j : TFine.Node, fine.c j = coarse.c (agg j))
    (hCoarse_h : ∀ i : TCoarse.Node,
      coarse.p i • coarse.h i =
        ∑ j ∈ Finset.univ.filter (fun j : TFine.Node => agg j = i), fine.p j • fine.h j)
    (hCoarse_T : ∀ i : TCoarse.Node, (TCoarse.stage i).val ≠ 0 →
      coarse.p i • coarse.Tmat i =
        ∑ j ∈ Finset.univ.filter (fun j : TFine.Node => agg j = i), fine.p j • fine.Tmat j)
    (Θ : Type) (curOutcome : TCoarse.Node → Θ)
    (hCommonOutcome : ∀ i i' : TCoarse.Node, TCoarse.stage i = TCoarse.stage i' →
      curOutcome i = curOutcome i' → coarse.h i = coarse.h i' ∧ coarse.Tmat i = coarse.Tmat i')
    (zFine zCoarse : ℝ)
    (hzFine_lb : ∀ x, Feasible fine x → zFine ≤ obj fine x)
    (hzFine_attain : ∃ x, Feasible fine x ∧ obj fine x = zFine)
    (hzCoarse_lb : ∀ x, Feasible coarse x → zCoarse ≤ obj coarse x)
    (hzCoarse_attain : ∃ x, Feasible coarse x ∧ obj coarse x = zCoarse) :
    zCoarse ≤ zFine := by sorry

end StochasticProg.MultistageBounds
Source
Birge & Louveaux, Introduction to Stochastic Programming, 2nd ed., Springer 2011, p. 419, Chapter 10, Theorem 1
Read-back

What the Lean code literally says, in plain math · claude-opus-5

Fix a horizon HHH and matrix dimensions n,mn, mn,m (natural numbers, all of which may be zero). The statement is about two scenario trees of horizon HHH — a fine tree TF\mathcal{T}_FTF​ and a coarse tree TC\mathcal{T}_CTC​ — each built from the bundle's own Tree definition, which is not unfolded here; what is used of it is only that a tree has a finite type of nodes, a distinguished root, a stage map assigning each node a stage stage⁡(j)\operatorname{stage}(j)stage(j) whose underlying value is a natural number, and an ancestor map anc⁡\operatorname{anc}anc (a total function, so anc⁡\operatorname{anc}anc of the root is some node, not "undefined"). Over these trees sit two instances IF\mathcal{I}_FIF​ and IC\mathcal{I}_CIC​ of the bundle's Instance structure, also not unfolded; the fields used are, for each node jjj: a probability-like scalar pjp_jpj​, a vector hjh_jhj​, a matrix TjT_jTj​, a cost vector cjc_jcj​, and a single recourse matrix WWW shared across nodes. Together with these come two bundle-defined predicates that the statement leaves opaque: Feasible⁡(I,x)\operatorname{Feasible}(\mathcal{I}, x)Feasible(I,x) for a decision xxx, and a real-valued objective obj⁡(I,x)\operatorname{obj}(\mathcal{I}, x)obj(I,x). Nothing in the statement pins down what "feasible" means, what type xxx ranges over beyond what these predicates accept, or how obj⁡\operatorname{obj}obj is computed from p,h,T,c,Wp, h, T, c, Wp,h,T,c,W; all of that lives in the imported definitions.

The hypotheses are as follows. There is an aggregation map agg⁡:Node⁡(TF)→Node⁡(TC)\operatorname{agg} : \operatorname{Node}(\mathcal{T}_F) \to \operatorname{Node}(\mathcal{T}_C)agg:Node(TF​)→Node(TC​) such that

  • agg⁡(root⁡F)=root⁡C\operatorname{agg}(\operatorname{root}_F) = \operatorname{root}_Cagg(rootF​)=rootC​;
  • for every fine node jjj, stage⁡C(agg⁡(j))=stage⁡F(j)\operatorname{stage}_C(\operatorname{agg}(j)) = \operatorname{stage}_F(j)stageC​(agg(j))=stageF​(j) (stages are preserved exactly);
  • for every fine node jjj whose stage value is not 000, agg⁡(anc⁡F(j))=anc⁡C(agg⁡(j))\operatorname{agg}(\operatorname{anc}_F(j)) = \operatorname{anc}_C(\operatorname{agg}(j))agg(ancF​(j))=ancC​(agg(j)) (aggregation commutes with taking the parent, except that nothing is required at stage-000 nodes).

The data of the two instances are tied together by:

  • WF=WCW_F = W_CWF​=WC​ (the recourse matrices coincide);
  • for every fine node jjj, cjF=cagg⁡(j)Cc^F_j = c^C_{\operatorname{agg}(j)}cjF​=cagg(j)C​ (costs are copied from the aggregated node);
  • for every coarse node iii,
piC⋅hiC  =  ∑j : agg⁡(j)=ipjF⋅hjF,p^C_i \cdot h^C_i \;=\; \sum_{j \,:\, \operatorname{agg}(j) = i} p^F_j \cdot h^F_j,piC​⋅hiC​=j:agg(j)=i∑​pjF​⋅hjF​,

the sum ranging over all fine nodes mapped to iii (an empty sum, hence the zero vector, if no fine node maps to iii);

  • for every coarse node iii whose stage value is not 000,
piC⋅TiC  =  ∑j : agg⁡(j)=ipjF⋅TjF,p^C_i \cdot T^C_i \;=\; \sum_{j \,:\, \operatorname{agg}(j) = i} p^F_j \cdot T^F_j,piC​⋅TiC​=j:agg(j)=i∑​pjF​⋅TjF​,

with the same convention; at stage-000 coarse nodes no relation between TCT^CTC and TFT^FTF is imposed.

Note that these are relations on the products p⋅hp \cdot hp⋅h and p⋅Tp \cdot Tp⋅T; they do not say piC=∑pjFp^C_i = \sum p^F_jpiC​=∑pjF​, nor that hiCh^C_ihiC​ is a conditional expectation, and if piC=0p^C_i = 0piC​=0 they force the fine-side sums to vanish while leaving hiCh^C_ihiC​, TiCT^C_iTiC​ arbitrary.

There is an arbitrary type Θ\ThetaΘ of labels and a labelling curOutcome⁡:Node⁡(TC)→Θ\operatorname{curOutcome} : \operatorname{Node}(\mathcal{T}_C) \to \ThetacurOutcome:Node(TC​)→Θ such that for all coarse nodes i,i′i, i'i,i′ with stage⁡C(i)=stage⁡C(i′)\operatorname{stage}_C(i) = \operatorname{stage}_C(i')stageC​(i)=stageC​(i′) and curOutcome⁡(i)=curOutcome⁡(i′)\operatorname{curOutcome}(i) = \operatorname{curOutcome}(i')curOutcome(i)=curOutcome(i′), one has both hiC=hi′Ch^C_i = h^C_{i'}hiC​=hi′C​ and TiC=Ti′CT^C_i = T^C_{i'}TiC​=Ti′C​. (This is vacuous if curOutcome⁡\operatorname{curOutcome}curOutcome is injective on each stage, and it forces all same-stage h,Th, Th,T data to agree if Θ\ThetaΘ has one element.)

Finally, two real numbers zFz_FzF​ and zCz_CzC​ are given, each characterized as the attained minimum of its instance's objective over feasible decisions:

  • zF≤obj⁡(IF,x)z_F \le \operatorname{obj}(\mathcal{I}_F, x)zF​≤obj(IF​,x) for every xxx with Feasible⁡(IF,x)\operatorname{Feasible}(\mathcal{I}_F, x)Feasible(IF​,x), and there exists some xxx with Feasible⁡(IF,x)\operatorname{Feasible}(\mathcal{I}_F, x)Feasible(IF​,x) and obj⁡(IF,x)=zF\operatorname{obj}(\mathcal{I}_F, x) = z_Fobj(IF​,x)=zF​;
  • zC≤obj⁡(IC,x)z_C \le \operatorname{obj}(\mathcal{I}_C, x)zC​≤obj(IC​,x) for every xxx with Feasible⁡(IC,x)\operatorname{Feasible}(\mathcal{I}_C, x)Feasible(IC​,x), and there exists some xxx with Feasible⁡(IC,x)\operatorname{Feasible}(\mathcal{I}_C, x)Feasible(IC​,x) and obj⁡(IC,x)=zC\operatorname{obj}(\mathcal{I}_C, x) = z_Cobj(IC​,x)=zC​.

The conclusion is the single real inequality

zC  ≤  zF.z_C \;\le\; z_F .zC​≤zF​.

Nothing is asserted about the objectives being convex, about agg⁡\operatorname{agg}agg being surjective, about the fine tree refining the coarse one in any structural sense beyond the three agg conditions, or about ppp being nonnegative or summing to one.

In degenerate cases: if H=0H = 0H=0, or if either tree has a single node, the hypotheses reduce to statements about roots only and the claim is still zC≤zFz_C \le z_FzC​≤zF​ for whatever Feasible⁡\operatorname{Feasible}Feasible and obj⁡\operatorname{obj}obj yield there. If n=0n = 0n=0 or m=0m = 0m=0, the vectors and matrices are empty and the data hypotheses hold trivially. If some coarse node has no fine preimage under agg⁡\operatorname{agg}agg, the corresponding hypothesis reads piC⋅hiC=0p^C_i \cdot h^C_i = 0piC​⋅hiC​=0 (and piC⋅TiC=0p^C_i \cdot T^C_i = 0piC​⋅TiC​=0 for non-initial stages). The attainment hypotheses require both feasible sets to be nonempty; if either Feasible predicate were unsatisfiable the theorem's hypotheses could not be met and it would assert nothing. Because the statement quantifies over arbitrary zF,zCz_F, z_CzF​,zC​ satisfying the minimum characterization, it does not itself define an optimal value; when a feasible set is nonempty but the objective is unbounded below, no real number satisfies the lower-bound hypothesis and the theorem again has no instances. Stage values are natural numbers, so "stage value ≠0\ne 0=0" is the only guard on the ancestor and TTT-matrix conditions; no subtraction, division, or integral appears in the statement itself, though any such junk-value behaviour inside the unexpanded Feasible, obj, Tree, and Instance definitions is inherited unseen.

Human review
  • Endorsed by Shuze Chen · Sep 24, 2026

    Confirmed by the moderator at approval.

  • Endorsed by mikedeng1 · Sep 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 paper
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me