DASC: A DECOMPOSITION ALGORITHM FOR MULTISTAGE STOCHASTIC

PROGRAMS WITH STRONGLY CONVEX COST FUNCTIONS

Vincent Guigues
School of Applied Mathematics, FGV
arXiv:1711.04650v2 [math.OC] 18 Nov 2017

Praia de Botafogo, Rio de Janeiro, Brazil

[email protected]

Abstract. We introduce DASC, a decomposition method akin to Stochastic Dual Dynamic Programming
(SDDP) which solves some multistage stochastic optimization problems having strongly convex cost func-
tions. Similarly to SDDP, DASC approximates cost-to-go functions by a maximum of lower bounding
functions called cuts. However, contrary to SDDP where cuts are affine functions, the cuts computed with
DASC are quadratic functions. We also prove the convergence of DASC.

Keywords: Strongly convex value function and Monte-Carlo sampling and Stochastic Programming and
SDDP.

AMS subject classifications: 90C15, 90C90.

1. Introduction
Stochastic Dual Dynamic Programming (SDDP), introduced in [13], is a sampling-based extension of
the Nested Decomposition algorithm [1] which builds policies for some multistage stochastic optimization
problems. It has been used to solve many real-life problems and several extensions of the method have been
considered such as DOASA [15], CUPPS [3], ReSA [11], AND [2], and more recently risk-averse ([8], [9], [14],
[5], [16], [17], [12]) or inexact ([7]) variants. SDDP builds approximations for the cost-to-go functions which
take the form of a maximum of affine functions called cuts. We propose an extension of this algorithm called
DASC, which is a Decomposition Algorithm for multistage stochastic programs having Strongly Convex
cost functions. Similarly to SDDP, at each iteration the algorithm computes in a forward pass a sequence
of trial points which are used in a backward pass to build lower bounding functions called cuts. However,
contrary to SDDP where cuts are affine functions, the cuts computed with DASC are quadratic functions
and therefore the cost-to-go functions are approximated by a maximum of quadratic functions. The outline
of the study is as follows. In Section 2, we give in Proposition 2.3 a simple condition ensuring that the
value function of a convex optimization problem is strongly convex. In Section 3, we introduce the class of
optimization problems to which DASC applies and the necessary assumptions. DASC algorithm, which is
based on Proposition 2.3, is given in Section 4, while convergence of the algorithm is shown in Section 5.

2. Strong convexity of the value function

Let k · k be a norm on Rm and let f : X → R be a function defined on a convex subset X ⊂ Rm .
Definition 2.1 (Strongly convex functions). f is strongly convex on X ⊂ Rm with constant of strong
convexity α > 0 with respect to norm k · k iff
αt(1 − t)
f (tx + (1 − t)y) ≤ tf (x) + (1 − t)f (y) − ky − xk2 ,
2
for all 0 ≤ t ≤ 1, x, y ∈ X.
We have the following equivalent characterization of strongly convex functions:
Proposition 2.2. Let X ⊂ Rm be a convex set. Function f : X → R is strongly convex on X with constant
of strong convexity α > 0 with respect to norm k · k iff
α
(2.1) f (y) ≥ f (x) + sT (y − x) + ky − xk2 , ∀x, y ∈ X, ∀s ∈ ∂f (x).
2
1
 Let X ⊂ Rm and Y ⊂ Rn be two nonempty convex sets. Let A be a p×n real matrix, let B be a p×m
real matrix, let f : Y ×X → R, and let g : Y ×X → Rq . For b ∈ Rp , we define the value function

