# Approximation of High-Dimensional Rank One Tensors

- 339 Downloads
- 4 Citations

## Abstract

Many real world problems are high-dimensional in that their solution is a function which depends on many variables or parameters. This presents a computational challenge since traditional numerical techniques are built on model classes for functions based solely on smoothness. It is known that the approximation of smoothness classes of functions suffers from the so-called ‘curse of dimensionality’. Avoiding this curse requires new model classes for real world functions that match applications. This has led to the introduction of notions such as sparsity, variable reduction, and reduced modeling. One theme that is particularly common is to assume a tensor structure for the target function. This paper investigates how well a rank one function *f*(*x*_{1},…,*x*_{d})=*f*_{1}(*x*_{1})⋯*f*_{d}(*x*_{d}), defined on *Ω*=[0,1]^{d} can be captured through point queries. It is shown that such a rank one function with component functions *f*_{j} in \(W^{r}_{\infty}([0,1])\) can be captured (in *L*_{∞}) to accuracy *O*(*C*(*d*,*r*)*N*^{−r}) from *N* well-chosen point evaluations. The constant *C*(*d*,*r*) scales like *d*^{dr}. The queries in our algorithms have two ingredients, a set of points built on the results from discrepancy theory and a second adaptive set of queries dependent on the information drawn from the first set. Under the assumption that a point *z*∈*Ω* with nonvanishing *f*(*z*) is known, the accuracy improves to *O*(*dN*^{−r}).

### Keywords

Query algorithms High-dimensional approximation Separable functions Rate of approximation### Mathematics Subject Classification (2000)

41A25 65D15## 1 Introduction

A recurring model in certain high-dimensional application domains is that the target function is a low rank tensor, or can be approximated well by a linear combination of such tensors. For an overview of numerical methods based on this concept and their applications, we refer to [3] and the references therein. We consider a fundamental question concerning the computational complexity of such low rank tensors: If we know that a given function has such a tensor structure, to what accuracy can we approximate it using only a certain number of deterministically chosen point queries? In this paper, we treat this problem in the simplest setting where the tensors are of rank one.

*r*, we denote by \(W^{r}_{\infty}[0,1]\) the set of all univariate functions on [0,1] which have

*r*weak derivatives in

*L*

_{∞}, with the semi-norm

*Ω*:=[0,1]

^{d}. If

*r*is a positive integer and

*M*>0, we consider the class of functions

*i*.

For ease of presentation, we assume from now on that *M*≥1.

*MW*

^{r}(

*L*

_{∞}) consists of all functions

*f*(

*x*

_{1},…,

*x*

_{d}) for which

*Λ*

_{r}:={

*ν*=(

*ν*

_{1},…,

*ν*

_{d}): 0≤

*ν*

_{i}≤

*r*,

*i*=1,…,

*d*}. We define the norm on this space by adding \(\|f\|_{L_{\infty}(\varOmega)}\) to the above semi-norm. This is a well-studied class of functions, especially for the analysis of cubature formulae. These function spaces can also be characterized as tensor products of univariate Sobolev spaces, see [9]. Clearly, we have that \(\mathcal {F}^{r}(M)\) is contained in a finite ball of

*MW*

^{r}(

*L*

_{∞}(

*Ω*)) (see Chaps. III and V of [11]). It is known (see, e.g., [10], [11, IV.5], [1, Lemma 4.9]) that one can sample functions in

*MW*

^{r}(

*L*

_{∞}(

*Ω*)) on a set of points (called sparse grids) with cardinality

*N*and use these point values to construct an approximation to

*f*with accuracy \(C(d,r)\|f\|_{MW^{r}(L_{\infty})}N^{-r} [\log N]^{(r+1)(d-1)}\) in

*L*

_{∞}(

*Ω*).

The main result of the present paper is to present a query algorithm for functions \(f\in \mathcal {F}^{r}\). The query algorithm works without knowledge of *M*, but would require a bound on *r*. We show that we can query such a function *f* at *O*(*N*) suitably chosen points and from these queries we can construct an approximation \(\tilde{f}_{N}\) that approximates *f* to accuracy *C*(*r*,*d*)*N*^{−r}. Thus, for rank one tensors, the [log*N*]^{(r+1)(d−1)} appearing for mixed norm classes can be removed. Moreover, \(\tilde{f}_{N}\) is again separable, that is, the algorithm preserves this structural property of the original function *f*.

