QMC: Transition Workshop - Reduced Component-by-Component Constructions of (Polynomial) Lattice Points - Peter Kritzer, May 9, 2018

Modiﬁed component-by-component
constructions of (polynomial) lattice points
Peter Kritzer
Johann Radon Institute for Computational and Applied Mathematics (RICAM)
Austrian Academy of Sciences
Linz, Austria
Joint work with
J. Dick (UNSW Sydney), A. Ebert (KU Leuven),
G. Leobacher (KFU Graz), F. Pillichshammer (JKU Linz)
SAMSI QMC Transition Workshop, May 9, 2018
Research supported by the Austrian Science Fund, Project F5506-N26
Peter Kritzer Modiﬁed component-by-component constructions of (polynomial) lattice points 1

Johann Radon Institute for Computational and Applied Mathematics
Introduction and Motivation

Consider integration of functions on [0, 1]d
,
Id (f) =
[0,1]d
f(x) dx ,
where f ∈ H, and H is some Banach space.

,
Id (f) =
[0,1]d
f(x) dx ,
Approximate Id by a quasi-Monte Carlo (QMC) rule,
Id (f) ≈ QN,d (f) =
1
N
N−1
k=0
f(xk ),
where PN = {x0, . . . , xN−1}.

,
Id (f) =
[0,1]d
f(x) dx ,
Approximate Id by a quasi-Monte Carlo (QMC) rule,
Id (f) ≈ QN,d (f) =
1
N
N−1
k=0
f(xk ),
where PN = {x0, . . . , xN−1}.
Both parameters d and N can be (very) large.

Worst case error in Banach space H with respect to
PN = {x0, . . . , xN−1} :
eN,d (H, PN) := sup
f∈H, f ≤1
|Id (f) − QN,d (f)| .

Worst case error in Banach space H with respect to
PN = {x0, . . . , xN−1} :
eN,d (H, PN) := sup
f∈H, f ≤1
|Id (f) − QN,d (f)| .
Need PN that makes eN,d (H, PN) small: How can we ﬁnd it?

Example of function space:
Weighted Korobov space (Hd,α,γ, · d,α,γ): space of continuous
functions f, where
f 2
d,α,γ =
h∈Zd
ρα,γ(h) |f(h)|2
,
where f(h)is the h-th Fourier coefﬁcient of f.

functions f, where
f 2
d,α,γ =
h∈Zd
ρα,γ(h) |f(h)|2
,
Here, ρα,γ(h) moderates the decay of the Fourier coefﬁcients,
depending on:
α > 1: “smoothness parameter” (higher α → smoother functions
in Hd,α,γ),

functions f, where
f 2
d,α,γ =
h∈Zd
ρα,γ(h) |f(h)|2
,
Here, ρα,γ(h) moderates the decay of the Fourier coefﬁcients,
depending on:
α > 1: “smoothness parameter” (higher α → smoother functions
in Hd,α,γ),
γ = (γu)u⊆{1,...,d}: coordinate weights.

Weights?
Sloan and Wo´zniakowski (1998): Assign weights to different
groups of coordinates to model their different inﬂuence on a
problem:
γ = (γu)u⊆{1,...,d}
of positive reals: weights.

Weights?
problem:
γ = (γu)u⊆{1,...,d}
Suitable weights can help to reduce negative inﬂuence of the
dimension.

Weights?
problem:
γ = (γu)u⊆{1,...,d}
Suitable weights can help to reduce negative inﬂuence of the
dimension.
Important class of weights: product weights
γu =
j∈u
γj
for positive reals γj . In this case, assume
1 = γ1, and γj ≥ γj+1 for all j.

Here:
PN = {x0, . . . , xN−1} is a lattice point set with generating vector
z = (z1, . . . , zd ) ∈ {1, . . . , N − 1}d
.

Here:
z = (z1, . . . , zd ) ∈ {1, . . . , N − 1}d
.
Points of PN:
xn = (xn,1, . . . , xn,d )
with
xn,j =
nzj
N
,
where {t} = t − t .