inf f (y, x)
(2.2) Q(x) =
y ∈ S(x) := {y ∈ Y, Ay + Bx = b, g(y, x) ≤ 0}.
DASC algorithm is based on Proposition 2.3 below giving conditions ensuring that Q is strongly convex:
Proposition 2.3. Consider value function Q given by (2.2). Assume that (i) X, Y are nonempty and convex
sets such that X ⊆ dom(Q) and Y is closed, (ii) f, g are lower semicontinuous and the components gi of g
are convex functions. If additionally f is strongly convex on Y ×X with constant of strong convexity α with
respect to norm k · k on Rm+n , then Q is strongly convex on X with constant of strong convexity α with
respect to norm k · k on Rm .
Proof. Take x1 , x2 ∈ X. Since X ⊆ dom(Q) the sets S(x1 ) and S(x2 ) are nonempty. Our assumptions
imply that there are y1 ∈ S(x1 ) and y2 ∈ S(x2 ) such that Q(x1 ) = f (y1 , x1 ) and Q(x2 ) = f (y2 , x2 ). Then
for every 0 ≤ t ≤ 1, by convexity arguments we have that ty1 + (1 − t)y2 ∈ S(tx1 + (1 − t)x2 ) and therefore
Q(tx1 + (1 − t)x2 ) ≤ f (ty1 + (1 − t)y2 , tx1 + (1 − t)x2 )
≤ tf (y1 , x1 ) + (1 − t)f (y2 , x2 ) − 12 αt(1 − t)k(y2 , x2 ) − (y1 , x1 )k2
≤ tQ(x1 ) + (1 − t)Q(x2 ) − 21 αt(1 − t)kx2 − x1 k2 ,
which completes the proof. 

3. Problem formulation and assumptions

We consider multistage stochastic optimization problems of the form
T
X
inf Eξ2 ,...,ξT [ ft (xt (ξ1 , ξ2 , . . . , ξt ), xt−1 (ξ1 , ξ2 , . . . , ξt−1 ), ξt )]
(3.3) x1 ,...,xT
t=1
xt (ξ1 , ξ2 , . . . , ξt ) ∈ Xt (xt−1 (ξ1 , ξ2 , . . . , ξt−1 ), ξt ) a.s., xt Ft -measurable, t = 1, . . . , T,
where x0 is given, ξ1 is deterministic, (ξt )Tt=2 is a stochastic process, Ft is the sigma-algebra Ft := σ(ξj , j ≤ t),
and Xt (xt−1 , ξt ), t = 1, . . . , T , can be of two types:
(S1) Xt (xt−1 , ξt ) = {xt ∈ Rn : xt ∈ Xt : xt ≥ 0, At xt + Bt xt−1 = bt } (in this case, for short, we say that
Xt is of type S1);
(S2) Xt (xt−1 , ξt ) = {xt ∈ Rn : xt ∈ Xt , gt (xt , xt−1 , ξt ) ≤ 0, At xt + Bt xt−1 = bt }. In this case, for short,
we say that Xt is of type S2.
For both kinds of constraints, ξt contains in particular the random elements in matrices At , Bt , and vector
bt . Note that a mix of these types of constraints is allowed: for instance we can have X1 of type S1 and X2
of type S2.

We make the following assumption on (ξt ):

(H0) (ξt ) is interstage independent and for t = 2, . . . , T , ξt is a random vector taking values in RK with a
discrete distribution and a finite support Θt = {ξt1 , . . . , ξtM } with pti = P(ξt = ξti ) > 0, i = 1, . . . , M , while
ξ1 is deterministic.1

We will denote by Atj , Btj , and btj the realizations of respectively At , Bt , and bt in ξtj . For this problem,
we can write Dynamic Programming equations: assuming that ξ1 is deterministic, the first stage problem is

inf x1 ∈Rn F1 (x1 , x0 , ξ1 ) := f1 (x1 , x0 , ξ1 ) + Q2 (x1 )
(3.4) Q1 (x0 ) =
x1 ∈ X1 (x0 , ξ1 )
for x0 given and for t = 2, . . . , T , Qt (xt−1 ) = Eξt [Qt (xt−1 , ξt )] with

inf xt ∈Rn Ft (xt , xt−1 , ξt ) := ft (xt , xt−1 , ξt ) + Qt+1 (xt )
(3.5) Qt (xt−1 , ξt ) =
xt ∈ Xt (xt−1 , ξt ),
1To alleviate notation and without loss of generality, we have assumed that the number M of possible realizations of ξ , the
t
size K of ξt , and n of xt do not depend on t.
2
with the convention that QT +1 is null.
We set X0 = {x0 } and make the following assumptions (H1) on the problem data: for t = 1, . . . , T ,

