Construction Algorithms for (Polynomial) Lattice Points Peter - - PowerPoint PPT Presentation

Construction Algorithms for (Polynomial) Lattice Points

Peter Kritzer

Johann Radon Institute for Computational and Applied Mathematics (RICAM) Austrian Academy of Sciences Joint work with

• J. Dick, A. Ebert, G. Leobacher, D. Nuyens,

O.O. Osisiogu, F . Pillichshammer MCM 2019, Sydney

Research supported by the Austrian Science Fund, Project F5506-N26

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 1

Johann Radon Institute for Computational and Applied Mathematics

1

Introduction and Motivation

2

The reduced CBC construction

3

The reduced fast CBC construction for POD weights

4

The successive coordinate search (SCS) construction

5

The reduced fast SCS construction

6

The CBC-DBD construction

7

Conclusion

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 2

Johann Radon Institute for Computational and Applied Mathematics

Introduction and Motivation

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 3

Johann Radon Institute for Computational and Applied Mathematics

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. 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.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 4

Johann Radon Institute for Computational and Applied Mathematics

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 find it?

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 5

Johann Radon Institute for Computational and Applied Mathematics

Function space considered here: Weighted Korobov space (Hd,α,γ, ·d,α,γ): space of 1-periodic continuous functions f, where f2

d,α,γ =

• h∈Zd

ρα,γ(h) | f(h)|2, where f(h)is the h-th Fourier coefficient of f. The function ρα,γ(h) moderates the decay of the Fourier coefficients.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 6

Johann Radon Institute for Computational and Applied Mathematics

Set ρα,γ(0) := 1. For h = (h1, . . . , hd), let u ⊆ {1, . . . , d} be the set of the j with hj = 0. Then ρα,γ(h) = γ−1

u

• j∈u

|hj|α . α > 1: “smoothness parameter” (higher α → smoother functions in Hd,α,γ), γ = (γu)u⊆{1,...,d}: coordinate weights.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 7

Johann Radon Institute for Computational and Applied Mathematics

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

• f positive reals: weights.

larger weights ≃ more influence of corresponding variables, smaller weights ≃ less influence of corresponding variables. Suitable weights can help to reduce negative influence 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.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 8

Johann Radon Institute for Computational and Applied Mathematics

Here: PN = {x0, . . . , xN−1} is a rank-1 lattice point set with generating vector 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.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 9

Johann Radon Institute for Computational and Applied Mathematics

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

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 10

Johann Radon Institute for Computational and Applied Mathematics

Worst-case error of a lattice rule with generating vector z: e2

N,d,α,γ(z) =

• 0=h∈Zd

h·z≡0 mod N

(ρα,γ(h))−1. Explicit formula for the (squared) worst-case error for product weights: 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.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 11

Johann Radon Institute for Computational and Applied Mathematics

Question: is the Korobov space interesting? Yes, first 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 modified lattice rules in certain unanchored Sobolev spaces.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 12

Johann Radon Institute for Computational and Applied Mathematics

All that remains is to find “good” z ∈ {1, . . . , N − 1}d. Huge search space of size (N − 1)d. (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 (Kuo, 2003).

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 13

Johann Radon Institute for Computational and Applied Mathematics

Algorithm 1 (CBC construction) Let N be given. Construct z = (z1, . . . , zd) as follows. 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. Increase s and repeat the second step until (z1, . . . , zd) is found.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 14

Johann Radon Institute for Computational and Applied Mathematics

Can do fast CBC (Cools, Nuyens, 2006): computation cost of O(dN log N). Computation cost of O(dN log N) can still be demanding for big N, d. Might want to have big N, d simultaneously. → Can we speed up the search?

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 15

Johann Radon Institute for Computational and Applied Mathematics

The reduced CBC construction (joint work with J. Dick, G. Leobacher, F. Pillichshammer)

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 16

Johann Radon Institute for Computational and Applied Mathematics

Idea: small weights for later components → make search space smaller for later components zj. Let N be a prime power, N = bm, b prime, m ∈ N. Let w1, w2, . . . ∈ N0 with 0 = w1 ≤ w2 ≤ · · · . Consider the sequence of reduced search spaces ZN,wj :=

• {1 ≤ z < bm−wj : gcd(z, N) = 1}

if wj < m, {1} if wj ≥ m. Note that |ZN,wj| :=

• bm−wj−1(b − 1)

if wj < m, 1 if wj ≥ m. write Yj := bwj.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 17

Johann Radon Institute for Computational and Applied Mathematics

Algorithm 2 (Reduced CBC construction) Let N, w1, . . . , wd, and Y1, . . . , Yd be as above. Construct z = (Y1z1, . . . , Ydzd) as follows. Set z1 = 1. For s ∈ {2, . . . , d} assume that z1, . . . , zs−1 have already been

• found. Now choose zs ∈ ZN,ws such that

e2

N,s,α,γ((Y1z1, . . . , Ys−1zs−1, Yszs))

is minimized as a function of zs. Increase s and repeat the second step until (Y1z1, . . . , Ydzd) is found. Usual CBC construction: wj = 0 and Yj = 1 for all j.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 18

Johann Radon Institute for Computational and Applied Mathematics

Theorem 3 (Dick/K./Leobacher/Pillichshammer, 2015) Let z = (Y1z1, . . . , Ydzd) ∈ Zd be constructed according to the reduced CBC algorithm. Then, eN,d,α,γ((Y1z1, . . . , Ydzd)) ≤ ≤ 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.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 19

Johann Radon Institute for Computational and Applied Mathematics

If B :=

∞

• j=1

γ

1 α−2δ

j

bwj < ∞, then the error bound is independent of the dimension.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 20

Johann Radon Institute for Computational and Applied Mathematics

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), 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 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}.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 21