Here:
z = (z1, . . . , zd ) ∈ {1, . . . , N − 1}d
.
Points of PN:
xn = (xn,1, . . . , xn,d )
with
xn,j =
nzj
N
,
where {t} = t − t .
Note: Given N and d, z fully determines the lattice point set.

Lattice point set with d = 2, N = 34, and z = (1, 21):

Explicit formula for the (squared) worst-case error,
e2
N,d,α,γ(z) = −1 +
1
N
N−1
n=0
d
j=1
1 + γj ϕα
nzj
N
,
where ϕα
k
N can be computed for all values of k = 0, . . . , N − 1.
The error formula is easy to implement.

Question: is the Korobov space interesting?

Yes, ﬁrst reason: it is a model function space that makes it easier
to understand how lattice rules work.

Yes, ﬁrst reason: it is a model function space that makes it easier
to understand how lattice rules work.
Yes, second reason:
Bounds on the worst-case error of lattice rules in the Korobov
space with α = 2 immediately yield bounds on the worst-case
error of slightly modiﬁed lattice rules in certain Sobolev spaces.

All that remains is to ﬁnd “good” z ∈ {1, . . . , N − 1}d
.

.
Huge search space of size (N − 1)d
. (e.g., N = 10 000 and
d = 100).

.
. (e.g., N = 10 000 and
d = 100).
Component by component (CBC) construction: greedy algorithm
to construct zj one at a time.

.
. (e.g., N = 10 000 and
d = 100).
Component by component (CBC) construction: greedy algorithm
to construct zj one at a time.
Size of search space is N − 1 per component.
(Almost) optimal convergence of error bounds.

Algorithm 1 (CBC construction)
Let N be given. Construct z = (z1, . . . , zd ) as follows.
Set z1 = 1.

Set z1 = 1.
For s ∈ {2, . . . , d} assume that z1, . . . , zs−1 have already been
found. Now choose zs ∈ {1, . . . , N − 1} such that
e2
N,s,α,γ((z1, . . . , zs−1, zs))
is minimized as a function of zs.

Set z1 = 1.
e2
N,s,α,γ((z1, . . . , zs−1, zs))
Increase s and repeat the second step until (z1, . . . , zd ) is found.

Can do fast CBC (Cools, Nuyens, 2006): computation cost of
O(dN log N).

O(dN log N).
Computation cost of O(dN log N) can still be demanding for big
N, d

O(dN log N).
N, d
Might want to have big N, d simultaneously.

O(dN log N).
N, d
Might want to have big N, d simultaneously. → Can we speed
up the search?

The reduced CBC construction

Idea: make search space smaller for later components of z.
Let N be a prime power, N = bm
, b prime, m ∈ N.

, b prime, m ∈ N.
Let w1, . . . , wd , . . . ∈ N0 with 0 = w1 ≤ · · · ≤ wd ≤ · · · .

, b prime, m ∈ N.
Let w1, . . . , wd , . . . ∈ N0 with 0 = w1 ≤ · · · ≤ wd ≤ · · · .
Consider the sequence of reduced search spaces
ZN,wj
:=
{1 ≤ z < bm−wj : gcd(z, N) = 1} if wj < m,
{1} if wj ≥ m.

, b prime, m ∈ N.
Let w1, . . . , wd , . . . ∈ N0 with 0 = w1 ≤ · · · ≤ wd ≤ · · · .
ZN,wj
:=
{1} if wj ≥ m.
Note that
|ZN,wj
| :=
bm−wj −1
(b − 1) if wj < m,
1 if wj ≥ m.

, b prime, m ∈ N.
Let w1, . . . , wd , . . . ∈ N0 with 0 = w1 ≤ · · · ≤ wd ≤ · · · .
ZN,wj
:=
{1} if wj ≥ m.
Note that
|ZN,wj
| :=
bm−wj −1
(b − 1) if wj < m,
1 if wj ≥ m.
write Yj := bwj .

Algorithm 2 (Reduced CBC construction)
Let N, w1, . . . , wd , and Y1, . . . , Yd be as above. Construct
z = (Y1z1, . . . , Yd zd ) as follows.
Set z1 = 1.