(H1)-(a) for every xt , xt−1 ∈ Rn the function ft (xt , xt−1 , ·) is measurable and for every j = 1, . . . , M , the
function ft (·, ·, ξtj ) is strongly convex on Xt ×Xt−1 with constant of strong convexity αtj > 0 with respect to
norm k · k2 ;
(H1)-(b) Xt is nonempty, convex, and compact;
εt
(H1)-(c) there exists εt > 0 such that for every j = 1, . . . , M , for every xt−1 ∈ Xt−1 , the set Xt (xt−1 , ξtj )∩
ri(Xt ) is nonempty.

If Xt is of type S2 we additionally assume that:

(H1)-(d) for t = 1, . . . , T , there exists ε̃t > 0 such that for every j = 1, . . . , M , each component
ε̃t
gti (·, ·, ξtj ), i = 1, . . . , p, of the function gt (·, ·, ξtj ) is convex on Xt ×Xt−1 ;
(H1)-(e) for t = 2, . . . , T , ∀j = 1, . . . , M , there exists (x̄tjt−1 , x̄tjt ) ∈ Xt−1 ×ri(Xt ) such that Atj x̄tjt +
Btj x̄tjt−1 = btj , and (x̄tjt−1 , x̄tjt ) ∈ ri({gt (·, ·, ξtj ) ≤ 0}).

Remark 3.1. For a problem of form (3.3) where the strong convexity assumption of functions ft (·, ·, ξtj ) fails
to hold, if for every t, j function ft (·, ·, ξtj ) is convex and if the columns of matrix (Atj Btj ) are independant
then we may reformulate the problem pushing and penalizing the linear coupling constraints in the objective,
ending up with the strongly convex cost function ft (·, ·, ξtj )+ ρt kAtj xt + Btj xt−1 − btj k22 in variables (xt , xt−1 )
for stage t realization ξtj for some well chosen penalization ρt > 0.

4. DASC Algorithm
T −1
Due to Assumption (H0), the M realizations of (ξt )Tt=1 form a scenario tree of depth T + 1 where the
root node n0 associated to a stage 0 (with decision x0 taken at that node) has one child node n1 associated
to the first stage (with ξ1 deterministic).
We denote by N the set of nodes, by Nodes(t) the set of nodes for stage t and for a node n of the tree,
we define:
• C(n): the set of children nodes (the empty set for the leaves);
• xn : a decision taken at that node;
• pn : the transition probability from the parent node of n to n;
• ξn : the realization of process (ξt ) at node n2: for a node n of stage t, this realization ξn contains in
particular the realizations bn of bt , An of At , and Bn of Bt ;
• ξ[n] : the history of the realizations of process (ξt ) from the first stage node n1 to node n: for a node
n of stage t, the i-th component of ξ[n] is ξP t−i (n) for i = 1, . . . , t, where P : N → N is the function
associating to a node its parent node (the empty set for the root node).
Similary to SDDP, at iteration k, trial points xkn are computed in a forward pass for all nodes n of the
k−1
scenario tree replacing recourse functions Qt+1 by the approximations Qt+1 available at the beginning of
this iteration.
In a backward pass, we then select a set of nodes (nk1 , nk2 , . . . , nkT ) (with nk1 = n1 , and for t ≥ 2, nkt a node
of stage t, child of node nkt−1 ) corresponding to a sample (ξ˜1k , ξ̃2k , . . . , ξ˜Tk ) of (ξ1 , ξ2 , . . . , ξT ). For t = 2, . . . , T ,
a cut
αt
(4.6) Ctk (xt−1 ) = θtk + hβtk , xt−1 − xknk i + kxt−1 − xknk k22
t−1 2 t−1

2The same notation ξ

Index is used to denote the realization of the process at node Index of the scenario tree and the value
of the process (ξt ) for stage Index. The context will allow us to know which concept is being referred to. In particular, letters
n and m will only be used to refer to nodes while t will be used to refer to stages.
3
is computed for Qt at xknk where
t−1