Johann Radon Institute for Computational and Applied Mathematics

Computation times (in seconds) for b = 2, α = 2, γj = 0.7j:

wj = 0 (non-reduced) wj = ⌊3 logb j⌋ (reduced) d = 100 d = 500 d = 1000 d∗ m = 10 0.0329 0.0021 0.1600 0.0022 0.3230 0.0022 10 m = 14 0.0851 0.0076 0.4380 0.0105 0.8560 0.0071 25 m = 18 0.8320 0.0897 4.4400 0.0915 8.5400 0.0910 63 m = 20 4.1700 0.6230 21.5000 0.6430 42.4000 0.6360 101 fast CBC (top), reduced fast CBC (bottom).

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 22

Johann Radon Institute for Computational and Applied Mathematics

Error convergence: b = 3, α = 2, d = 100, γj = 0.8j:

101 102 103 104 105 106 10-2 10-1 100 101 102

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 23

Johann Radon Institute for Computational and Applied Mathematics

Error convergence: b = 3, α = 2, d = 100, γj = j−3:

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

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 24

Johann Radon Institute for Computational and Applied Mathematics

The reduced fast CBC construction for POD weights (joint work with A. Ebert, D. Nuyens)

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 25

Johann Radon Institute for Computational and Applied Mathematics

Recent result: Adaption of the reduced fast CBC construction to POD weights (motivated by a question by Ch. Schwab). POD weights: product and order-dependent weights, relevant for applications in PDEs with random coefficients: γu = Γ|u|

• j∈u

γj. Reduced fast CBC construction for this class of weights. Yields a slight improvement for the special case of product weights.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 26

Johann Radon Institute for Computational and Applied Mathematics

Theorem 4 (Ebert/K./Nuyens, 2019) Given a sequence 0 ≤ w1 ≤ w2 ≤ · · · and POD weights we can construct a lattice rule with N = bm points in d dimensions, whose worst-case error has almost optimal convergence, with construction cost of order O  

min{d,d∗}

• j=1

(m − wj + j) bm−wj   , The memory cost is O(min{d,d∗}

j=1

bm−wj). In case of product weights we need O(min{d,d∗}

j=1

(m − wj) bm−wj) for the construction with memory O(bm−w1).

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 27

Johann Radon Institute for Computational and Applied Mathematics

The successive coordinate search (SCS) construction

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 28

Johann Radon Institute for Computational and Applied Mathematics

Question: can one improve on the quality of the output vector of the CBC construction? Ebert/Leövey/Nuyens (2016): successive coordinate search (SCS) construction. 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.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 29

Johann Radon Institute for Computational and Applied Mathematics

Algorithm 5 (SCS construction) Let N be a prime. Let z(0) = (z(0)

1 , . . . , z(0) d ) ∈ {0, 1, . . . , N − 1}d be

given. For s ∈ {1, . . . , d} assume that z1, . . . , zs−1 have already been

• found. Now choose zs ∈ {1, . . . , N − 1} such that

e2

N,d,α,γ((z1, . . . , zs−1, zs, z(0) s+1, . . . , z(0) d ))

is minimized as a function of zs. Increase s and repeat the second step until z = (z1, . . . , zd) is found.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 30

Johann Radon Institute for Computational and Applied Mathematics