Set z1 = 1.
found. Now choose zs ∈ ZN,ws
such that
e2
N,s,α,γ((Y1z1, . . . , Ys−1zs−1, Yszs))

Set z1 = 1.
such that
e2
N,s,α,γ((Y1z1, . . . , Ys−1zs−1, Yszs))
Increase s and repeat the second step until (Y1z1, . . . , Yd zd ) is
found.

Set z1 = 1.
such that
e2
N,s,α,γ((Y1z1, . . . , Ys−1zs−1, Yszs))
Increase s and repeat the second step until (Y1z1, . . . , Yd zd ) is
found.
Usual CBC construction: wj = 0 and Yj = 1 for all j.

Theorem 3 (Dick/K./Leobacher/Pillichshammer, 2015)
Let z = (Y1z1, . . . , Yd zd ) ∈ Zd
be constructed according to the
reduced CBC algorithm. Then,
eN,d,α,γ((Y1z1, . . . , Yd zd )) ≤
≤ N−α/2+δ

2
d
j=1
1 + γ
1
α−2δ
j 2ζ α
α−2δ bwj


α/2−δ
for all δ ∈ 0, α−1
2 , where ζ is the Riemann zeta function.

Theorem 3 (Dick/K./Leobacher/Pillichshammer, 2015)
Let z = (Y1z1, . . . , Yd zd ) ∈ Zd
be constructed according to the
reduced CBC algorithm. Then,
eN,d,α,γ((Y1z1, . . . , Yd zd )) ≤
≤ N−α/2+δ

2
d
j=1
1 + γ
1
α−2δ
j 2ζ α
α−2δ bwj


α/2−δ
for all δ ∈ 0, α−1
2 , where ζ is the Riemann zeta function.
Theorem formulated for product weights, similar result holds for
general weights.

If
B :=
∞
j=1
γ
1
α−2δ
j bwj
< ∞,
then the error can be bounded independently of the dimension.

The reduced fast CBC construction

Fast CBC construction (Nuyens/Cools) for non-reduced case
(wj = 0) has computation cost of O(dN log N).

Idea also works for the reduced case (assuming product weights;
POD weights: work in progress), yields reduced cost by
exploiting additional structure of the case wj > 0.

Bonus: once wj ≥ m the search space contains only one
element, construction of additional components zj incurs no extra
cost.

Bonus: once wj ≥ m the search space contains only one
element, construction of additional components zj incurs no extra
cost.
Computational cost of the reduced fast CBC construction is
O

N log N + min{d, d∗
}N +
min{d,d∗
}
j=1
(m − wj )Nb−wj

 ,
where d∗
:= max{j ∈ N : wj < m}.

Example:
Suppose (product) weights γj are γj = j−3
.

Example:
.
Fast CBC construction needs O(dmbm
) operations to compute a
generating vector for which the worst-case error is bounded
independently of the dimension.

Example:
.
Reduced fast CBC construction: choose, e.g., wj = 3
2 logb j .