M
X
(4.7) αt = ptj αtj ,
j=1

and where the computation of coefficients θtk , βtk is given below. We show in Section 5 that cut Ctk is a
lower bounding function for Qt . Contrary to SDDP where cuts are affine functions our cuts are quadratic
functions. In the end of iteration k, we obtain the lower approximations Qkt of Qt , t = 2, . . . , T + 1, given by

Qkt (xt−1 ) = max Ctℓ (xt−1 ),

1≤ℓ≤k

which take the form of a maximum of quadratic functions. The detailed steps of the DASC algorithm are
given below.

DASC, Step 1: Initialization. For t = 2, . . . , T , take as initial approximations Q0t ≡ −∞. Set
x1n0= x0 , set the iteration count k to 1, and Q0T +1 ≡ 0.

DASC, Step 2: Forward pass. The forward pass performs the following computations:
For t = 1, . . . , T ,
For every node n of stage t − 1,
For every child node m of node n, compute an optimal solution xkm of

inf Ftk−1 (xm , xkn , ξm ) := ft (xm , xkn , ξm ) + Qt+1

k−1
(
k−1 k (xm )
(4.8) Qt (xn , ξm ) = xm
k
xm ∈ Xt (xn , ξm ),

where xkn0 = x0 .
End For
End For
End For

DASC, Step 3: Backward pass. We select a set of nodes (nk1 , nk2 , . . . , nkT ) with nkt a node of stage t
(nk1 = n1 and for t ≥ 2, nkt a child node of nkt−1 ) corresponding to a sample (ξ˜1k , ξ̃2k , . . . , ξ˜Tk ) of (ξ1 , ξ2 , . . . , ξT ).
Set θTk +1 = αT +1 = 0 and βTk +1 = 0 which defines CTk +1 ≡ 0.
For t = T, . . . , 2,
For every child node m of n = nkt−1
Compute an optimal solution xBk m of
(
inf Ftk (xm , xkn , ξm ) := ft (xm , xkn , ξm ) + Qkt+1 (xm )
(4.9) Qkt (xkn , ξm ) = xm
xm ∈ Xt (xkn , ξm ).

For the problem above, if Xt is of type S1 we define the Lagrangian L(xm , λ, µ) = Ftk (xm , xkn , ξm ) +
λT (Am xm + Bm xkn − bm ) and take optimal Lagrange multipliers λkm . If Xt is of type S2 we define the
Lagrangian L(xm , λ, µ) = Ftk (xm , xkn , ξm ) + λT (Am xm + Bm xkn − bm ) + µT gt (xm , xkn , ξm ) and take optimal
Lagrange multipliers (λkm , µkm ). If Xt is of type S1, denoting by SGft (xBk
m ,·,ξm )
(xkn ) a subgradient of convex
Bk k km k k
function ft (xm , ·, ξm ) at xn , we compute θt = Qt (xn , ξm ) and

β km = SGft (xBk
m ,·,ξm )
(xkn ) + Bm
T k
λm .

If Xt is of type S2 denoting by SGgti (xBk

m ,·,ξm )
(xkn ) a subgradient of convex function gti (xBk k
m , ·, ξm ) at xn we
km k k
compute θt = Qt (xn , ξm ) and
p
X
β km = SGft (xBk
m ,·,ξm )
(xkn ) + Bm
T k
λm + µkm (i)SGgti (xBk
m ,·,ξm )
(xkn ).
i=1
4
 End For
The new cut Ctk is obtained computing
X X
(4.10) θtk = pm θtkm and βtk = pm β km .
m∈C(n) m∈C(n)

End For

DASC, Step 4: Do k ← k + 1 and go to Step 2.

Remark 4.1. In DASC, decisions are computed at every iteration for all the nodes of the scenario tree in
the forward pass. However, in practice, sampling will be used in the forward pass to compute at iteration k
decisions only for the nodes (nk1 , . . . , nkT ) and their children nodes. The variant of DASC written above is
convenient for the convergence analysis of the method, presented in the next section. From this convergence
analysis, it is possible to show the convergence of the variant of DASC which uses sampling in the forward
pass (see also Remark 5.4 in [7] and Remark 4.3 in [10]).

5. Convergence analysis
In Theorem 5.2 below we show the convergence of DASC making the following additional assumption:

(H2) The samples in the backward passes are independent: (ξ˜2k , . . . , ξ̃Tk ) is a realization of ξ k = (ξ2k , . . . , ξTk ) ∼
(ξ2 , . . . , ξT ) and ξ 1 , ξ 2 , . . . , are independent.

We will make use of the following lemma:

Lemma 5.1. Let Assumptions (H0) and (H1) hold. Then for t = 2, . . . , T + 1, function Qt is convex and
Lipschitz continuous on Xt−1 .
Proof. The proof is analogue to the proofs of Lemma 3.2 in [6] and Lemma 2.2 in [4]. 
Theorem 5.2. Consider the sequences of stochastic decisions xkn and of recourse functions Qkt generated by
DASC. Let Assumptions (H0), (H1) and (H2) hold. Then
(i) almost surely, for t = 2, . . . , T + 1, the following holds:
H(t) : ∀n ∈ Nodes(t − 1), lim Qt (xkn ) − Qkt (xkn ) = 0.
k→+∞

(ii) Almost surely, the limit of the sequence (F1k−1 (xkn1 , x0 , ξ1 ))k of the approximate first stage optimal val-
ues and of the sequence (Qk1 (x0 , ξ1 ))k is the optimal value Q1 (x0 ) of (3.3). Let Ω = (Θ2 × . . . ×ΘT )∞
be the sample space of all possible sequences of scenarios equipped with the product P of the corre-
sponding probability measures. Define on Ω the random variable x∗ = (x∗1 , . . . , x∗T ) as follows. For
ω ∈ Ω, consider the corresponding sequence of decisions ((xkn (ω))n∈N )k≥1 computed by DASC. Take
any accumulation point (x∗n (ω))n∈N of this sequence. If Zt is the set of Ft -measurable functions,
define x∗1 (ω), . . . , x∗T (ω) taking x∗t (ω) : Zt → Rn given by x∗t (ω)(ξ1 , . . . , ξt ) = x∗m (ω) where m is given
by ξ[m] = (ξ1 , . . . , ξt ) for t = 1, . . . , T . Then P((x∗1 , . . . , x∗T ) is an optimal solution to (3.3)) = 1.
Proof. Let us prove (i). We first check by induction on k and backward induction on t that for all k ≥ 0, for
all t = 2, . . . , T + 1, for any node n of stage t − 1 and decision xn taken at that node we have
(5.11) Qt (xn ) ≥ Ctk (xn ),
almost surely. For any fixed k, relation (5.11) holds for t = T + 1 and if it holds until iteration k
for t + 1 with t ∈ {2, . . . , T }, we deduce that for any node n of stage t − 1 and decision xn taken at
that node we have Qt+1 (xn ) ≥ Qkt+1 (xn ), Qt (xn , ξm ) ≥ Qkt (xn , ξm ) for any child node m of n. Now
note that function (xm , xn ) → Qkt+1 (xm ) is convex (as a maximum of convex functions) and recalling
that (xm , xn ) → ft (xm , xn , ξm ) is strongly convex with constant of strong convexity αtm , the function
(xm , xn ) → ft (xm , xn , ξm ) + Qkt+1 (xm ) is also strongly convex with the same parameter of strong convexity.
Using Proposition 2.3, it follows that Qkt (·, ξm ) is strongly convex with constant of strong convexity αtm .
5
Using Lemma 2.1 in [6] we have that β km ∈ ∂Qkt (·, ξm )(xknk ). Recalling characterization (2.1) of strongly
t−1
convex functions (see Proposition 2.2), we get for any xn ∈ Xt−1 :

Qkt (xn , ξm ) ≥ Qkt (xknk , ξm ) + hβ km , xn − xknk i + αtm

2 kxn − xknk k22
t−1 t−1 t−1

and therefore for any node n of stage t − 1 and decision xn taken at that node we have
X
Qt (xn ) = pm Qt (xn , ξm )
m∈C(n)
X
≥ pm Qkt (xn , ξm )
m∈C(n)
(5.12) X  αtm 
≥ pm Qkt (xknk , ξm ) + hβ km , xn − xknk i + kxn − xknk k22
t−1 t−1 2 t−1
m∈C(n)
αt
= θtk + hβtk , xn − xknk i + 2 kxn − xknk k22
t−1 t−1
= Ctk (xn ).
This completes the induction step and shows (5.11) for every t, k.
Let Ω1 be the event on the sample space Ω of sequences of scenarios such that every scenario is sampled
an infinite number of times. Due to (H2), this event has probability one. Take an arbitrary realization ω of
DASC in Ω1 . To simplify notation we will use xkn , Qkt , θtk , βtk instead of xkn (ω), Qkt (ω), θtk (ω), βtk (ω).
We want to show that H(t), t = 2, . . . , T + 1, hold for that realization. The proof is by backward induction
on t. For t = T + 1, H(t) holds by definition of QT +1 , QkT +1 . Now assume that H(t + 1) holds for some
t ∈ {2, . . . , T }. We want to show that H(t) holds. Take an arbitrary node n ∈ Nodes(t − 1). For this node
we define Sn = {k ≥ 1 : nkt−1 = n} the set of iterations such that the sampled scenario passes through node
n. Observe that Sn is infinite because the realization of DASC is in Ω1 . We first show that
lim Qt (xkn ) − Qkt (xkn ) = 0.
k→+∞,k∈Sn

For k ∈ Sn , we have nkt−1 = n, i.e., xkn = xknk , which implies, using (5.11), that
t−1

X X
(5.13) Qt (xkn ) ≥ Qkt (xkn ) ≥ Ctk (xkn ) = θtk = pm θtkm = pm Qkt (xkn , ξm )
m∈C(n) m∈C(n)

by definition of Ctk and θtk . It follows that for any k ∈ Sn we have

X  
0 ≤ Qt (xkn ) − Qkt (xkn ) ≤ pm Qt (xkn , ξm ) − Qkt (xkn , ξm )
m∈C(n)  
X
≤ pm Qt (xkn , ξm ) − Qtk−1 (xkn , ξm )
m∈C(n)  
X
= pm Qt (xkn , ξm ) − Ftk−1 (xkm , xkn , ξm )
m∈C(n)
(5.14) X 
k−1 k

= pm Qt (xkn , ξm ) − ft (xkm , xkn , ξm ) − Qt+1 (xm )
m∈C(n)  
X
k−1 k
= pm Qt (xkn , ξm ) − Ft (xkm , xkn , ξm ) + Qt+1 (xkm ) − Qt+1 (xm )
m∈C(n)  
X
k−1 k
≤ pm Qt+1 (xkm ) − Qt+1 (xm ) ,
m∈C(n)

where for the last inequality we have used the definition of Qt and the fact that xkm ∈ Xt (xkn , ξm ).
Next, recall that Qt+1 is convex; by Lemma 5.1 functions (Qkt+1 )k are Lipschitz continuous; and for all
k ≥ 1 we have Qkt+1 ≤ Qk+1
t+1 ≤ Qt+1 on compact set Xt . Therefore, the induction hypothesis

lim Qt+1 (xkm ) − Qkt+1 (xkm ) = 0

k→+∞
6
implies, using Lemma A.1 in [4], that
k−1 k
(5.15) lim Qt+1 (xkm ) − Qt+1 (xm ) = 0.
k→+∞

Plugging (5.15) into (5.14) we obtain

(5.16) lim Qt (xkn ) − Qkt (xkn ) = 0.
k→+∞,k∈Sn

It remains to show that

(5.17) lim Qt (xkn ) − Qkt (xkn ) = 0.
k→+∞,k∈S
/ n

The relation above can be proved using Lemma 5.4 in [10] which can be applied since (A) relation (5.16) holds
(convergence was shown for the iterations in Sn ), (B) the sequence (Qkt )k is monotone, i.e., Qkt ≥ Qtk−1 for all
k
k ≥ 1, (C) Assumption (H2) holds, and (D) ξt−1 is independent on ((xjn , j = 1, . . . , k), (Qjt , j = 1, . . . , k−1)).3
Therefore, we have shown (i).

(ii) can be proved as Theorem 5.3-(ii) in [7] using (i). 

Acknowledgments
The author’s research was partially supported by an FGV grant, CNPq grant 311289/2016-9, and FAPERJ
grant E-26/201.599/2014.

References
[1] J.R. Birge. Decomposition and partitioning methods for multistage stochastic linear programs. Oper. Res., 33:989–1007,
1985.
[2] J.R. Birge and C. J. Donohue. The Abridged Nested Decomposition Method for Multistage Stochastic Linear Programs
with Relatively Complete Recourse. Algorithmic of Operations Research, 1:20–30, 2001.
[3] Z.L. Chen and W.B. Powell. Convergent Cutting-Plane and Partial-Sampling Algorithm for Multistage Stochastic Linear
Programs with Recourse. J. Optim. Theory Appl., 102:497–524, 1999.
[4] P. Girardeau, V. Leclere, and A.B. Philpott. On the convergence of decomposition methods for multistage stochastic convex
programs. Mathematics of Operations Research, 40:130–145, 2015.
[5] V. Guigues. SDDP for some interstage dependent risk-averse problems and application to hydro-thermal planning. Com-
putational Optimization and Applications, 57:167–203, 2014.
[6] V. Guigues. Convergence analysis of sampling-based decomposition methods for risk-averse multistage stochastic convex
programs. SIAM Journal on Optimization, 26:2468–2494, 2016.
[7] V. Guigues. Inexact decomposition methods for solving deterministic and stochastic convex dynamic programming equa-
tions. arXiv, 2017. https://arxiv.org/abs/1707.00812.
[8] V. Guigues and W. Römisch. Sampling-based decomposition methods for multistage stochastic programs based on extended
polyhedral risk measures. SIAM J. Optim., 22:286–312, 2012.
[9] V. Guigues and W. Römisch. SDDP for multistage stochastic linear programs based on spectral risk measures. Operations
Research Letters, 40:313–318, 2012.
[10] V. Guigues, W. Tekaya, and M. Lejeune. Regularized decomposition methods for deterministic and stochastic convex
optimization and application to portfolio selection with direct transaction and market impact costs. Optimization OnLine,
2017.
[11] M. Hindsberger and A. B. Philpott. Resa: A method for solving multi-stage stochastic linear programs. SPIX Stochastic
Programming Symposium, 2001.
[12] V. Kozmik and D.P. Morton. Evaluating policies in risk-averse multi-stage stochastic programming. Mathematical Pro-
gramming, 152:275–300, 2015.
[13] M.V.F. Pereira and L.M.V.G Pinto. Multi-stage stochastic optimization applied to energy planning. Math. Program.,
52:359–375, 1991.
[14] A. Philpott and V. de Matos. Dynamic sampling algorithms for multi-stage stochastic programs with risk aversion. European
Journal of Operational Research, 218:470–483, 2012.
[15] A. B. Philpott and Z. Guan. On the convergence of stochastic dual dynamic programming and related methods. Oper.
Res. Lett., 36:450–455, 2008.
[16] A. Shapiro. Analysis of stochastic dual dynamic programming method. European Journal of Operational Research, 209:63–
72, 2011.

3Lemma 5.4 in [10] is similar to the end of the proof of Theorem 4.1 in [6] and uses the Strong Law of Large Numbers. This
lemma itself applies the ideas of the end of the convergence proof of SDDP given in [4], which was given with a different (more
general) sampling scheme in the backward pass.
7
[17] A. Shapiro, D. Dentcheva, and A. Ruszczyński. Lectures on Stochastic Programming: Modeling and Theory. SIAM,
Philadelphia, 2009.