Theorem 6 (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 SCS. Then e2

N,d,α,γ(z) ≤ e2 N,d,α,γ(z(1)).

Theorem 7 (Ebert/Leövey/Nuyens, 2016) Set z(0) := (0, 0, . . . , 0) in the SCS construction. Then the SCS construction yields the same result as usual CBC

• construction. SCS is thus a generalization of CBC.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 31

Johann Radon Institute for Computational and Applied Mathematics

SCS yields improvements over the CBC construction for pre-asymptotically moderately decreasing weights, e.g. γj = 0.95j. There is a fast implementation of the SCS construction:

Pre-computation with cost of O(dN), matrix-vector multiplication of same speed as in CBC, total cost of O(dN log N).

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 32

Johann Radon Institute for Computational and Applied Mathematics

The reduced fast SCS construction (joint work with A. Ebert)

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 33

Johann Radon Institute for Computational and Applied Mathematics

Combine advantages of reduced fast CBC construction and fast SCS construction: reduced fast SCS construction. Same setting as for reduced fast CBC construction, brings similar results: Reduction in computation times if weights decay fast, similar error convergence behavior. Modify SCS construction to prime-power N, Generalization to arbitrary (not only product) weights.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 34

Johann Radon Institute for Computational and Applied Mathematics

The CBC-DBD construction (ongoing joint work with A. Ebert, D. Nuyens, O.O. Osisiogu)

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 35

Johann Radon Institute for Computational and Applied Mathematics

Slightly different function class (based on Korobov’s original work): Eα

d,γ :=

• f ∈ L2([0, 1]d) | ∃ C > 0 such that

|ˆ f(h)| ≤ C (ρα,γ(h))−1 ∀ h ∈ Zd . Eα

d,γ is a Banach space with norm given by

fEα

d,γ := sup

h∈Zd |ˆ

f(h)| ρα,γ(h). Worst-case error of a lattice rule with generating vector z:

• eN,d,α,γ(z) =
• 0=h∈Zd

h·z≡0 mod N

(ρα,γ(h))−1.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 36

Johann Radon Institute for Computational and Applied Mathematics

This yields a connection between Eα

d,γ and (Hd,α,γ, ·d,α,γ):

• eN,d,α,γ(z) = e2

N,d,α,γ(z).

Results on

• eN,d,α,γ(z)

(for Eα

d,γ)

thus automatically imply results on e2

N,d,α,γ(z)

(for Hd,α,γ, ·d,α,γ ).

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 37

Johann Radon Institute for Computational and Applied Mathematics

Recall our goal: Efficiently construct a “good” generating vector z = (z1, . . . , zd) ∈ {0, . . . , N − 1}d

• f a rank-1 lattice rule.

Assume N = 2n for some n ∈ N. For s ∈ {1, . . . , d} we write zs = zs,1 + zs,2 2 + · · · + zs,n 2n−1 with zs,v ∈ {0, 1}.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 38

Johann Radon Institute for Computational and Applied Mathematics

Idea by Korobov: Construct the digits zs,v ∈ {0, 1}, 1 ≤ v ≤ n,

• ne after the other.

This yields a digit-by-digit (DBD) construction. Go through the DBD-construction component-wise. This gives a CBC-DBD construction. Construction is extensible in d, but not in the number of digits (points).

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 39

Johann Radon Institute for Computational and Applied Mathematics

To this end: Define a complicated quality function: Let x ∈ N be odd, and n, s ∈ N, and let γ = (γu)u⊆{1,...,d} be positive

• weights. For 1 ≤ v ≤ n and 1 ≤ s ≤ d let

hs,v,γ(x) :=

n

• k=v

1 2k−v

2k

• m=1

m≡1 mod 2

 

• ∅=u⊆{1,...,s−1}

γu

• j∈u

ln 1 sin2(πmaj,n/2k) +

• w⊆{1,...,j−1}

γw∪{s}  

j∈w

ln 1 sin2(πmaj,n/2k)   ln 1 sin2(πmx/2v)   . Use hs,v,γ in the following CBC-DBD construction.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 40

Johann Radon Institute for Computational and Applied Mathematics

Algorithm 8 (CBC-DBD construction) Given N = 2n, d ∈ N, and γ = (γu)u⊆{1,...,d}. Set z1 = 1 and a2,1 = · · · = ad,1 = 1. Outer loop (CBC): for s ∈ {2, . . . , d}: Inner loop (DBD): for v ∈ {2, . . . , n}: Choose zs,v = argminz∈{0,1} hs,v,γ(as,v−1 + 2v−1z). Set as,v = as,v−1 + 2v−1zs,v. Increase v; repeat inner loop until v = n. Increase s; repeat outer loop until s = d. Set zs := as,n for 2 ≤ s ≤ d.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 41

Johann Radon Institute for Computational and Applied Mathematics

The CBC-DBD construction yields almost optimal results: Adaption of proof idea by Korobov (1960s): We write Md := {−(N − 1), . . . , N − 1}d \ {0} Note that

• eN,d,α,γ(z)

=

• 0=h∈Zd

h·z≡0 mod N

1 ρα,γ(h) =

• h∈Md

h·z≡0 mod N

1 ρα,γ(h) +

• h∈Md

h·z≡0 mod N

1 ρα,γ(h).

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 42

Johann Radon Institute for Computational and Applied Mathematics

We can easily show: Proposition 9 Let z = (z1, . . . , zd) ∈ Zd with gcd(zj, N) = 1 for all j = 1, . . . , d. Then, for α > 1 we have

• h∈Md

h·z≡0 mod N

1 ρα,γ(h) ≤ 1 Nα

• ∅=u⊆{1,...,d}

γα

u (4ζ(α))|u|.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 43

Johann Radon Institute for Computational and Applied Mathematics

The CBC-DBD algorithm constructs a generating vector z = (z1, . . . , zd) such that there exist constants C(γ, δ) with

• ∅=u⊆{1,...,d}

γu

• hu∈M|u|

hu·zu≡0 mod N

1

• j∈u |hj| ≤ C(γ, δ)N−1+δ

for any δ > 0, if the weights γ satisfy a suitable summability condition.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 44

Johann Radon Institute for Computational and Applied Mathematics

This result then yields Theorem 10 (Ebert/K./Osisiogu/Nuyens, 2019) Let N = 2n, and let γ = (γu)u⊆{1,...,d} be a sequence of positive weights satisfying

• u⊆N

|u|<∞

|u| (γu)1/|u| < ∞ Let z = (z1, . . . , zd) be the generating vector constructed by the CBC-DBD algorithm. Then for any δ > 0 and α > 1 we have

• eN,d,γα,α(z) ≤

1 Nα  

• ∅=u⊆{1,...,d}

γα

u (4ζ(α))|u| + C(γ, δ)Nαδ

  with γα = (γα

u )u⊆{1,...,d} and some positive constant C(γ, δ)

independent of d and N.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 45

Johann Radon Institute for Computational and Applied Mathematics

Note that: The proof technique is such that the CBC-DBD algorithm is independent of α. Rather elementary methods can be applied to ensure a run-time

• f O(dN log N) of the CBC-DBD algorithm.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 46

Johann Radon Institute for Computational and Applied Mathematics

Niederreiter & Pillichshammer, 2009: Idea of DBD construction for extensible (polynomial) lattice rules. Rules extensible in the number of points N, but not in dimension d (CBC-DBD construction: extensible in d, but not in N). Convergence rate not optimal (CBC-DBD-construction: almost

• ptimal convergence rate possible).

Future research: Can we obtain better convergence rate for extensible rules using Korobov’s original method? Can we obtain an algorithm extensible in N and d?

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 47

Johann Radon Institute for Computational and Applied Mathematics

Error convergence: N = 2n, d = 100, γj = j−2, α = 2, α = 3, α = 4:

101 102 103 104 105 106 10-20 10-18 10-16 10-14 10-12 10-10 10-8 10-6 10-4 10-2

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 48

Johann Radon Institute for Computational and Applied Mathematics

Error convergence: N = 2n, d = 100, γj = j−3, α = 2, α = 3, α = 4:

101 102 103 104 105 106 10-22 10-20 10-18 10-16 10-14 10-12 10-10 10-8 10-6 10-4 10-2

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 49

Johann Radon Institute for Computational and Applied Mathematics

Error convergence: N = 2n, d = 100, γj = 0.95j, α = 2, α = 3, α = 4:

101 102 103 104 105 106 10-4 10-2 100 102 104 106 108

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 50

Johann Radon Institute for Computational and Applied Mathematics

Error convergence: N = 2n, d = 100, γj = 0.7j, α = 2, α = 3, α = 4:

101 102 103 104 105 106 10-16 10-14 10-12 10-10 10-8 10-6 10-4 10-2 100

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 51

Johann Radon Institute for Computational and Applied Mathematics

Polynomial lattice rules: Polynomial lattice rules: similar to lattice rules, but integer arithmetic replaced by polynomial arithmetic over finite fields. Special cases of Niederreiter’s (t, m, d)-nets, powerful QMC methods. CBC, fast CBC, reduced fast CBC, SCS, fast SCS, reduced fast SCS work analogously for polynomial lattice rules. CBC-DBD construction for polynomial lattice rules: in progress.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 52

Johann Radon Institute for Computational and Applied Mathematics

Conclusion

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 53

Johann Radon Institute for Computational and Applied Mathematics

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)

• perations.

We can reduce the construction cost depending on the coordinate weights, sometimes obtain independence of the dimension. The (fast) SCS construction can improve on the quality of generating vectors, as compared to the CBC construction. We can reduce the run-time of the SCS algorithm, similarly to that of the CBC construction. CBC-DBD construction seems to be a useful alternative to previous algorithms.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 54

Johann Radon Institute for Computational and Applied Mathematics

Thanks for your attention.

Peter Kritzer Construction Algorithms for (Polynomial) Lattice Points 55