Example:
.
2 logb j .
We need O(mbm
+ min{d, d∗
}mbm
generating vector for which the worst-case error is still bounded
independently of the dimension, as
j
γj bwj
< ζ(3/2) < ∞.

Example:
.
2 logb j .
We need O(mbm
+ min{d, d∗
}mbm
generating vector for which the worst-case error is still bounded
independently of the dimension, as
j
γj bwj
< ζ(3/2) < ∞.
Reduced fast CBC construction signiﬁcantly reduces
computation cost.

The successive coordinate search (SCS) algorithm

Question: can one improve on the quality of the output vector of the
CBC algorithm?

Question: can one improve on the quality of the output vector of the
CBC algorithm?
Ebert/Leövey/Nuyens (2016): successive coordinate search (SCS)
algorithm.
Basic idea:
Assume product weights.
Begin with a start vector z(0)
= (z
(0)
1 , . . . , z
(0)
d ).
Update components one after the other by minimizing worst-case
error.
Returned vector is at least as good as initial vector.

Algorithm 4 (SCS construction)
Let N be a prime. Let z(0)
= (z
(0)
1 , . . . , z
(0)
d ) ∈ {0, 1, . . . , N − 1}d
be
given.

= (z
(0)
1 , . . . , z
(0)
d ) ∈ {0, 1, . . . , N − 1}d
be
given.
e2
N,d,α,γ((z1, . . . , zs−1, zs, z
(0)
s+1, . . . , z
(0)
d ))

= (z
(0)
1 , . . . , z
(0)
d ) ∈ {0, 1, . . . , N − 1}d
be
given.
e2
N,d,α,γ((z1, . . . , zs−1, zs, z
(0)
s+1, . . . , z
(0)
d ))
Increase s and repeat the second step until z = (z1, . . . , zd ) is
found.

Theorem 5 (Ebert/Leövey/Nuyens, 2016)
Let z(1)
be constructed by the fast CBC algorithm.
Set z(0)
:= z(1)
in the SCS algorithm.
Let z be the vector returned by the SCS algorithm. Then
e2
N,d,α,γ(z) ≤ e2
N,d,α,γ(z(1)
).

Let z(1)
be constructed by the fast CBC algorithm.
Set z(0)
:= z(1)
in the SCS algorithm.
Let z be the vector returned by the SCS algorithm. Then
e2
N,d,α,γ(z) ≤ e2
N,d,α,γ(z(1)
).
Set z(0)
:= (0, 0, . . . , 0) in the SCS algorithm.
Then the SCS algorithm yields the same result as the usual CBC
algorithm. The SCS algorithm is thus a generalization of the CBC
algorithm.

The SCS algorithm yields improvements over the CBC algorithm
for pre-asymptotically moderately decreasing weights, e.g.
γj = 0.95j

The SCS algorithm yields improvements over the CBC algorithm
for pre-asymptotically moderately decreasing weights, e.g.
γj = 0.95j
There is a fast implementation of the SCS algorithm:
Pre-computation with cost of O(dN),
matrix-vector multiplication of same speed as in CBC algorithm,
total cost of O(dN log N).

The reduced fast SCS algorithm

Joint work with A. Ebert (2017/18):
Combine advantages of reduced fast CBC construction and fast SCS
construction:
reduced fast SCS construction.

Same setting as for reduced fast CBC construction, i.e.,
, b prime, m ∈ N.

, b prime, m ∈ N.
Let w1, . . . , wd , . . . ∈ N0 with 0 = w1 ≤ · · · ≤ wd ≤ · · · .

, b prime, m ∈ N.
Let w1, . . . , wd , . . . ∈ N0 with 0 = w1 ≤ · · · ≤ wd ≤ · · · .
ZN,wj
:=
{1} if wj ≥ m.

, b prime, m ∈ N.
Let w1, . . . , wd , . . . ∈ N0 with 0 = w1 ≤ · · · ≤ wd ≤ · · · .
ZN,wj
:=
{1} if wj ≥ m.
write Yj := bwj .

Algorithm 7 (Reduced SCS construction)
Let N be a prime power. Let
z(0)
= (z
(0)
1 , . . . , z
(0)
d ) ∈ {0, 1, . . . , N − 1}d
be given.

z(0)
= (z
(0)
1 , . . . , z
(0)
d ) ∈ {0, 1, . . . , N − 1}d
be given.
such that
e2
N,d,α,γ((Y1z1, . . . , Ys−1zs−1, Yszs, z
(0)
s+1, . . . , z
(0)
d ))

z(0)
= (z
(0)
1 , . . . , z
(0)
d ) ∈ {0, 1, . . . , N − 1}d
be given.
such that
e2
N,d,α,γ((Y1z1, . . . , Ys−1zs−1, Yszs, z
(0)
s+1, . . . , z
(0)
d ))
Increase s and repeat the second step until z = (Y1z1, . . . , Yd zd )
is found.

Theorem 8 (Ebert/K., 2018)
Assume product weights and let z = (Y1z1, . . . , Yd zd ) be constructed
by Algorithm 7. Then we have for all δ ∈ (0, α−1
2 ] that
eN,d,α,γ(z) ≤ Cd,α,γ,δ N−α/2+δ
,
where Cd,α,γ,δ is bounded independently of d if
∞
j=1
γ
1
α−2δ
j bwj
< ∞.

Theorem 8 (Ebert/K., 2018)
Assume product weights and let z = (Y1z1, . . . , Yd zd ) be constructed
by Algorithm 7. Then we have for all δ ∈ (0, α−1
2 ] that
eN,d,α,γ(z) ≤ Cd,α,γ,δ N−α/2+δ
,
where Cd,α,γ,δ is bounded independently of d if
∞
j=1
γ
1
α−2δ
j bwj
< ∞.
Theorem formulated for product weights, similar result holds for
general weights.

Special case of reduced SCS construction:
Set w1 = w2 = · · · = wd = 0. Then the new result generalizes the
previous SCS construction with respect to
General weights instead of product weights,
prime power N instead of prime N.

Reduced fast SCS construction:
Assume product weights,
Assume initial vector of the form z(0)
= (Y1z
(0)
1 , . . . , Yd z
(0)
d ) with
z
(0)
j ∈ ZN,wj
.

= (Y1z
(0)
1 , . . . , Yd z
(0)
d ) with
z
(0)
j ∈ ZN,wj
.
Use fast pre-computation (due to structure of z(0)
) and fast
matrix-vector multiplication (as in reduced fast CBC
construction).

= (Y1z
(0)
1 , . . . , Yd z
(0)
d ) with
z
(0)
j ∈ ZN,wj
.
Use fast pre-computation (due to structure of z(0)
) and fast
matrix-vector multiplication (as in reduced fast CBC
construction).
Implementation with overall cost
O

N log N + min{d, d∗
}N +
min{d,d∗
}
j=1
(m − wj )Nb−wj

 ,
where d∗
:= max{j ∈ N : wj < m}.

Numerical results

Computation times

Computation times (in seconds):
unreduced (normal font) and reduced CBC (bold font)
α = 2, b = 2, γj = (0.7)j
, wj = 3 logb j .
d = 50 d = 100 d = 500 d = 1000 d = 2000
m = 10
0.0173 0.0329 0.16 0.323 0.636
0.00298 0.00206 0.00218 0.00222 0.00241
m = 12
0.0256 0.0481 0.241 0.48 0.953
0.00358 0.00365 0.0037 0.00354 0.00439
m = 14
0.0469 0.0851 0.438 0.856 1.88
0.00803 0.00761 0.0105 0.00712 0.00747
m = 16
0.14 0.239 1.33 2.49 5.05
0.0237 0.0233 0.0233 0.0227 0.0251
m = 18
0.443 0.832 4.44 8.54 17.1
0.0798 0.0897 0.0915 0.091 0.09
m = 20
2.17 4.17 21.5 42.4 84.3
0.38 0.623 0.643 0.636 0.628
Intel Core i5-2400S CPU with 2.5GHz using Matlab.

Computation times (in seconds):
unreduced (normal font) and reduced SCS (bold font)
α = 2, b = 2, γj = (0.7)j
, wj = 3 logb j
d = 50 d = 100 d = 500 d = 1000 d = 2000
m = 10
0.0275 0.0516 0.256 0.516 1.03
0.00408 0.00327 0.00354 0.00347 0.00329
m = 12
0.0418 0.0751 0.383 0.756 1.56
0.00592 0.00504 0.00612 0.00516 0.00794
m = 14
0.0792 0.14 0.767 1.39 2.82
0.014 0.0136 0.0163 0.0138 0.0138
m = 16
0.204 0.388 2.09 4.05 8.04
0.0441 0.0434 0.0434 0.0423 0.0462
m = 18
0.686 1.35 6.89 13.7 26.8
0.16 0.177 0.182 0.183 0.187
m = 20
3.28 6.71 34.4 67.4 132
0.843 1.4 1.51 1.37 1.36
Intel Core i5-2400S CPU with 2.5GHz using Matlab.

Errors

Logarithmic errors for
d = 100, b = 2, α = 2, γj = 0.7j
, wj = 2 logb j :
zCBC zSCS zred
CBC zred
SCS
m = 6 -0.9858 -0.9874 -0.7760 -0.7817
m = 7 -1.6268 -1.6255 -1.4292 -1.4425
m = 8 -2.2860 -2.2810 -2.0997 -2.1021
m = 9 -2.9535 -2.9482 -2.7784 -2.7745
m = 10 -3.6389 -3.6271 -3.4536 -3.4631
For SCS errors, we consider the average of 100 runs of the
algorithms with random starting vectors.

Convergence rates

101
102
103
104
105
106
10-6
10-5
10-4
10-3
10-2
10-1

101
102
103
104
105
106
10-6
10-5
10-4
10-3
10-2
10-1
100

Polynomial lattice rules:
Polynomial lattice rules: similar to lattice rules, but integer
arithmetic replaced by polynomial arithmetic over ﬁnite ﬁelds.

Special cases of Niederreiter’s (t, m, d)-nets, powerful QMC
methods.

Special cases of Niederreiter’s (t, m, d)-nets, powerful QMC
methods.
All results shown above (CBC, fast CBC, reduced fast CBC,
SCS, fast SCS, reduced fast SCS) work analogously for
polynomial lattice rules.

Conclusion

Component-by-component (CBC) construction of (polynomial)
lattice points is a standard method in modern QMC theory.

Fast CBC construction by Nuyens/Cools needs O(dN log N)
operations.

operations.
We can reduce the construction cost depending on the
coordinate weights, sometimes obtain independence of the
dimension.

operations.
dimension.
The (fast) SCS algorithm can improve on the quality of
generating vectors, as compared to the CBC construction.

operations.
dimension.
We can reduce the run-time of the SCS algorithm, similarly to
that of the CBC construction.

operations.
dimension.
Numerical results demonstrate the effect of the reduced
approach.

operations.
dimension.
Numerical results demonstrate the effect of the reduced
approach.
Decision which algorithm to use when depends on parameter
settings.

Thanks for your attention.

J. Dick, P. Kritzer. On a projection-corrected component-by-component
construction. J. Complexity 32, 74–80, 2016.
J. Dick, P. Kritzer, G. Leobacher, F. Pillichshammer. A reduced fast
component-by-component construction of lattice points for integration in weighted
spaces with fast decreasing weights. J. Comput. Appl. Math. 276, 1–15, 2015.
A. Ebert, P. Kritzer. Constructing lattice points for numerical integration by a
reduced fast successive coordinate search algorithm. Submitted, 2018.
A. Ebert, H. Leövey, D. Nuyens. Successive Coordinate Search and
Component-by-Component Construction of Rank-1 Lattice Rules. To appear in:
P. Glynn, A. Owen (eds.), Monte Carlo and Quasi-Monte Carlo Methods 2016,
Springer, 2018.
H. Laimer. On combined component-by-component constructions of lattice point
sets. J. Complexity 38, 22–30, 2017.
D. Nuyens, R. Cools. Fast algorithms for component-by-component construction
of rank-1 lattice rules in shift-invariant reproducing kernel Hilbert spaces. Math.
Comp. 75, 903–920, 2006.

QMC: Transition Workshop - Reduced Component-by-Component Constructions of (Polynomial) Lattice Points - Peter Kritzer, May 9, 2018

Recommended

Recommended

More Related Content

What's hot

What's hot (6)

Similar to QMC: Transition Workshop - Reduced Component-by-Component Constructions of (Polynomial) Lattice Points - Peter Kritzer, May 9, 2018

Similar to QMC: Transition Workshop - Reduced Component-by-Component Constructions of (Polynomial) Lattice Points - Peter Kritzer, May 9, 2018 (20)

More from The Statistical and Applied Mathematical Sciences Institute

More from The Statistical and Applied Mathematical Sciences Institute (20)

Recently uploaded

Recently uploaded (20)

QMC: Transition Workshop - Reduced Component-by-Component Constructions of (Polynomial) Lattice Points - Peter Kritzer, May 9, 2018