Chapter 10, Theorem 1 — multistage Jensen lower bound via aggregation
DisprovedStochasticProg.MultistageBounds.thm1_multistage_jensen_lower_boundChapter 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,
i.e. , 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),
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.
import Mathlib import Definitions.Def_StochasticProg_MultistageBounds_Tree import Definitions.Def_StochasticProg_MultistageBounds_Instance
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
Read-back
What the Lean code literally says, in plain math · claude-opus-5
Fix a horizon and matrix dimensions (natural numbers, all of which may be zero). The statement is about two scenario trees of horizon — a fine tree and a coarse tree — 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 whose underlying value is a natural number, and an ancestor map (a total function, so of the root is some node, not "undefined"). Over these trees sit two instances and of the bundle's Instance structure, also not unfolded; the fields used are, for each node : a probability-like scalar , a vector , a matrix , a cost vector , and a single recourse matrix shared across nodes. Together with these come two bundle-defined predicates that the statement leaves opaque: for a decision , and a real-valued objective . Nothing in the statement pins down what "feasible" means, what type ranges over beyond what these predicates accept, or how is computed from ; all of that lives in the imported definitions.
The hypotheses are as follows. There is an aggregation map such that
- ;
- for every fine node , (stages are preserved exactly);
- for every fine node whose stage value is not , (aggregation commutes with taking the parent, except that nothing is required at stage- nodes).
The data of the two instances are tied together by:
- (the recourse matrices coincide);
- for every fine node , (costs are copied from the aggregated node);
- for every coarse node ,
the sum ranging over all fine nodes mapped to (an empty sum, hence the zero vector, if no fine node maps to );
- for every coarse node whose stage value is not ,
with the same convention; at stage- coarse nodes no relation between and is imposed.
Note that these are relations on the products and ; they do not say , nor that is a conditional expectation, and if they force the fine-side sums to vanish while leaving , arbitrary.
There is an arbitrary type of labels and a labelling such that for all coarse nodes with and , one has both and . (This is vacuous if is injective on each stage, and it forces all same-stage data to agree if has one element.)
Finally, two real numbers and are given, each characterized as the attained minimum of its instance's objective over feasible decisions:
- for every with , and there exists some with and ;
- for every with , and there exists some with and .
The conclusion is the single real inequality
Nothing is asserted about the objectives being convex, about being surjective, about the fine tree refining the coarse one in any structural sense beyond the three agg conditions, or about being nonnegative or summing to one.
In degenerate cases: if , or if either tree has a single node, the hypotheses reduce to statements about roots only and the claim is still for whatever and yield there. If or , the vectors and matrices are empty and the data hypotheses hold trivially. If some coarse node has no fine preimage under , the corresponding hypothesis reads (and 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 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 " is the only guard on the ancestor and -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.
Confirmed by the mission captain (proposal self-audit).
Confirmed by the moderator at approval.