Given a budget *N*, our queries of *f* will have two stages. The first queries of *f* occur at a set of *O*(*N*) points built from discrepancy theory. If *f*(*z*)≠0 for one of the points *z* of the initial query, then we continue and sample *f* at *O*(*N*) points built from *z*. We then show how to build an approximation \(\tilde{f}_{N}\) to *f* from these query values which will provide the required accuracy.

## 2 Univariate Approximation

*g*(

*i*/

*N*), we can construct an approximation \(\mathcal {I}_{N}((g(i/N))_{i=1}^{N})\) that satisfies

*r*. Another is to simply take for each interval

*I*=[

*j*−1/

*N*,

*j*/

*N*),

*j*=1,…,

*N*, a set

*S*

_{j}of

*r*consecutive integers

*i*+1,…,

*i*+

*r*that contain

*j*−1 and

*j*, and then define

*g*on the interval

*I*as the polynomial of order

*r*that interpolates

*g*at the points in

*S*

_{j}.

In going further, we use any such construction of an operator \(\mathcal {I}_{N}\). We note that \(\mathcal {I}_{N}\) needs as input any vector *y*=(*y*_{0},…,*y*_{N}). The *y*_{i} are usually taken as function values such as *y*_{i}=*g*(*i*/*N*) above.

We need a second result about univariate functions summarized in the following lemma.

### Lemma 2.1

*Suppose*\(g\in W^{r}_{\infty}[0,1]\)

*is a univariate function that vanishes at*

*r*

*points*

*t*

_{1},…,

*t*

_{r}∈[0,1].

*If*

*J*

*is the smallest interval that contains all of the*

*t*

_{j},

*j*=1,…,

*r*,

*then*

### Proof

*g*

^{(k)}for

*k*=0,…,

*r*−1 is in \(W^{1}_{\infty}[0,1]\) and can thus be identified with a continuous function. From Rolle’s theorem, for each

*k*=0,…,

*r*−1, there is a point

*ξ*

_{k}in

*J*such that

*g*

^{(k)}(

*ξ*

_{k})=0. This gives the bound

## 3 Low-Discrepancy Point Sequences

*Ω*. The particular property we are interested in here is that no

*d*-dimensional rectangle contained in

*Ω*can have large measure without containing at least one of these points. We shall adopt a method for constructing such a sequence given in [4, 5] which rests on base

*q*expansions. For any prime number

*q*and any positive integer

*n*, we have a unique base

*q*representation

*b*

_{j}are the ‘bits’ of

*n*in base

*q*. For any

*n*<

*q*

^{k}, one has

*b*

_{j}(

*q*,

*n*)=0 for

*j*≥

*k*.

*b*

_{j})=(

*b*

_{j}(

*n*)) in hand, we define

*q*is fixed, the set of points

*Γ*

_{q}(

*m*):={

*γ*

_{q}(

*n*):1≤

*n*<

*m*} are in (0,1), and any point

*x*∈(0,1) satisfies

*m*=

*q*

^{k}for some positive integer

*k*, then

*Γ*

_{q}(

*m*) contains all points

*j*/

*m*,

*j*=1,…,

*m*−1, and so the distance in (3.1) does not exceed 1/

*m*. The general result for arbitrary

*m*follows from this.

### Definition 3.1

(Halton Sequence)

*d*≥1, we choose the first

*d*prime numbers

*p*

_{1},…,

*p*

_{d}. The sequence of points \((\hat{x}_{k})_{k\in \mathbb{N}}\) in [0,1]

^{d}is then defined by

The following theorem (see [8] and [2]) shows that this sequence of points is well scattered in the sense that we need.

### Theorem 3.2

*Let*\(\hat{x}_{k}\),

*k*=1,2,…,

*be defined as in*(3.2).

*For any*

*d*-

*dimensional rectangle*

*R*=(

*α*

_{1},

*β*

_{1})×⋯×(

*α*

_{d},

*β*

_{d})

*with*0≤

*α*

_{i}<

*β*

_{i}≤1

*that does not contain any of the points*\(\hat{x}_{k}\),

*k*=1,…,

*N*,

*we have the following bound for the measure*|

*R*|

*of*

*R*:

*where*\(C_{H}(d):= 2^{d} \prod_{i=1}^{d} p_{i} \).

### Proof

*d*-dimensional rectangle

*R*

_{0}⊂

*Ω*of the form

*t*

_{i}are positive integers. Such a rectangle obviously has volume ≥1/

*N*. We shall show that such a rectangle always contains a point \(\hat{x}_{k}\) for some 1≤

*k*≤

*N*and thus obtain the theorem for rectangles of this special type.

*R*

_{0}⊂

*Ω*, each

*t*

_{i}is in \(\{0,\dots,p_{i}^{\nu _{1}}-1\} \) and therefore has a unique expansion

*a*

_{i,j}∈{0,…,

*p*

_{i}−1}. We introduce the integers

*i*=1,…,

*d*. Therefore \(\hat{x}_{k}=(\gamma_{p_{1}}(k),\dots,\gamma_{p_{d}}(k))\) is in

*R*

_{0}, and we have proved the theorem in this special case.

We now consider the general rectangle *R* in the statement of the theorem. We claim that *R* contains a special rectangle *R*_{0} of the form (3.3) of volume larger than *C*_{H}(*d*)^{−1}|*R*|. Indeed, for the given *α*_{i}<*β*_{i}, we define *ν*_{i} to be the smallest integer such that there exists an integer *t*_{i} with \([t_{i} p^{-\nu_{i}} , (t_{i}+1) p^{-\nu_{i}} ) \subset(\alpha_{i}, \beta_{i})\). Then, \(\beta_{i} -\alpha_{i} < 2 p^{-\nu_{i} + 1}\), since otherwise *ν*_{i} would not be minimal. This means that *R* contains a special rectangle *R*_{0} with volume |*R*_{0}|≥*C*_{H}(*d*)^{−1}|*R*|. Since *R* does not contain any of the \(\hat{x}_{k}\), *k*=0,…,*N*, the same is true of *R*_{0}. Hence |*R*_{0}|≤*N*^{−1}, and so |*R*|≤*C*_{H}(*d*)*N*^{−1}. □

## 4 Query Points and the Approximation

*r*. If

*r*=1, then given our budget

*N*of queries, it would be sufficient to simply query

*f*at the points \(\hat{x}_{1},\hat{x}_{2}, \dots,\hat{x}_{N}\) of a Halton sequence in succession. However, when

*r*>1, we will

*occasionally*have to query

*f*at a cloud of points near each \(\hat{x}_{k}\) in order to take advantage of the higher smoothness of

*f*. We fix

*r*≥1 in what follows. We next describe the cloud of points where we might query

*f*. We define for each

*k*=1,2,…, and each

*n*≥

*k*,

*e*

_{i},

*i*=1,…,

*d*, is the usual coordinate basis for \(\mathbb{R}^{d}\). For each

*k*,

*n*, this set contains at most (2

*r*−1)

^{d}points and contains at least

*r*

^{d}points. When asked to query

*f*at one of the sets \(\varGamma_{n}(\hat{x}_{k})\), we traverse these points in lexicographic order.

*f*at point clouds \(\varGamma _{n_{k}}(\hat{x}_{k})\),

*k*=1,…. If we stipulate the budget

*N*in advance, we can then choose once and for all a single

*n*

_{k}as the smallest integer such that \(2^{n_{k}} \ge N\). For a given

*f*and fixed

*N*, this gives rise to the basic scheme given in Algorithm 1 for determining an approximation \(\tilde{f}_{N}\) to

*f*.

**Query 2**is defined for any

*z*such that

*f*(

*z*)≠0 and \(N\in \mathbb{N}\) as follows:

\(\tilde{f}_{N}\) := CrossApproximation(

*z*,*N*)- defining
*z*^{j}as the vector which agrees with*z*in all but the*j*-th coordinate and is zero in the*j*-th coordinate, evaluate*f*at the points$$ \tilde{z}_{j,i}:= z^j+\frac{i}{N}e_j, \quad i=1,\dots,N,\ j=1,\dots,d , $$(4.1) - and definewhere \(\mathcal {I}_{N}\) is the operator of Sect. 2. Then, setting$$ F_j:=\mathcal {I}_N \bigl(f(\tilde{z}_{j,i})_{i=1}^N \bigr),\quad j=1,\dots,d, $$(4.2)
*A*:=*f*(*z*), return$$ \tilde{f}_N(x):=A^{-d+1}F_1(x_1) \cdots F_d(x_d). $$(4.3)

*N*; i.e., when the budget

*N*is increased, one would still like to utilize the previous samples. This requires modifying both query stages. First, we will occasionally update the assignment of

*n*

_{k}, which means that the function

*f*has to be resampled at \(\varGamma_{n_{k}}(\hat{x}_{j})\) for some of the

*j*<

*k*. This leads us to the modification specified in

**Query 1**of Algorithm 2. Note that this query loop may be exited at any value of

*N*. As we will show below, the asymptotic complexity of Algorithm 1 is preserved.

Second, note that once a point *z* with *f*(*z*)≠0 is found for some *N*, Algorithm 2 proceeds directly to **Query 2** for every subsequent value of *N*. To keep the complexity of **Query 2** proportional to *N*, as *N* increases, we should also reuse the samples in preceding calls of **Query 2**. This can be done by dyadic nesting and leads to the modified procedure CrossApproximation^{∗}(*z*,*N*) obtained by replacing *N* in (4.1) and (4.2) by \(2^{\lceil\log_{2} N\rceil}\).

*Λ*

_{N}(

*f*) as the set of points where we have sampled

*f*in Algorithm 2, up to a given budget index

*N*. We want next to bound the cardinality of

*Λ*

_{N}(

*f*). Since \(\#(\varGamma_{n}(\hat{x}_{k}))\le(2r-1)^{d}\), for all choices

*n*,

*k*, the only issue in bounding the number of samples in

**Query 1**will be how many times we have resampled

*f*near \(\hat{x}_{j}\). Now, for a given \(\hat{x}_{j}\), we originally sample

*f*at the points \(\varGamma_{j}(\hat{x}_{j})\). This sampling will be updated to a sampling \(\varGamma_{2^{j}}(\hat{x}_{j})\) if 2

^{j}<

*N*. It will be updated again if \(2^{2^{j}}<N\) and so on. It follows that the only \(\hat{x}_{j}\) whose sampling is updated are those with

*j*≤log

_{2}

*N*and the maximum number of times it is updated is bounded by log

_{2}

*N*. Thus, the total number of samples taken in

**Query 1**does not exceed (2

*r*−1)

^{d}[

*N*+(log

_{2}

*N*)

^{2}]≤2⋅(2

*r*−1)

^{d}

*N*. This gives that the total number of samples taken is

## 5 Error of Approximation

We now analyze how well \(\tilde{f}_{N}\) approximates *f*.

### Theorem 5.1

*If*\(f\in \mathcal {F}^{r}(M)\),

*then for each*

*N*=1,2,…,

*we have*

*with*

*C*

_{H}(

*d*)

*as in Theorem*3.2.

*If*,

*however*,

**Query**

**1***stops at a point*

*z*

*where*

*f*(

*z*)≠0,

*and*

*N*

*satisfies*

*C*

_{1}(

*r*)

*MN*

^{−r}<1/(2

*d*),

*then*

The remainder of this section is devoted to the proof of this theorem. We will consider the two cases used for the definition of \(\tilde{f}_{N}\) in Algorithm 2.

### Proof

We fix an arbitrary *N*. We first consider:

**Case 1**: *No**z**with**f*(*z*)≠0 *has been found in***Query 1**.

In this case, \(\tilde{f}_{N} = 0\). In order to obtain the required bound for \(\|f\|_{L_{\infty}(\varOmega )}\), we begin with:

### Lemma 5.2

*Under the assumptions of Theorem* 5.1, *for each**k*=1,…,*N*, *there is a**j*∈{1,…,*d*} *such that**f*_{j}*vanishes at**r**distinct points in* [0,1] *of the form*\((\hat{x}_{k})_{j}+t_{i,j}\), *i*∈{−*r*+1,…,0,…*r*−1} *with* |*t*_{i,j}|≤*N*^{−1}.

### Proof of Lemma 5.2

We know that *f* vanishes at all points in \(\varGamma_{n_{k}}(\hat{x}_{k})\) where *n*_{k} is the last update associated to \(\hat{x}_{k}\). We also know that \(2^{-n_{k}}\le1/N\). We now prove the lemma for \(t_{i,j} = \frac{i}{r2^{n_{k}}}\). Suppose that the statement does not hold; then for this value of *k* and for each *j*=1,…,*d*, there is an *i*_{j}∈{−*r*+1,…,0,…*r*−1} such that \(z_{j}:=(\hat{x}_{k})_{j}+(r2^{n_{k}})^{-1} i_{j}\in[0,1]\) and *f*_{j}(*z*_{j})≠0. But then \(z:=(z_{1},\dots,z_{d})\in\varGamma_{n_{k}}(\hat{x}_{k})\) and *f*(*z*)≠0, which is the desired contradiction. □

For each *k*, we let \(\mathcal{C}_{k}\) be the set of all such integers *j*∈{1,…,*d*} with the properties stated in Lemma 5.2. We refer to the integers *j* in \(\mathcal{C}_{k}\) as the colors of \(\hat{x}_{k}\).

*f*vanishes at each of the points of

**Query 1**and that \(\tilde{f}_{N}=0\). Let

*x*=(

*x*

_{1},…,

*x*

_{d})∈

*Ω*. Our goal is to bound the value

*f*(

*x*). We define

*δ*

_{j}(

*x*) tells us how well we can approximate

*x*

_{j}by the numbers \((\hat{x}_{k})_{j}\) using those

*k*for which

*j*is in \(\mathcal{C}_{k}\).

*j*, and this is true for each

*j*=1,…,

*d*. Since, as we have already observed in Lemma 5.2, every \(\hat{x}_{k}\) has some colors, it follows that

*R*does not contain any of the points \(\hat{x}_{k}\),

*k*=1,…,

*N*. From Theorem 3.2, we have that |

*R*|≤

*C*

_{H}(

*d*)/

*N*. Since \(|R|\ge\prod_{j=1}^{d}\delta_{j}\), we obtain

*j*≤

*d*. In the case that the statement of Lemma 5.2 does not apply with this

*j*for any

*k*, we have \(\| f_{j} \|_{L_{\infty}[0,1]} \leq1 = \delta_{j} = \delta_{j}^{r}\). Otherwise, we know from the definition of coloring and the definition of

*δ*

_{j}that there exist

*r*points

*t*

_{1},…,

*t*

_{r}∈[0,1] contained in an interval

*J*of length 1/

*N*such that \(\operatorname{dist}(x_{j},J)\le\delta_{j}\) and

*f*

_{j}vanishes at each of these points. Hence, from Lemma 2.1, we obtain

*δ*

_{j},

*j*=1,…,

*d*are not greater than one. This completes the proof of the theorem in Case 1.

**Case 2**: **Query 1***has produced**z**such that**f*(*z*)≠0.

*z*=(

*z*

_{1},…,

*z*

_{d}), let

*A*:=

*f*(

*z*)≠0 and

*A*

_{j}:=∏

_{i≠j}

*f*

_{i}(

*z*

_{i}) for

*j*=1,…,

*d*. Sampling

*f*at the points \(\tilde{z}_{j,i}\) of (4.1) thus yields the values \(f(\tilde{z}_{j,i})=A_{j}f_{j}(i/N)\),

*i*=1,2,…,

*N*. Hence, from (2.1), we obtain

*j*=1,…,

*d*, we have

*y*

_{j}:=

*f*

_{j}(

*x*

_{j}) and \(y_{j}':=A_{j}^{-1}F_{j}(x_{j})\), in which case we can take

*L*:=1+

*C*

_{1}(

*r*)

*MN*

^{−r}to obtain

*ε*:=

*C*

_{1}(

*r*)

*MN*

^{−r}, we have

*ε*<1/(2

*d*) by our assumption, and hence

## 6 Optimality of the Algorithm

It is quite easy to see that our algorithm has asymptotically optimal performance, in terms of *N*, on the class \(\mathcal {F}^{r}(M)\).

### Theorem 6.1

*Given positive integers*

*r*

*and*

*d*,

*there is an absolute constant*

*c*(

*d*,

*r*)

*such that the following holds*:

*Given any algorithm which uses*

*N*

*point queries to approximate*

*f*

*by*

*A*

_{N}(

*f*),

*there is a function*\(f\in \mathcal {F}^{r}(M)\)

*such that*

### Proof

We can assume without loss of generality that *N*=*m*^{d}−1 for some positive integer *m*. We divide *Ω* into *N*+1 cubes of sidelength 1/*m*. To the proposed query algorithm we return the value zero to each of the *N* query points. Now we can choose a cube *Q* of sidelength 1/*m* which contains none of the *N* query points. There is a function \(g\in \mathcal {F}^{r}(M)\) which is supported in *Q* and has maximum value [*c*(*r*)*Mm*^{−r}]^{d}. Since the proposed algorithm gives *A*_{N}(*g*)=*A*_{N}(0), for one of the two functions *f*=0 or *f*=*g*, (6.1) follows. □

Let us finally relate our results to what is commonly referred to as the *curse of dimensionality*, see [6, 7]. First note that our estimate for the computational work in Algorithms 1 and 2 may be dominated by **Query 1**. In fact, according to the bound (5.1), the computational complexity of our algorithms—measured in terms of the number of generated degrees of freedom—required to realize a desired target accuracy may in general increase exponentially in the spatial dimension *d* and is therefore still subject to that “curse.” However, (5.2) says that, once a point *z* for which *f*(*z*)≠0 has been found, the complexity of the additional computational work needed to recover *f* within a desired accuracy *ϵ* grows only like (*d*/*ε*)^{1/r}, and hence this part of the algorithm would break the curse of dimensionality. Moreover, under additional assumptions on *f*, **Query 1** can have much lower complexity. For example, if each component function *f*_{j} is a polynomial of a fixed degree *p*, or more generally if each component has at most a fixed number *p* of zeros, then **Query 1** will terminate after at most *p* steps. Indeed, the Halton sequence never repeats a coordinate value. Even when further relaxing the assumptions on *f*, say to analyticity, and replacing in **Query 1** the sampling by random sampling, one could formulate a result according to which the algorithm breaks the curse of dimensionality with high probability.

## Notes

### Acknowledgements

This research was supported by the Office of Naval Research Contracts ONR N00014-08-1-1113, ONR N00014-09-1-0107, and ONR N00014-11-1-0712; the AFOSR Contract FA95500910500; the NSF Grants DMS-0810869, and DMS 0915231; and the DFG Special Priority Program SPP-1324. This research was done when R.D. was a visiting professor at RWTH and the AICES Graduate Program. This publication is based in part on work supported by Award No. KUS-C1-016-04 made by King Abdullah University of Science and Technology (KAUST).

### References

- 1.Bungartz, H.-J., Griebel, M.: Sparse grids. Acta Numer.
**13**, 147–269 (2004) CrossRefMathSciNetGoogle Scholar - 2.Dumitrescu, A., Jiang, M.: On the largest empty axis-parallel box amidst
*n*points. Algorithmica (2012). doi:10.1007/s00453-012-9635-5 MathSciNetGoogle Scholar - 3.Hackbusch, W.: Tensor Spaces and Numerical Tensor Calculus. Springer Series in Computational Mathematics, vol. 42. Springer, Berlin (2012) CrossRefMATHGoogle Scholar
- 4.Halton, J.H.: On the efficiency of certain quasi-random sequences of points in evaluating multi-dimensional integrals. Numer. Math.
**2**, 84–90 (1960) CrossRefMATHMathSciNetGoogle Scholar - 5.Hammersley, J.M.: Monte Carlo methods for solving multivariable problems. Ann. N.Y. Acad. Sci.
**86**, 844–874 (1960) CrossRefMATHMathSciNetGoogle Scholar - 6.Novak, E., Woźniakowski, H.: Tractability of Multivariate Problems, Volume I: Linear Information. EMS Tracts in Mathematics, vol. 6. Eur. Math. Soc., Zurich (2008) CrossRefGoogle Scholar
- 7.Novak, E., Woźniakowski, H.: Approximation of infinitely differentiable multivariate functions is intractable. J. Complex.
**25**, 398–404 (2009) CrossRefMATHGoogle Scholar - 8.Rote, G., Tichy, R.F.: Quasi-Monte-Carlo methods and the dispersion of point sequences. Math. Comput. Model.
**23**, 9–23 (1996) CrossRefMATHMathSciNetGoogle Scholar - 9.Sickel, W., Ullrich, T.: Tensor products of Sobolev–Besov spaces and applications to approximation from the hyperbolic cross. J. Approx. Theory
**161**, 748–786 (2009) CrossRefMATHMathSciNetGoogle Scholar - 10.Smolyak, S.A.: Quadrature and interpolation formulas tensor products of certain classes of functions. Sov. Math. Dokl.
**4**, 240–243 (1963) Google Scholar - 11.Temlyakov, V.: Approximation of Periodic Functions. Nova Science Publishers, New York (1993) MATHGoogle Scholar