text:
# On the numerical rank of radial basis function kernel matrices in high dimension

Low-rank approximations are popular techniques to reduce the high computational cost of large-scale kernel matrices, which are of significant interest in many applications. The success of low-rank methods hinges on the matrix rank, and in practice, these methods are effective even for high-dimensional datasets. The practical success has elicited the theoretical analysis of the rank in this paper. We will consider radial basis functions (RBF) and present theorems on the rank and error bounds. Our three main results are as follows. First, the rank of RBFs grows polynomially with the data dimension, in the worst case; second, precise approximation error bounds in terms of function properties and data structures are derived; and last, a group pattern in the decay of singular values for RBF kernel matrices is analyzed, and is explained by a grouping of the expansion terms. Empirical results verify and illustrate the theoretical results.

## Authors

• 8 publications
• 15 publications
• 31 publications
• ### On the numerical rank of radial basis function kernels in high dimension

Low-rank approximations are popular methods to reduce the high computati...
06/23/2017 ∙ by Ruoxi Wang, et al. ∙ 0

• ### Structured Block Basis Factorization for Scalable Kernel Matrix Evaluation

Kernel matrices are popular in machine learning and scientific computing...
05/03/2015 ∙ by Ruoxi Wang, et al. ∙ 0

• ### Improved guarantees and a multiple-descent curve for the Column Subset Selection Problem and the Nyström method

The Column Subset Selection Problem (CSSP) and the Nyström method are am...
02/21/2020 ∙ by Michał Dereziński, et al. ∙ 0

• ### Hierarchically Compositional Kernels for Scalable Nonparametric Learning

We propose a novel class of kernels to alleviate the high computational ...
08/02/2016 ∙ by Jie Chen, et al. ∙ 0

• ### Precise expressions for random projections: Low-rank approximation and randomized Newton

It is often desirable to reduce the dimensionality of a large dataset by...
06/18/2020 ∙ by Michał Dereziński, et al. ∙ 0

• ### A Note on Error Bounds for Pseudo Skeleton Approximations of Matrices

Due to their importance in both data analysis and numerical algorithms, ...
07/05/2021 ∙ by Frank de Hoog, et al. ∙ 0

• ### Improved Fixed-Rank Nyström Approximation via QR Decomposition: Practical and Theoretical Aspects

The Nyström method is a popular technique for computing fixed-rank appro...
08/08/2017 ∙ by Farhad Pourkamali-Anaraki, et al. ∙ 0

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

Kernel matrices [38, 7, 6]

are widely used across fields including machine learning, inverse problems, graph theory and PDEs

[39, 29, 20, 22, 21, 34]. The ability to generate data at the scale of millions and even billions has increased rapidly, posing computational challenges to systems involving large-scale matrices. The lack of scalability has made algorithms that accelerate matrix computations particularly important.

There have been algebraic algorithms proposed to reduce the computational burden, mostly based on low-rank approximations of the matrix or certain submatrices [39]

. The singular value decomposition (SVD)

[18] is optimal but has an undesirable cubic complexity. Many methods [25, 19, 23, 30, 9, 17, 8, 43] have been proposed to accelerate the low-rank constructions with an acceptable loss of accuracy. The success of these low-rank algorithms hinges on a large spectrum gap or a fast decay of the spectrum of the matrix itself or its submatrices. However, to our knowledge, there is no theoretical guarantee that these conditions always hold.

Nonetheless, algebraic low-rank techniques are effective in many cases where the data dimension ranges from moderate to high, motivating us to study the growth rate of matrix ranks in high dimensions. A precise analysis of the matrix rank is nontrivial, and we turn to analyzing its upper bound, that is, the function rank of kernels that will be defined in what follows. The function rank is the number of terms in the minimal separable form of , when is approximated by a finite sum of separate products where and are real-valued functions. If the function rank does not grow exponentially with the data dimension, neither will the matrix rank.

If, however, we expand the multivariable function by expanding each variable in turn using function basis (per dimension), i.e.,

 r∑i1,…,id,j1,…,jd=1g(i1)1(x1)g(i2)2(x2)…g(id)d(xd)h(j1)1(y1)h(j2)2(y2)…h(jd)d(yd)

where and , respectively, are the -th function bases in dimension for and . Then, the number of terms will be , which grows exponentially with the data dimension. The exponential growth is striking in the sense that even for a moderate dimension, a reasonable accuracy would be difficult to achieve. However, in practice, people have observed much lower matrix ranks. A plausible reason is that both the functions and the data of practical interest enjoy some special properties, which should be considered when carrying out the analysis.

The aim of this paper, therefore, is to analytically describe the relationship between the function rank and the properties of the function and the data, including measures of function smoothness, the data dimension, and the domain diameter. Such relation has not been described before. We hope the conclusions of this paper on functions can provide some theoretical foundations for the practical success of low-rank matrix algorithms.

In this paper, we present three main results. First, we show that under common smoothness assumptions and up to some precision, the function rank of RBF kernels grows polynomially with increasing dimension in the worst case. Second, we provide explicit error bounds for the low-rank approximations of RBF kernel functions. And last, we explain the observed “decay-plateau” behavior of the singular values of smooth RBF kernel matrices.

### 1.1 Related Work

There has been extensive interest in kernel properties in a high-dimensional setting.

One line of research focuses on the spectrum of kernel matrices. There is a rich literature on the smallest eigenvalues, mainly concerning matrix conditioning. Several papers

[1, 27, 31, 32] provided lower bounds for the smallest (in magnitude) eigenvalues. Some work further studied the eigenvalue distributions. Karoui [11] obtained the spectral distribution in the limit by applying a second-order Taylor expansion to the kernel function. In particular, Karoui considered kernel matrices with the -th entry and , and showed that as data dimension , the spectral property is the same as that of the covariance matrix . Wathen [40] described the eigenvalue distribution of RBF kernel matrices more explicitly. Specifically, the authors provided formulas to calculate the number of eigenvalues that decay like as , for a given . This group pattern in eigenvalues was observed earlier in [14] but with no explanation. The same pattern also occurs in the coefficients of the orthogonal expansion in the RBF-QR method proposed in [12]. There have also been studies focusing on the “flat-limit” situation where [10, 33, 13].

Another line of research is on developing efficient methods for function expansion and interpolation. The goal is to diminish the exponential dependence on the data dimension introduced by a tensor-product based approach. Barthelmann

et al[2] considered polynomial interpolation on a sparse grid [15]. Sparse grids are based on a high-dimensional multiscale basis and involve only degrees of freedom, where is the number of grid points in one coordinate direction at the boundary. This is in contrast with the degrees of freedom from tensor-product grids. Barthelmann showed that when , the number of selected points grows as , where is related to the function smoothness.

Trefethen [37] commented that to ensure a uniform resolution in all directions, the Euclidean degree of a polynomial (defined as for a multi-index ) may be the most useful. He investigated the complexity of polynomials with degrees defined by 1-, 2- and norms and concluded that by using the 2-norm we achieve similar accuracy as with the -norm, but with fewer points.

### 1.2 Main Results

In this paper, we study radial basis functions (RBF). RBFs are functions whose value depends only on the distance to the origin. In our manuscript, for convenience, we will consider the form . The square inside the argument of is to ensure that if is smooth then the RBF function is smooth as well. If we instead use and pick for example, the kernel is not differentiable when .

We define the numerical function rank of a kernel related to error , to which we will frequently refer.

 Rϵ=min{r∣∃ {hi}ri=1,{gi}ri=1, s.t.\ ∀ x,y∈Rd, ∣∣K(x,y)−r∑i=1gi(x)hi(y)∣∣≤ϵ}

where and are real functions on , and the separable form will be referred to as a low-rank kernel, or a low-rank representation of rank at most . Note that the rank definition concerns the function rank instead of the matrix rank.

Our two main results are as follows. First, we show that under common smoothness assumptions of RBFs and for a fixed precision, the function rank for RBF kernels is a polynomial function of the data dimension . Specifically, the function rank where is related to the low-rank approximation error. Furthermore, precise and detailed error bounds will be proved.

Second, we observe that the singular values of RBF kernel matrices form groups with plateaus. A pictorial example is in Figure 1. There are 5 groups (plateau) of singular values with a sharp drop in magnitude between groups; the group cardinalities are dependent on the data dimension, but independent of the data size. We explain this phenomenon by applying an appropriate analytic expansion of the function and grouping expansion terms appropriately.

### 1.3 Organization

This paper is organized as follows. Section 2 presents our theorems concerning the function rank of the approximation of the RBF kernel function, and the error bound of the approximations. Section 3 provides the theorem proofs. Section 4 shows that for a fixed precision, the polynomial growth rate of the derived rank cannot be improved. Section 5 verifies our theorems experimentally. Finally, in Section 6, we investigate and discuss the group pattern in the singular values of RBF kernel matrices.

## 2 Main theorems

In this section, we present theorems concerning the function rank and function and data properties. Each theorem approximates the RBF kernels in the norm with low-rank kernels where the function rank and the error bound are given in explicit formulas. We briefly describe the theorems and then delve into further details.

The first four theorems consider kernels with two types of smoothness assumptions, and for each type, we present the deterministic result and the probabilistic result in two theorems, respectively. The probabilistic results take into account the concentration of measure for large data dimensions. The separable form is obtained by applying a Chebyshev expansion of followed by a further expansion of .

The key advantage of this approach is that the accuracy of the expansion only depends on instead of , which lies in a -dimensional space. Assume we have expanded to order with error . Then, we substitute , expand the result, and re-arrange the terms to identify the number of distinct separate products of the form in the final representation. This number becomes our upper bound on the function rank.

The theorems show that for a fixed precision, the function rank grows polynomially with data dimension , and that the error for low-rank approximations decreases with decreasing diameter of the domain that contains and .

The last theorem considers kernels with finite smoothness assumptions. The separable form is obtained by applying a Fourier expansion of followed by a Taylor expansion on each Fourier term. Additional to what the previous theorems suggest, the formulas for the error and the function rank capture subtler relations between different parameters, and the theorem shows that the error decreases when either the diameter of the domain that contains or that contains decreases. Before presenting our theorems, we introduce some notations.

Notations. Let and

denote the expectation and variance, respectively. Let

 Eρ2=:{z=ρ2eıθ+ρ−2e−ıθ2∣∣θ∈[0,2π)}

be the Bernstein ellipse defined on with parameter , an open region bounded by an ellipse. For an arbitrary interval, the ellipse is scaled and shifted and is referred to as the transformed Bernstein ellipse. For instance, given an interval , let be a linear mapping from to . And the transformed Bernstein ellipse for is defined to be . In this case, the parameter still characterizes the shape of the transformed Bernstein ellipse. Therefore, throughout this paper, when we say a transformed Bernstein ellipse with parameter , we refer to the parameter of the Bernstein ellipse defined on [-1, 1]. Let the function domain be , and we refer to as the target domain and as the source domain. We assume the domain is not a manifold, where lower ranks can be expected. Let the sub-domain containing the data of interest be .

The following theorems assume the bandwidth parameter in to be fixed at 1. A scaled kernel will not be considered because it can be handled by rescaling the data points instead. We start with some assumptions on the kernel type, function domain, and probabilistic distribution that will be used in the theorems, and then we present our theorems.

###### RBF Kernel Assumption.

Consider a function and kernel function with and . We assume that , , where is a constant independent of . And this implies .

###### Analytic Assumption.

is analytic in , and is analytically continuable to a transformed Bernstein ellipse with parameter , and inside the ellipse.

###### Finite Smoothness Assumption.

and its derivatives through are absolutely continuous on and the -th derivative has bounded total variation on ,

###### Probability Distribution Assumption.

and

are i.i.d. random variables, with

and

, and their second moments exist. Let

and

 σ2d=d∑i=1Var[(xi−yi)2]

Then, with respect to , i.e., the mean distance between pairs of points neither goes to 0 nor with . And (a concentration of measure).

###### Theorem 2.1.

Suppose the creftypecap RBF Kernel Assumption and the creftypecap Analytic Assumption hold. Then, for , the kernel can be approximated in the norm by a low-rank kernel of function rank at most

 K(x,y)=R∑i=1gi(x)hi(y)+ϵn=˜K(x,y)+ϵn (1)

where and are two sequences of -variable polynomials. And the error term is bounded as

 |ϵn(D)|≤2CDρ−2nDρ2D−1 (2)

Remark. If an approximation with a given maximal rank is requested, we need to select an such that . Then, we obtain an approximation with error and function rank at most . The low-rank kernel is of order , which can be revealed from the explicit form of in the proof (see Section 3.2). For the space of -variate polynomials with maximum total degree , the dimension is . In contrast, our upper bound is . When , our formula becomes favorable for a large range of .

###### Corollary 2.2.

Under the same assumptions in Theorem 2.1 and with fixed, the low-rank kernel approximation, for a fixed precision , is achievable with a rank proportional to , where and are positive constants.

The proofs of Theorem 2.1 and Corollary 2.2 can be found in Section 3.1 and Section 3.2, respectively.

Theorem 2.1 suggests that for some precision , the function rank grows polynomially with increasing data dimension , i.e., , where is determined by the desired precision , and . This can be seen from with fixed and .

For a fixed and for a sub-domain with diameter , the error bound decreases, namely in the following sense. In this case, the same function on the sub-domain can be analytically extended to a Bernstein ellipse whose parameter is larger than , reducing the error bound in Eq. 2. Therefore, when the diameter of the domain that contains our data decreases, we will observe a lower approximation error for low-rank approximations with a fixed function rank, and similarly, we will observe a lower function rank for low-rank approximations with a fixed accuracy.

Along the same line of reasoning, for a fixed kernel on a fixed domain, when the point sets become denser, we should expect the function rank to remain unchanged for a fixed precision. The result for function ranks turns out to be in perfect agreement with the observations in practical situations on matrix ranks, assuming there are sufficiently many points to make the matrix rank visible before reaching a given precision.

We now turn to the case when is large. Because we have assumed and to be in , by concentration of measure, the values of will fall into a small-sized subinterval of

with high probability. Therefore, we are interested in quantifying this probabilistic error bound.

###### Theorem 2.3.

Suppose the creftypecap RBF Kernel Assumption and the creftypecap Analytic Assumption hold, and points and

are sampled under the probability distribution involving

, and in creftypecap Probability Distribution Assumption. We define function . Then, is analytic in , with the parameter of its transformed Bernstein ellipse to be , and inside the ellipse. Defining the same error as in Theorem 2.1

 ϵn(D,δ)=K(x,y)−R∑i=1gi(x)hi(y),with R=(n+d+2d+2) (3)

we obtain that for , with probability at least

 1−2exp(−δ4d2σ2dd+8D2δ2/3) (4)

the error can be bounded by

 |ϵn(D,δ)|≤2CDδ2D2(~ρ2D−~ρ−2D)−δ2(D2(~ρ2D−~ρ−2D)δ2)−n

And with the same probability, the distance of a sampled pair will fall into the following interval

 ∥x−y∥22∈[E2d−δ2,E2d+δ2]

The proof of Theorem 2.3 can be found in Section 3.3.

In Theorem 2.3, as , needs to decrease with to maintain the same probability. If we choose with being a very large number, then the probability remains close to 1 because . Moreover, we can keep small while reducing , because . This means that for sufficiently large and for a given error, goes down as increases. Asymptotically, reaches 0, and the function rank reaches 1. On the other hand, for a fixed , the error bound decreases when increases.

Note that is the size of the subinterval where the values of ’s fall into with probability given by Eq. 4 and, by concentration of measure, with the same probability, the interval size shrinks with increasing . This is consistent with what we have discussed that needs to decrease with to maintain the same probability.

The analytic assumption in Theorem 2.1 and Theorem 2.3 is very strong because many RBFs are not infinitely differentiable when the domain contains zero. However, most RBFs of practical interest are -times differentiable. In the following theorem, we weaken the analytic assumption to a finite-smoothness assumption and compute the corresponding error bound.

###### Theorem 2.4.

Suppose the creftypecap RBF Kernel Assumption and the creftypecap Finite Smoothness Assumption hold. Then for , the kernel can be approximated in the norm by a low-rank kernel of function rank at most

 K(x,y)=R∑i=1gi(x)hi(y)+ϵn=˜K(x,y)+ϵn

where and are two sequences of -variable polynomials. And the error term is bounded as

 |ϵn(Vq,D,q)|≤2VqD2qπq[2(n−q)]q (5)

Remark. We can weaken the assumption of having bounded total variation to being Lipschitz continuous, and this does not impose assumptions on . With this weaker assumption, we obtain the same error rate ; however, the trade off is the absent of explicit constants in the upper bound Eq. 5.

The proof of Theorem 2.4 can be found in Section 3.4.

Compared to Theorem 2.1, the convergence rate slows down from a nice geometric convergence rate to an algebraic convergence rate . Each time the function becomes one derivative smoother ( increased by 1), the convergence rate will also become one order faster. The domain diameter affects the error bound by , where represents the smoothness of the function. For a sub-domain with diameter , it is straightforward to obtain that the error is bounded by , and for a fixed , a decrease in will reduce the error.

We also consider the phenomenon of concentration of measure and present the probabilistic result in the following theorem. and are i.i.d. random variables, with and , and have their second moments exist.

###### Theorem 2.5.

Suppose the creftypecap RBF Kernel Assumption and the creftypecap Finite Smoothness Assumption hold. We further assume and are sampled under the probability distribution involving , , and in creftypecap Probability Distribution Assumption. Defining the same as in Theorem 2.4

 ϵn(Vq,δ,q)=K(x,y)−R∑i=1gi(x)hi(y),with R=(n+d+2d+2)

Then, for , we obtain the following bound

 |ϵn(Vq,δ,q)|≤2Vqδ2qπq[2(n−q)]q

with probability at least

 1−2exp(−δ4d2σ2dd+8D2δ2/3)

The proof of Theorem 2.5 can be found in Section 3.4.

Up to now, we have only considered a single parameter that characterizes the domain, to make the error bound more informative as in response to subtler changes of the domain, we also consider the diameters of the target domain and of the source domain . The following theorem nicely quantifies the influences of and on the error. Our result theoretically offers critical insights and motivations for many algorithms that take advantage of the low-rank property of sub-matrices, where these sub-matrices usually relate to data clusters of small diameters.

###### Theorem 2.6.

Suppose the creftypecap RBF Kernel Assumption hold, and there are and , such that and .

Let be a -periodic extension of , where 111see details in [5] is 1 on and smoothly decays to 0 outside of the interval. We assume that and its derivatives through are continuous, and the -th derivative is piecewise continuous with the total variation over one period bounded by .

Then, for with , the kernel can be approximated by a low-rank kernel of rank at most

 K(x,y)=R∑i=1gi(x)hi(y)+ϵMf,Mt=˜K(x,y)+ϵMf,Mt

And the error is bounded by

 |ϵMf,Mt(Dx,Dy,q,ρ)|≤∥f∥∞(DxDyD2)Mt+1+Vqπq(2D2πMf)q

The proof of Theorem 2.6 can be found in Section 3.5.

In contrast to the previous theorems where the domain information only enters the error as , in Theorem 2.6, the diameters of the source domain and the target domain also appear in error. The form suggests that a decrease in will reduce the error, which can be achieved when either the source or the target domain has a smaller diameter. This property has motivated people to approach matrix approximation problems by identifying low-rank blocks in a matrix, which is partially achieved by partitioning the data into clusters of small diameters.

The function rank still remains a polynomial growth and it grows as , when and are fixed and . represents the Fourier expansion order of , and each term in the expansion is further expanded into Taylor terms up to order . We assumed to be the same across all the Fourier terms for simplicity. If we decrease the Taylor order with increasing Fourier order to preserve more information of low-order Fourier terms, then a lower error bound can be attained for the same function rank.

Remark. We summarize the assumptions, error bounds and function ranks of the theorems in Table 1, and discuss the similarities and differences in the function rank and the error bound. We refer to Theorem 2.1 and Theorem 2.4 as the Chebyshev approach and Theorem 2.6 as the Fourier-Taylor approach based on their proof techniques. The function rank is determined by the data dimension and the expansion order, and it is a power of the dimension, where the power is the expansion order and is different in the Chebyshev approach and the Fourier-Taylor approach. The error bounds quantify the influences from the expansion order and the domain diameter: a higher expansion order reduces the error bound, so does a smaller domain diameter. The domain diameter occurs as a single parameter in the Chebyshev approach but as , and in the Fourier-Taylor approach.

From the practical viewpoint, the absence of exponential growth for the function rank agrees with the practical situation where people observe lower matrix ranks for high dimension data. And, the fact that decreasing or reduces the error is also in agreement with practice and moreover, it provides an insight of why point clusterings followed by local interpolations often leads to a more memory efficient approximation.

## 3 Theorem Proofs

In this section, we prove the theorems in Section 2. All the proofs consist of three components: separating into a finite sum of products of real-valued functions , counting the terms to obtain an upper bound for the function rank, and calculating the error bound. Similar techniques can be found in [26, 33, 40, 44]. We describe the high-level procedure of the separation step; the rest steps should be straightforward.

In the proofs of Theorem 2.1 and Theorem 2.4, the separable form was obtained by first expanding the kernel into polynomials of of a certain order to settle the error bound, and then expanding the terms . The key advantage of this approach has been discussed at the beginning of Section 2. We seek approximation theorems in 1D that provide optimal convergence rate and explicit error bounds. Chebyshev theorems (Theorem 8.2 and Theorem 7.2 in [36]) are ideal choices. Analogous results also exist, e.g., the classic Bernstein and Jackson’s approximation theorems (page 257 in [3]), but the downside is that they only provide an error rate rather than an explicit formula, and moreover, they will not improve our results or simplify the proofs.

In the proof of Theorem 2.6, the separable form was obtained by first applying a Fourier expansion on to separate the cross term , then applying a Taylor expansion on the cross term.

Before stating the detailed proofs, we introduce some notations that will be used.
Notations. For multi-index

and vector

, we define , and the multinomial coefficient with to be

### 3.1 Proof of Theorem 2.1

We first introduce a lemma on the identity of binomial coefficients.

###### Lemma 3.1.

For and , the following identity holds:

 m∑k=0(k+dd)=(m+1+dd+1)
###### Proof.

The proof can be done by induction and follows that from Lemma 2.4 in [41]. ∎

###### Proof.

The proof consists of two components. First, we map the domain of to (for the convenience of the proof) and approximate with a Chebyshev polynomial, and this settles the error. Second, we further separate terms in the polynomial and count the number of distinct terms to be an upper bound of the function rank.

• [leftmargin=*]

• Approximation by Chebyshev polynomials. We first linearly map the domain of to and denote the new function as :

 (6)

Because , it follows that . From our assumptions, is analytic in and is analytically continuable to the open Bernstein ellipse with parameter (consider a shifted ellipse).

According to Theorem 8.2 in [36] that follows from [24], for , we can approximate by its Chebyshev truncations in the norm with error

 |ϵn|≤2CDρ−2nDρ2D−1 (7)

and

 ~fn(z)=n∑k=0ckTk(z)+ϵn (8)

where , and is the Chebyshev polynomial of the first kind of degree defined by the relation:

 Tk(x)=cos(kθ), with x=cos(θ). (9)

Rearranging the terms in Eq. 8 we obtain a polynomial of :

 K(x,y)=~f(2D2∥x−y∥22)=n∑k=0akD2k∥x−y∥2k+ϵn (10)

where depends on but is independent of and .

• Separable form. We separate each term in Eq. 10 into a finite sum of separate products:

 ∥x−y∥2l=l∑k=0(lk)(−2)l−kk∑j=0(kj)∥x∥2j∥y∥2(k−j)(d∑i=1xiyi)l−k=l∑k=0k∑j=0∑|α|=l−kCl,k,α(∥x∥2jxα)(∥y∥2(k−j)yα) (11)

where . Substituting Eq. 11 into Eq. 10, we obtain a separable form of :

 K(x,y)=n∑l=0l∑k=0k∑j=0∑|α|=l−kDl,k,α(∥x∥2jxα)(∥y∥2(k−j)yα)+ϵn (12)

where is a constant independent of and . Therefore, the function rank of can be upper bounded by the total number of separate terms:

 n∑l=0l∑k=0(k+1)(l−k+d−1d−1)=(n+d+2d+2)

where the equality follows from the result in Lemma 3.1. To summarize, we have proved that can be approximated by the separable form in Eq. 12 in the norm with rank at most

 R(n,d)=(n+d+2d+2) (13)

and approximation error

 |ϵn(D)|≤2CDρ−2nDρ2D−1 (14)

### 3.2 Proof of Corollary 2.2

###### Proof.

For a fixed kernel function and fixed , we define two constants and . Then, the truncation error can be rewritten as

 ϵ=2CDρ−2nDρ2D−1=e−nc2c1

and equivalently,

 n=−logc1ϵc2 (15)

We relate function rank to error and dimension . When , we obtain,

 R=(n+d+2d+2)≤2ndnn!=cnd−logc1ϵc2 (16)

where is a constant for a fixed . Therefore, an error is achievable with the function rank proportional to . ∎

### 3.3 Proof of Theorem 2.3

###### Proof.

We consider the concentration of measure phenomenon and apply concentration inequalities to obtain a probabilistic error bound. The proof mostly follows the proof of Theorem 2.1, and we will focus on computing the error bound for a smaller domain.

To simplify the proof, we consider a function that is shifted by such that

and we will see later that this shift ensures the inputs for to fall into an interval that centers around 0 with some probability. inherits the analyticity of ; therefore, it is analytic on , and can be analytically extended to a transformed Bernstein Ellipse with parameter .

Let us denote and we will shortly apply concentration inequality to . With the assumptions that and are i.i.d. random variables where and , it follows that the are statistically independent with mean zero and are bounded by . By applying Bernstein’s inequality [4] on the sum of the , we conclude that for ,

 P(|∥x−y∥22−E2d|≤δ2)≥1−2exp(−δ4d2σ2dd+8D2δ2/3) (17)

where is a constant. In other words, with probability at least

 1−2exp(−δ4d2σ2dd+8D2δ2/3)

This also means that with the same probability in Eq. 17, the inputs for will fall into the interval .

Therefore, for a probability associated with , we can turn to considering on the domain . We assume that is analytically extended to a transformed Bernstein ellipse with parameter , with the value of inside the ellipse bounded by . Following the same argument in the proof for Theorem 2.1, we obtain that for and with probability in Eq. 17, the approximation error for and sampled from the above distribution is bounded by

 |ϵn|≤2Cδρ2δ−1ρ−2nδ (18)

This sharper bound can be achieved with the same function rank as in Eq. 13 and with the same low-rank representation as in Eq. 12 except for coefficients.

Next, we rewrite the upper bound in Eq. 18 with the parameters , , and . If we linearly map the domain of from to [-1,1], then the Bernstein ellipse with parameter will be scaled by . We seek the largest such that the Bernstein ellipse with parameter will be contained in the transformed Bernstein ellipse with parameter . In that case, the lengths of their semi-minor axises match and the largest satisfies

 ρ2δ−ρ−2δ=D2δ2(~ρ2D−~ρ−2D) (19)

and we obtain . In the special case where , , we recover the error bound . To simplify the bound, we use the relation that . Substituting this into Eq. 18, along with the fact that , we obtain

 |ϵ


text:
# Tag Info

The upper bound for the 80 call is C(90) + 10, or 30. At least assuming no arbitrage. Let's start by assuming the risk-free rate is 0 (this isn't a problem, but the math is clearer without it), so we don't have to discount the price. Then, the call price is given by $C(K) = E_t[(S_T - K)^+]$, which gives: \begin{array} \$C(K - 10) &= E_t[max(S_T - (K - ...

format: plain


text:
# Fundamental theorem on homomorphisms

Fundamental theorem on homomorphisms In abstract algebra, the fundamental theorem on homomorphisms, also known as the fundamental homomorphism theorem, or the first isomorphism theorem, relates the structure of two objects between which a homomorphism is given, and of the kernel and image of the homomorphism.

The homomorphism theorem is used to prove the isomorphism theorems.

Contents 1 Group theoretic version 2 Other versions 3 See also 4 References Group theoretic version Diagram of the fundamental theorem on homomorphisms where f is a homomorphism, N is a normal subgroup of G and e is the identity element of G.

Given two groups G and H and a group homomorphism f : G → H, let N be a normal subgroup in G and φ the natural surjective homomorphism G → G/N (where G/N is the quotient group of G by N). If N is a subset of ker(f) then there exists a unique homomorphism h: G/N → H such that f = h∘φ.

In other words, the natural projection φ is universal among homomorphisms on G that map N to the identity element.

The situation is described by the following commutative diagram: h is injective if and only if N = ker(f). Therefore, by setting N = ker(f) we immediately get the first isomorphism theorem.

We can write the statement of the fundamental theorem on homomorphisms of groups as "every homomorphic image of a group is isomorphic to a quotient group".

Other versions Similar theorems are valid for monoids, vector spaces, modules, and rings.

See also Quotient category References Beachy, John A. (1999), "Theorem 1.2.7 (The fundamental homomorphism theorem)", Introductory Lectures on Rings and Modules, London Mathematical Society Student Texts, vol. 47, Cambridge University Press, p. 27, ISBN 9780521644075. Grove, Larry C. (2012), "Theorem 1.11 (The Fundamental Homomorphism Theorem)", Algebra, Dover Books on Mathematics, Courier Corporation, p. 11, ISBN 9780486142135. Jacobson, Nathan (2012), "Fundamental theorem on homomorphisms of Ω-algebras", Basic Algebra II, Dover Books on Mathematics (2nd ed.), Courier Corporation, p. 62, ISBN 9780486135212. Rose, John S. (1994), "3.24 Fundamental theorem on homomorphisms", A course on Group Theory [reprint of the 1978 original], Dover Publications, Inc., New York, pp. 44–45, ISBN 0-486-68194-7, MR 1298629. Categories: Theorems in abstract algebra

Si quieres conocer otros artículos parecidos a Fundamental theorem on homomorphisms puedes visitar la categoría Theorems in abstract algebra.

Subir

Utilizamos cookies propias y de terceros para mejorar la experiencia de usuario Más información


text:
## Introductory Algebra for College Students (7th Edition)

Published by Pearson

# Chapter 6 - Section 6.6 - Solving Quadratic Equations by Factoring - Exercise Set: 5

#### Answer

x=9 or -$\frac{4}{5}$

#### Work Step by Step

Set each variable factor as equal to zero and then isolate the variable to find the solutions. (x-9)(5x+4)=0 x-9=0 or 5x+4=0 x=9 or 5x=-4 x=9 or x=-$\frac{4}{5}$

After you claim an answer you’ll have 24 hours to send in a draft. An editor will review the submission and either publish your submission or provide feedback.


text:
the formulation of Nielsen-Schreier theorem: every subgroup of a free group is free

I just got a little confused reading the formulation on wiki. Let $F_X$ denote the free group on the set $X$ and let the symbol $\leq$ denote "is subgroup of".

From what I know, the theorem reads: $H\leq F_X$ $\Rightarrow$ $\exists Y$: $H\cong F_Y$.

Is my formulation of this theorem also correct: $H\leq F_X$ $\Rightarrow$ $\exists Y\subseteq X$: $H=F_Y$

-
No, certainly not. Consider $X = \{a,b\}$ and the subgroup $H \cong \mathbb{Z}$ generated by $ab$ in $F_X$. Another example is the commutator subgroup $[F_X,F_X]$, which can be shown to be free on a countably infinite set (as soon as $|X| \geq 2$), so anything can happen in terms of the size of the generating set. –  t.b. Apr 24 '11 at 16:53
my goodness, well this is a surprise. didn't expect that subgroups can have larger rank that the whole group. Thank you. –  Leon Apr 24 '11 at 22:11

Consider the lovely example that arises from studying the usual presentation of $S_3$, namely $<a,b: a^3=b^2=(ab)^2=1>$. The presentation leads to a free group on $a$ and $b$, and the subgroup of this free group `normally generated' by the three relations $a^3$, $b^2$ and $(ab)^2$ is of rank 7. For your interpretation $X= \{a,b\}$ whilst clearly your $Y$ is not a subset of that as it has 7 elements, Doh!
One of the clearest ways of looking at Neilsen-Schreier is via covering graphs. This can be found in several places. The example of $S_3$ can be found in Ronnie Brown's book: Topology and Groupoids, page 400.


text:
ExternalCodeComp¶

ExternalCodeComp is a component that runs an external program in a subprocess on your operating system.

If external programs do not have Python APIs, it is necessary to “file wrap” them. ExternalCodeComp is a utility component that makes file wrapping easier by taking care of the mundane tasks associated with executing the external application. These include:

• Making the system call using the Subprocess module

• Redirecting stdin, stdout, and stderr to the user’s specification

• Capturing error codes

• Defining environment variables

• Handling timeout and polling

• Running the code on a remote server if required

ExternalCodeComp Options¶

Option Default Acceptable Values Acceptable Types Description
allowed_return_codes [0] N/A N/A List of return codes that are considered successful.
command [] N/A ['list', 'str'] Command to be executed. If command is a list, shell=True, otherwise shell=False
distributed False [True, False] ['bool'] If True, set all variables in this component as distributed across multiple processes
env_vars {} N/A N/A Environment variables required by the command.
external_input_files [] N/A N/A List of input files that must exist before execution, otherwise an Exception is raised.
external_output_files[] N/A N/A List of output files that must exist after execution, otherwise an Exception is raised.
fail_hard True [True, False] ['bool'] If True, external code errors raise a 'hard' exception (RuntimeError), otherwise errors raise a 'soft' exception (AnalysisError).
poll_delay 0.0 N/A N/A Delay between polling for command completion. A value of zero will use an internally computed default.
run_root_only False [True, False] ['bool'] If True, call compute, compute_partials, linearize, apply_linear, apply_nonlinear, and compute_jacvec_product only on rank 0 and broadcast the results to the other ranks.
timeout 0.0 N/A N/A Maximum time to wait for command completion. A value of zero implies an infinite wait.

ExternalCodeComp Constructor¶

The call signature for the ExternalCodeComp constructor is:

ExternalCodeComp.__init__(**kwargs)[source]

Intialize the ExternalCodeComp component.

ExternalCodeComp Example¶

In this example we will give an example based on a common scenario of a code that takes its inputs from an input file, performs some computations, and then writes the results to an output file. ExternalCodeComp supports multiple input and output files but for simplicity, this example only uses one of each. Also, for the purposes of this example we have kept the input and output files as simple as possible. In practice, the data will likely be organized in some defined way and thus some care must be taken to read and write the data as dictated by the file format. OpenMDAO provides a set of File Wrapping tools to help with this.

Note

To make it easy for you to run our example external code in any operating system or environment, we built it as a Python script that evaluates the paraboloid equation. We’ll just call this script like any other executable, even though it is a Python script, and could be turned directly an OpenMDAO Component. Just keep in mind that any external code will work here, not just python scripts!

Here is the script for this external code. It simply reads its inputs, x and y, from an external file, does the same computation as the Paraboloid Tutorial and writes the output, f_xy, to an output file.

#!/usr/bin/env python
#
# usage: extcode_paraboloid.py input_filename output_filename
#
# Evaluates the equation f(x,y) = (x-3)^2 + xy + (y+4)^2 - 3.
#
# Read the values of x and y from input file
# and write the value of f_xy to output file.

if __name__ == '__main__':
import sys

input_filename = sys.argv[1]
output_filename = sys.argv[2]

with open(input_filename, 'r') as input_file:

x, y = [float(f) for f in file_contents]

f_xy = (x-3.0)**2 + x*y + (y+4.0)**2 - 3.0

with open(output_filename, 'w') as output_file:
output_file.write('%.16f\n' % f_xy)

The following example demonstrates how to build an OpenMDAO component that makes use of this external code.

Note

If you pass a string as a command, OpenMDAO sets shell=True which can add overhead leading to a decrease in performance and a security loophole. Use list when possible.

import openmdao.api as om

class ParaboloidExternalCodeComp(om.ExternalCodeComp):
def setup(self):

self.input_file = 'paraboloid_input.dat'
self.output_file = 'paraboloid_output.dat'

# providing these is optional; the component will verify that any input
# files exist before execution and that the output files exist after.
self.options['external_input_files'] = [self.input_file]
self.options['external_output_files'] = [self.output_file]

# If you want to write your command as a list, the code below will also work.
# self.options['command'] = [
#     sys.executable, 'extcode_paraboloid.py', self.input_file, self.output_file
# ]

self.options['command'] = ('python extcode_paraboloid.py {} {}').format(self.input_file, self.output_file)

def compute(self, inputs, outputs):
x = inputs['x']
y = inputs['y']

# generate the input file for the paraboloid external code
with open(self.input_file, 'w') as input_file:
input_file.write('%.16f\n%.16f\n' % (x, y))

# the parent compute function actually runs the external code
super().compute(inputs, outputs)

# parse the output file from the external code and set the value of f_xy
with open(self.output_file, 'r') as output_file:

outputs['f_xy'] = f_xy

We will go through each section and explain how this code works.

OpenMDAO provides a base class, ExternalCodeComp, which you should inherit from to build your wrapper components. Just like any other component, you will define the necessary inputs and outputs in the setup method. If you want the component to check to make sure any files exist before/after you run, then you can set the external_input_files and external_output_files, respectively. You’ll also define the command that should be called by the external code.

def setup(self):

self.input_file = 'paraboloid_input.dat'
self.output_file = 'paraboloid_output.dat'

# providing these is optional; the component will verify that any input
# files exist before execution and that the output files exist after.
self.options['external_input_files'] = [self.input_file]
self.options['external_output_files'] = [self.output_file]

# If you want to write your command as a list, the code below will also work.
# self.options['command'] = [
#     sys.executable, 'extcode_paraboloid.py', self.input_file, self.output_file
# ]

self.options['command'] = ('python extcode_paraboloid.py {} {}').format(self.input_file, self.output_file)

The compute method is responsible for calculating outputs for a given set of inputs. When running an external code, this means you have to take the parameter values and push them down into files, run your code, then pull the output values back up. So there is some Python code needed to do all that file writing, reading, and parsing.

def compute(self, inputs, outputs):
x = inputs['x']
y = inputs['y']

# generate the input file for the paraboloid external code
with open(self.input_file, 'w') as input_file:
input_file.write('%.16f\n%.16f\n' % (x, y))

# the parent compute function actually runs the external code
super().compute(inputs, outputs)

# parse the output file from the external code and set the value of f_xy
with open(self.output_file, 'r') as output_file:

outputs['f_xy'] = f_xy

ParaboloidExternalCodeComp is now complete. All that is left is to actually use it in a model.

import sys

prob = om.Problem()
model = prob.model

# run the ExternalCodeComp Component
prob.setup()

# Set input values
prob.set_val('p.x', 3.0)
prob.set_val('p.y', -4.0)

prob.run_model()

# print the output
print(prob.get_val('p.f_xy'))

[-15.]

Using ExternalCodeComp in an Optimization¶

If you are going to use an ExternalCodeComp component in a gradient based optimization, you’ll need to get its partial derivatives somehow. One way would be just to use finite-difference approximations for the partials.

In the following example, the ParaboloidExternalCodeComp component has been modified to specify that partial derivatives are approximiated via finite difference.

class ParaboloidExternalCodeCompFD(om.ExternalCodeComp):
def setup(self):

self.input_file = 'paraboloid_input.dat'
self.output_file = 'paraboloid_output.dat'

# providing these is optional; the component will verify that any input
# files exist before execution and that the output files exist after.
self.options['external_input_files'] = [self.input_file]
self.options['external_output_files'] = [self.output_file]

self.options['command'] = [
sys.executable, 'extcode_paraboloid.py', self.input_file, self.output_file
]

def setup_partials(self):
# this external code does not provide derivatives, use finite difference
self.declare_partials(of='*', wrt='*', method='fd')

def compute(self, inputs, outputs):
x = inputs['x']
y = inputs['y']

# generate the input file for the paraboloid external code
with open(self.input_file, 'w') as input_file:
input_file.write('%.16f\n%.16f\n' % (x, y))

# the parent compute function actually runs the external code
super().compute(inputs, outputs)

# parse the output file from the external code and set the value of f_xy
with open(self.output_file, 'r') as output_file:

outputs['f_xy'] = f_xy

Now we can perform an optimization using the external code, as shown here:

prob = om.Problem()
model = prob.model

# find optimal solution with SciPy optimize
# solution (minimum): x = 6.6667; y = -7.3333
prob.driver = om.ScipyOptimizeDriver()
prob.driver.options['optimizer'] = 'SLSQP'

prob.driver.options['tol'] = 1e-9
prob.driver.options['disp'] = True

prob.setup()

# Set input values
prob.set_val('p.x', 3.0)
prob.set_val('p.y', -4.0)

prob.run_driver()

Optimization terminated successfully    (Exit mode 0)
Current function value: [-27.33333333]
Iterations: 5
Function evaluations: 6
Optimization Complete
-----------------------------------

False

print(prob.get_val('p.x'))
print(prob.get_val('p.y'))

[6.66666633]
[-7.33333367]

Alternatively, if the code you are wrapping happens to provide analytic derivatives you could have those written out to a file and then parse that file in the compute_partials method.

Here is a version of our external script that writes its derivatives to a second output file:

#!/usr/bin/env python
#
# usage: extcode_paraboloid_derivs.py input_filename output_filename derivs_filename
#
# Evaluates the equation f(x,y) = (x-3)^2 + xy + (y+4)^2 - 3.
#
# Read the values of x and y from input file
# and write the value of f_xy to output file.
#
# Also write derivatives to another output file.

if __name__ == '__main__':
import sys

input_filename = sys.argv[1]
output_filename = sys.argv[2]
derivs_filename = sys.argv[3]

with open(input_filename, 'r') as input_file:

x, y = [float(f) for f in file_contents]

f_xy = (x-3.0)**2 + x*y + (y+4.0)**2 - 3.0

with open(output_filename, 'w') as output_file:
output_file.write('%.16f\n' % f_xy)

with open(derivs_filename, 'w') as derivs_file:
# partials['f_xy', 'x']
derivs_file.write('%.16f\n' % (2.0*x - 6.0 + y))
# partials['f_xy', 'y']
derivs_file.write('%.16f\n' % (2.0*y + 8.0 + x))

And the corresponding ParaboloidExternalCodeCompDerivs component:

class ParaboloidExternalCodeCompDerivs(om.ExternalCodeComp):
def setup(self):

self.input_file = 'paraboloid_input.dat'
self.output_file = 'paraboloid_output.dat'
self.derivs_file = 'paraboloid_derivs.dat'

# providing these is optional; the component will verify that any input
# files exist before execution and that the output files exist after.
self.options['external_input_files'] = [self.input_file]
self.options['external_output_files'] = [self.output_file, self.derivs_file]

self.options['command'] = [
sys.executable, 'extcode_paraboloid_derivs.py',
self.input_file, self.output_file, self.derivs_file
]

def setup_partials(self):
# this external code does provide derivatives
self.declare_partials(of='*', wrt='*')

def compute(self, inputs, outputs):
x = inputs['x']
y = inputs['y']

# generate the input file for the paraboloid external code
with open(self.input_file, 'w') as input_file:
input_file.write('%.16f\n%.16f\n' % (x, y))

# the parent compute function actually runs the external code
super().compute(inputs, outputs)

# parse the output file from the external code and set the value of f_xy
with open(self.output_file, 'r') as output_file:

outputs['f_xy'] = f_xy

def compute_partials(self, inputs, partials):
outputs = {}

# the parent compute function actually runs the external code
super().compute(inputs, outputs)

# parse the derivs file from the external code and set partials
with open(self.derivs_file, 'r') as derivs_file:

Again, we can perform an optimization using the external code with derivatives:

prob = om.Problem()
model = prob.model

# find optimal solution with SciPy optimize
# solution (minimum): x = 6.6667; y = -7.3333
prob.driver = om.ScipyOptimizeDriver()
prob.driver.options['optimizer'] = 'SLSQP'

prob.driver.options['tol'] = 1e-9
prob.driver.options['disp'] = True

prob.setup()

# Set input values
prob.set_val('p.x', 3.0)
prob.set_val('p.y', -4.0)

prob.run_driver();

Optimization terminated successfully    (Exit mode 0)
Current function value: [-27.33333333]
Iterations: 5
Function evaluations: 6

print(prob.get_val('p.x'))

[6.66666667]


text:
# Alm & Hamre¶

## Introduction¶

The ALM method is based upon that published by Alm & Hamre (2001) and uses CPT data. It allows for two sub methods to analyse the soil resistance to driving for SAND and CLAY.

## General¶

The total static resistance is calculated similarly to pile bearing capacity principles. OPILE applies factors on the calculated skin friction to account for the contributions from internal and external shaft friction. The default factor for sand is 1.0 (i.e. the predicted shaft friction accounts for both internal and external shaft friction without futher modification), whereas the default factor for clays is 1.8. In clays OPILE will therefore increase the shaft friction returned by the method by a factor of 1.8. to account for the effect of internal shaft friction (i.e. for clays the Alm & Hamre paper is interpreted) This factor could be increased to the ratio ID/OD (or 2) if one wants to account for full internal and external shaft contributions. Tha factor can be reduced to 1 in order to use the predicted shaft friction as is. Unit tip resistance is only applied to the annular area of the pile (i.e. piles are assumed to drive unplugged).

By default, the upper bound resistance is calculated as 1.25 times the best estimate as suggested by Alm & Hamre (2002). OPILE allows the user to specify any other factor on the SRD input screen.

Shaft capacity and end bearing resistance components are evaluated separately, and then combined as follows:

 Lower Bound $$SRD_{LB} = 1.0 \cdot Q_s + Q_a$$ $$SRD_{LB} = 1.8 \cdot Q_s + Q_a$$ For Sand For Clay 1.0 is the standard ALM Factor on Sand Friction 1.0 is the standard ALM Factor on Clay Friction Upper Bound $$SRD_{UB} = 1.25 \cdot SRD_{LB}$$ 1.25 is the standard ALM Upper Bound Factor

Where:

 $$Q_s$$ is the predicted shaft capacity $$Q_a$$ is the total end bearing resistance

The standard ALM Factors can be overwritten by the user in the SRD Soil Input - Other SRD Parameters (when selecting ALM as Main SRD Method):

Overriding the default Alm & Hamre parameters

The general formulation of side friction along a pile during driving is:

$f_s = f_{s,res} + (f_{s,i} - f_{s,res}) \cdot e^{k \cdot (d-p)}$

Where:

 $$f_s$$ is the pile side friction (kPa) $$f_{s,i}$$ is the initial pile side friction (kPa) $$f_{s,res}$$ is the residual pile side friction (kPa) $$d$$ is the depth to the actual layer (m) $$p$$ is the pile tip penetration (m) $$k$$ is the shape factor for degradation (-)

The shape factor for degradation is the same for sands and clays, using the following:

$k = \frac{\Big ( \frac{q_T}{p'_0} \Big) ^{0.5}}{80}$

Where:

 $$q_T$$ is the cone tip resistance (kPa) $$p'_0$$ is the effective overburden pressure (kPa)

## SAND¶

For SANDS the initial friction, $$f_{s,i}$$, is taken as the basic static friction formulation, while the residual friction, $$f_{s,res}$$, is taken as 20% of the initial friction:

$f_{s,i} = K \cdot p'_0 \cdot \tan(\delta)$

No upper limit on friction is included, however the lateral stress coefficient $$k$$ is linked to the cone resistance by:

$k = \frac{0.0132 \cdot q_T \cdot \Big( \frac{p'_0}{p_a} \Big)^{0.13}}{p'_0}$

Where:

 $$\delta$$ is the constant volume friction angle (degrees) $$p_a$$ is the reference pressure (100kPa) $$q_T$$ is the total cone tip resistance from the CPT

In SANDS the unit tip resistance is given by:

$q_{Tip} = 0.15 \cdot q_T \cdot \left( \frac{q_T}{p'_0} \right)^{0.2}$

## CLAY¶

For CLAYS the initial friction is taken as the recorded CPT sleeve friction, while the residual friction is a function of the normalized cone tip resistance using the following:

$f_{s,res} = 0.004 \cdot q_T \cdot \left( 1 - 0.0025 \cdot \frac{q_T}{p'_0} \right)$

In CLAYS unit tip resistance is taken as 60% of the total cone resistance.

$q_{Tip} = 0.6 \cdot q_T$


text:
# Shankar Exercise 1.1.3 (Vector Spaces)

Tags:
1. Apr 13, 2017

### Stephen Wright

<Mentor's note: moved from a technical forum, therefore no template.>

I'm long out of college and trying to teach myself QM out of Shankar's.
I'm trying to understand the reasoning here because I think that I am missing something...

1.1.3
1) Do functions that vanish at the endpoints x=0 and L=0 form a vector space?
2) How about periodic functions? obeying f(0)=f(L) ?
3) How about functions that obey f(0)=4 ?

If the functions do not qualify, list what go wrong.

The first 2 questions seem straight forward. X and L go to zero, and outside those boundaries you would get the null vector. If the function is periodic, you are certain to return a vector in the f(x).

#3 is tripping me up. I thought of an example function... lets say f(x)=x+4, so f(0)=4.
How is this not a vector space?

I was told that if g(x) and h(x) were in the set of f(x), g(0)+h(0)=8 which is not 4.

I do understand how this proves anything? What am I misunderstanding?

2. Apr 13, 2017

### Stephen Wright

1. The problem statement, all variables and given/known data
I'm long out of college and trying to teach myself QM out of Shankar's.
I'm trying to understand the reasoning here because I think that I am missing something...

1.1.3
1) Do functions that vanish at the endpoints x=0 and L=0 form a vector space?
2) How about periodic functions? obeying f(0)=f(L) ?
3) How about functions that obey f(0)=4 ?

If the functions do not qualify, list what go wrong.

The first 2 questions seem straight forward. X and L go to zero, and outside those boundaries you would get the null vector. If the function is periodic, you are certain to return a vector in the f(x).

#3 is tripping me up. I thought of an example function... lets say f(x)=x+4, so f(0)=4.
How is this not a vector space?

I was told that if g(x) and h(x) were in the set of f(x), g(0)+h(0)=8 which is not 4.

I do understand how this proves anything? What am I misunderstanding?

2. Relevant equations
The first 2 questions seem straight forward. X and L go to zero, and outside those boundaries you would get the null vector. If the function is periodic, you are certain to return a vector in the f(x).
3. The attempt at a solution

#3 is tripping me up. I thought of an example function... lets say f(x)=x+4, so f(0)=4.
How is this not a vector space?

I was told that if g(x) and h(x) were in the set of f(x), g(0)+h(0)=8 which is not 4.

I do understand how this proves anything? What am I misunderstanding? It said f(0)= 4, not f(x)=4. In my head 8 would be an acceptable answer.

3. Apr 13, 2017

### PeroK

Your working shows that you perhaps lack a good enough grasp of linear algebra and formal mathematics. You seem to be confused between an individual function (such as $f(x)$) and a vector space, which is an infinite set of functions. Normally, you would denote a vector space by $V$ and have something like $V$ is the set of functions that vanish on the endpoints.

Last edited: Apr 13, 2017
4. Apr 13, 2017

### MathematicalPhysicist

Well for 3) it's not closed under addition, take two functions with f(0)=g(0)=4, does h(x)=f(x)+g(x) satisfy this condition?

5. Apr 15, 2017

### nuuskur

3 is a collection of functions all satisfying $f(0)=4$. These functions can't form a vector space over $\mathbb R$ (or $\mathbb C$ for that matter), because $2f(0)=8\neq 4$. There is no homogeneity.

6. Apr 15, 2017

### vela

Staff Emeritus
The way the question is worded might be confusing you. In each case, you have a set of functions, and the question is asking you if this set along with the usual definitions of adding functions and multiplying by a scalar satisfy the requirements of being a vector space. So first, you have to know all of the conditions required of a vector space. There's probably a list in the book, or if not, you can check Wikipedia.

What you wrote here doesn't make sense. For the first question, let $V = \{f\ |\ f(0)=0\text{ and }f(L)=0\}$, and let $f, g \in V$. The fact that $f$ is an element of $V$ means you know that $f(0)=0$ and $f(L)=0$. Likewise for $g$. One of the conditions of a vector space is that of closure under addition. In other words, the function $f+g$ should also be in $V$. So you can check to see if $(f+g)(0)=0$ and if $(f+g)(L)=0$. If this is the case, then the function $(f+g) \in V$. It turns out that's true because $(f+g)(0) = f(0)+g(0) = 0+0 = 0$ and $(f+g)(L) = f(L)+g(L) = 0+0 = 0$. So $V$ is closed under addition.

You have to verify all of the other requirements before concluding $V$ is a vector space.

Given the explanation above, do you now understand why set 3 isn't closed under addition?

7. Apr 15, 2017

### eys_physics

For each of the cases 1), 2) and 3) you will have a set of functions (probably infinite number, but it doesn't effect the problem). To show that they form a vector space $V$, you have to show that for all members of the set, the conditions in Definition 1 are satisfied.


text:
Warnings shows up in message window

I have no idea why, but suddenly all my evaluation with warnings (like Sum::div:Sum does not converge) has begun to show up in a message box. Since always they appeared between In[] and Out[]?

How do I make it act normally again?

You can control how Messages are sent under Edit->Preferences. Choose the Messages tab and select your prefered behavior.

• This seems not to work in Mma V11. Christoph Haenel Feb 10, 2019 at 9:36
• This does not appear to be the case in v12 either Oct 31, 2019 at 15:02


text:
DokuWiki supports lists using the following syntax:

  * item1
* item2
* subitem 2.1
* item 3

However, when you have a very long list item, you will found a nightmare! In the editing window, the items will wrap and you lost all the visual hierarchy. Although you can still make the list as you want to but it is simply not as intuitive as it should be.

I made a plug-in, by referencing the creole plug-in, to do the above things, which now supports the syntax as follows:

  * item1
and its continuation
* item 2
* subitem 2.1
and its continuation

Those “continuation” will be shown as one single line, but you can make it visually better when editing the source. All continuation needs at least three spaces from the begin of the line and the actually number of spaces are not important to the outcome. The number of continuation lines is unlimited given that all lines begins with at least three spaces.

## Code

To use, create a directory lib/plugins/mllist/ and put the following file as syntax.php to use.

<?php
/**
* Multiline List Plugin
*
*/

// must be run within Dokuwiki
if(!defined('DOKU_INC')) die();

if(!defined('DOKU_PLUGIN')) define('DOKU_PLUGIN',DOKU_INC.'lib/plugins/');
require_once(DOKU_PLUGIN.'syntax.php');

/**
* All DokuWiki plugins to extend the parser/rendering mechanism
* need to inherit from this class
*/
class syntax_plugin_mllist extends DokuWiki_Syntax_Plugin {

function getInfo(){
return array(
'date'   => '2007-06-06',
'name'   => 'Multiline list plugin',
'desc'   => 'Allows a list item to break into multiple lines with indentation on non-bullet lines',
);
}

function getType(){ return 'container'; }
function getPType(){ return 'block'; }
function getSort(){ return 9; }

function getAllowedTypes(){
return array('formatting', 'substition', 'disabled', 'protected');
}

function connectTo($mode){$this->Lexer->addEntryPattern('\n {2,}[\-\*]',$mode,'plugin_mllist');$this->Lexer->addEntryPattern('\n\t{1,}[\-\*]',$mode,'plugin_mllist');$this->Lexer->addPattern('\n {2,}[\-\*]','plugin_mllist');
$this->Lexer->addPattern('\n\t{1,}[\-\*]','plugin_mllist'); // Continuation lines need at least three spaces for indentation$this->Lexer->addPattern('\n {2,}(?=\s)','plugin_mllist');
$this->Lexer->addPattern('\n\t{1,}(?=\s)','plugin_mllist'); } function postConnect(){$this->Lexer->addExitPattern('\n','plugin_mllist');
}

function handle($match,$state, $pos, &$handler){
switch ($state){ case DOKU_LEXER_ENTER:$ReWriter = & new Doku_Handler_List($handler->CallWriter);$handler->CallWriter = & $ReWriter;$handler->_addCall('list_open', array($match),$pos);
break;
case DOKU_LEXER_EXIT:
$handler->_addCall('list_close', array(),$pos);
$handler->CallWriter->process();$ReWriter = & $handler->CallWriter;$handler->CallWriter = & $ReWriter->CallWriter; break; case DOKU_LEXER_MATCHED: if (preg_match("/^\s+$/",$match)) break; // Captures the continuation case$handler->_addCall('list_item', array($match),$pos);
break;
case DOKU_LEXER_UNMATCHED:
$handler->_addCall('cdata', array($match), $pos); break; } return true; } function render($mode, &$renderer,$data){
return true;
}
}

//Setup VIM: ex: et ts=4 enc=utf-8 :

## Change History

• 2007-06-10:
• Initial release.


text:
# Stepping up your Math Game – 35 Summer Projects for Post-Secondary Math Students

This summer invest in your math education.

Undergraduate students often ask me for advice for how to improve themselves as mathematicians. There are many answers to this question: you can focus on learning new mathematics, you can work on your programming skills, you can improve your career prospects by working on professional development, …

This post is the result of many conversations and coffees with undergrads; It is the advice that I would have given myself as a second-year undergrad at the University of Winnipeg. These 35 projects will also provide necessary skills for completing a Ph.D. in Mathematics and will increase your employability.

Some of these projects will take an afternoon (“Learn how to make a bibliography in LaTeX”) and some might take a month (“Make a Predator-Prey Visualizer”). There is no time limit and no test, so take your time and make it your own.

1. Math Skills
3. Math Projects
4. Teaching
5. Professional Development
6. Other Skills

#### [B] Beginners

Some projects are marked with a [B]. These are especially well-suited for beginners.

## Math Skills

The most common way that we think of improving as mathematicians is to “learn more math”. Sometimes it’s about learning more, and sometimes it’s about learning better. Here are some skills you can work on and some topics you should aim towards.

#### [B] Basic Set Theory

As soon as possible you should become familiar with the interactions of set unions and intersections with functions and inverse images. This is a prerequite to understanding analysis and topology.

• Learn all of the words in section 1 of “Things You Should Know”. Know how to prove things about them and draw pictures to represent them.
• Prove that the composition of two bijections is a bijection.
• Prove all of the facts in section 3 of “Things You Should Know”.
• Prove that a function from a finite set into itself is an injection if and only if it is a surjection. Show that this is not always true for infinite sets.
• Learn the definition of a topological space. Prove that the intersection of an arbitrary family of topologies on a set X is also a topology on X.

#### Take an Inquiry-Based Learning (IBL) Course

IBL is a style of learning and teaching that focuses on students asking questions, making hypotheses, making mistakes and writing proofs themselves. The courses contain definitions and theorems, but no proofs (you fill them in yourself!). The courses move step by step and break down large theorems into manageable chunks.

#### Review and Master

Becoming stronger in mathematics is not just about looking forward and learning new things, it’s also about mastering old material, and gaining new perspectives on it. These projects focus on “looking backwards” so that you’ll have an easier time looking forwards.

For these projects, pick a technique or topic from a course you’ve completed recently. For example “Cantor’s Diagonalization Method”, “Linear Algebra in Differential Equations”, “Picture Proofs” or “Completeness of the Real Numbers” would all be good choices. At the end of these exercises, you will be a master of the material.

• Review the material from your notes.
• Explain the theorems and definitions in your own words. Write a couple of sentences explaining the relevance of each definition and theorem. If there are multiple similar theorems or definitions with slight variations, explain the differences and what makes each version special.
• Find other notes that explain the same material.
• Think of the likely places that readers could get confused, and point out how to resolve these issues.
• Write your own version of the proofs of the theorems. Look for different proofs and explain the key differences in each.
• Include connections to other branches of math and science if you can. For example, Cantor’s Diagonalization Method is the main proof technique for the Halting Problem.
• Find or invent exercises and questions that go with the ideas. Some questions should test basic understanding of definitions and theorems, some should point out common misunderstandings readers could have, some should require the reader to apply an old technique in a new way.
• Write up these explanations in a LaTeX document. You now have a chapter of a textbook. Congratulations!
• Move on to another topic that you want to master.

Math is a technical language and reading it is a skill that must be developed. When you first start reading papers your progress will be very slow. Don’t get discouraged! Write down lots of questions, take time to think about things, be skeptical. Just because it got printed in a journal doesn’t make it true!

#### Read a Book

Go through a math book that isn’t a textbook. Ask questions and talk to people about it.

#### Read a Paper

A lot of a mathematician’s time is spent reading papers and perusing the literature. It requires skill to read papers and generally speaking they are not written in a way that makes it easy to understand what’s going on. Read these papers and keep track of things you don’t understand and questions that come up. Try to write down a proof for anything they claim is “obvious” or “clear” or “easy”. The following papers really only assume a working knowledge of linear algebra and calculus

## Math Projects

Learning math for its own sake is fine, but sometimes its nice to have specific goals in mind. These projects will help you learn a topic while trying to accomplish a well-defined, achievable goal.

These are only sketches of projects; remember that you can add as much to them as you want. Personalize them! Go further!

#### [B] Characterize all Cyclic Groups

This is a project for people who have a bit of mathematical maturity (first or second year undergrad), but have not learned about groups yet. By the end of this project you will know exactly what every cyclic group looks like. By the end of this you can stop saying “I just don’t understand group theory”.

• Learn the definition of a group. (Look at some examples if you want.)
• Learn the definition of an abelian (i.e. commutative) group. Learn the definition of a cyclic group. Prove that every cyclic group is abelian.
• Prove that every subgroup of a cyclic group is cyclic.
• Let G be a finite cyclic group, and let x be an element of G. State and prove a theorem that relates the order of x with the order of G.
• State and prove a theorem that characterizes the cyclic groups. (It should contain a list of different groups, such that every cyclic group shows up on that list.)

If you like this type of math, one possible follow-up project is to characterize all abelian groups. This is a bigger task, but is often the end goal of a first course in group theory.

#### Make a Predator-Prey Visualizer

Your goal is to create a simulation of a predator-prey system along the lines of this. You will need a little bit of coding skill and you will need to know at least first year calculus. I will sketch out some steps you could take, but I will be vague. You should take things into your own hands and do extra research if needed.

• Read the Wikipedia article on the Lotka-Volterra equation.
• Here is a nice set of lecture notes by David Hyde [PDF] that explain the relevant notions and has many good exercises.
• You will need to learn some numerical methods for solving differential equations.
• Add in carrying capacity to your system.

## Teaching

Teaching is hard. Teaching is a skill. Teaching is extremely rewarding.

Use some of your free time in the summer to develop your teaching muscles. Good preparation outside the classroom will have a noticeable impact inside the classroom, even if it’s only a result of your higher confidence.

#### Redesign a Course

Take the syllabus of a course you’ve taken in the past and reorganize the syllabus. Try these five different exercises.

• Remove every section that can be removed without compromising the main goal of the course. See how much is essential, and how much is extra.
• Change the order of the material if possible. Can you present things in a more logical order?
• Find an assignment you didn’t like and redesign it. Make sure that your assignment accomplishes something.
• Redesign the course as though it was going to be taught to high school students in their last year of school. How does the course change? How do the assignments and tutorials change?
• Design your own final exam. Make sure it covers all of the relevant material and fairly tests the students. Can it be written in 3 hours?

#### Preparing Lectures and Tutorials

Take your notes from a lecture or tutorial you’ve given in the past, and try these exercises.

• Figure out the goal of the lecture and write it down. Make sure that everything in the lecture is designed to reach that goal. Remove things that aren’t helping.
• Add signposts to your written notes. These help direct your class as to where you’ve gone and where you’re going.
• Take a guess as to the three parts of your lecture that are hardest to follow. What would your students want that would help them follow?
• Think of and write down five questions students would have during your lecture, and write answers to those questions.

#### Stock Lectures

You should have at least three lectures ready that you can give at any moment. Use this summer to develop them all.

• Prepare a one hour lecture for 30 general high school students.
• Prepare a 30 minute lecture for bored parents.
• Prepare a one hour lecture for undergrads to get them excited about math.

## Professional Development

The model of a mathematician as a crazy-haired recluse working in isolation is far from how modern mathematics is practiced. Now the emphasis is placed more on connecting with other researchers, both mathematicians and those from other disciplines.

These projects will help make it easier to connect with others, and make it easier for them to reach out to you. Start early in your career!

#### Become Familiar with the Important Math Websites

There are many tools available for connecting with other math researchers and facilitating your own research. For each of these sites you should be able to (1) use them for their intended purpose, (2) navigate them, and (3) give a one sentence summary of them.

#### Form a Web Presence

When you go to conferences, or contact a professor, or apply for a job, people will look you up online, and you want them to find the good stuff. Make sure to keep these things active and up to date!

• Create your own website. Include your CV, a picture of yourself and some info about your mathematical interests. Include any relevant experience you have, some conferences that you have attended, some textbooks you have studied, some of your other online profiles (like Project Euler).
• Create a LinkedIn profile.
• Make sure your privacy settings on Facebook are high enough so that a prospective employer can’t see you doing stupid things. (In general you should also just avoid posting you doing stupid things.)

#### Attend Conferences

Networking with other mathematicians is an essential step in your career. Get out there! Start by reading this article by Andrew Schultz about the importance of networking.

• CUMC at the University of Alberta June 17-21, 2015. This is the undergraduate conference in mathematics. You should only not go if you have an important reason not to.
• Ottawa Math Conference at the University of Ottawa June 19-20, 2015. Undergrads and Grad students welcome!

If you are a graduate student, you should also look in to conferences in your specific area.

#### Find a Mentor

You should have a person you trust, who is older than you, and that you can ask questions to about the path you’ve chosen. If you’re an undergrad, this can be a senior undergrad, or a grad student. If you’re a grad student, this can be a senior grad student, a post doc, or a young faculty.

• Take your mentor out for coffee about once a month or every other month. This can vary depending on your mentor, but once a month is a good place to start.
• Tell your mentor your concrete goals, both short term (1 month), medium term (1 year) and long term (5 years). Figure out if you’re on the path to accomplishing those goals.
• Troubleshoot upcoming difficulties and debrief about past difficulties. Maybe you have to give a presentation at a conference, maybe you already did and it went horribly. Your mentor should have some experience to help you understand things that are giving you trouble, and how to approach them. They are there to bounce ideas off, not to tell you what to do.

## Other skills

This doesn’t look like a good way to slide into a base. It looks like the fielder’s leg is in a dangerous position.

To the modern mathematician, a computer is an essential tool. We use it to compute, disseminate, connect, hypothesize, record, verify, advertise, …

Even if you don’t plan on doing “math with computers”, your understanding of mathematics is enriched by knowing how computers interact with mathematics. Or, from a practical perspective, you are more employable outside of academia with coding skills.

#### Learn How to Code

At some point you need to feel what it’s like to “think like a programmer”, and that will give you a richer understanding of what it means to “solve” a math problem.

• [B] Learn Python at Codecademy. This website is fun, interactive and addictive. Python is a powerful, clear, flexible language that can be used to code many mathematical algorithms.
• Learn R at Try_R or Coursera. R is a very stats and data focused language.
• Solve the first 25 Project Euler problems. These are all math/coding problems that involve you writing a program. After about 20 problems you will start to “think like a programmer”.
• Subscribe to /r/dailyprogrammer and do all the challenges from a single week.

#### [B] Learn LaTex

LaTex is the language in which all mathematical writing is done. It is essential that you know how to produce LaTeX documents by the beginning of your third year of undergrad. You will need two things (1) an editor (like Notepad++, TeXnicCenter, etc.) and (2) the TeX (like MiKTeX). If this is the first time you’ve ever done something like this, it will be annoying and take you a while, but it is important.

These projects will give you skills you will need and use.

• Make a pdf that says “Hello World”. This guide will be handy.
• Make a pdf that includes a picture. Learn how to do that here.
• Make a command that takes two arguments “x” and “y” and returns the set “{x : y}”. Learn about “newcommand” here.
• Make a TeX document that imports all of its definitions and commands from another TeX file. Learn how to use “include” here.
• Label a theorem, a section and a picture, then reference them later in a document. It is best practice to use \label and \ref when referring to particular objects in your TeX.
• Make a bibliography using BibTex where the references are contained in a separate file. Learn about external bibliographies here.
• Make a presentation with two slides with Beamer: one slide that says “Hello World”, one that says “Thank You”. Beamer is the standard package for presentations.
• Write your CV in LaTex.

#### Learn the Basic Sorting Algorithms

Besides stretching your mathematical muscles, if you ever have to sort assignments or tests as a TA you’ll be happy that you know some quick sorting algorithms.

#### Hack

Mathematics is about understanding rules as they are, not rules as they should be. Hacking is about exploiting the disparity between these things.

#### Become Familiar a Computer Algebra System (CAS)

Many mathematicians use computers to help with computations. In this project choose any one of the popular CAS: MatLab [Tutorial 1 and Tutorial 2], Mathematica [Tutorial], Sage [Tutorial] or MAPLE – [Tutorial 1 and Tutorial 2]. Generally speaking, MatLab is the one that sees the most use in industry. Some of these are very expensive, but some are free. Check with your university to see if they have some software you can use for free or for a discount.

Here are some sample tasks that you should be able to complete in the CAS of your choice.

• Find the prime factors of 45750341.
• Find the determinant of the matrix:

1    2    3    4
2    3    4    5
1    1    0    0
0    1    1    0

## Thanks for Reading!

#### Feedback

Please let me know if you like this type of content, find it useful, or if you completed one of these projects and you feel proud of it.


text:
## 7-2-71. H. Poincaré to Felix Klein, English translation

Nancy, 22 September 1882

Sir,

Here are a few details concerning functions whose natural limit is formed by an infinity of circles, and about which I spoke in my note in the Annalen.11endnote: 1 See Poincaré (1882c), and Klein’s letter to Poincaré of 19 September, where he claims to know “sehr wohl” such functions (§ 4-47-25). To simplify the exposition, I shall take by way of example a very special case. Suppose we have four points $a$, $b$, $c$, $d$ on the fundamental circle and four circles meeting it orthogonally: the 1st at $a$ and $b$, the 2nd at $b$ and $c$, the 3rd at $c$ and $d$, and the 4th at $d$ and $a$. We have thereby a curvilinear quadrilateral. Let us consider two substitutions (hyperbolic or parabolic), the 1st sending the circle $a\,b$ to the circle $a\,d$, the 2nd sending the circle $c\,b$ to the circle $c\,d$. The Wiederholungen of our quadrilateral will cover the surface of the fundamental circle or only part of that surface; but in every case the group will obviously be discontinuous. It is easy to see that the fundamental circle will be entirely covered in one case only: when the four points $a\,b\,c\,d$ are harmonic and the two substitutions $(ab,ad)$ and $(cb,cd)$ are parabolic. We are dealing here with the modular function. In every other case, we find that the Wiederholungen in question cover only a region bounded by an infinity of circles. Now the whole plane can be abgebildet on our quadrilateral and in such a way that two corresponding points on the perimeter correspond to the same point of the plane. This Abbildung defines a function that exists only in the region covered by the Wiederholungne. Here, however, there is an important remark that must be made. The group generated by the two substitutions $(ab,ad)$ and $(cb,cd)$ may be considered as generated in another way. Let’s consider four circles $C_{1}$, $C_{2}$, $C_{3}$, $C_{4}$ meeting the fundamental circle orthogonally and not intersecting each other such that any is exterior. Consider two substitutions changing $C_{1}$ to $C_{2}$ and $C_{3}$ to $C_{4}$; the group they generate is obviously discontinuous and, for a suitable choice of the 4 circles, it will be the same as the group considered above. The part of the plane exterior to the 4 circles is a quadrilateral of sorts which can be abgebildet on a Riemann surface of genus 2 and which thereby determines a function defined on the whole plane. Here we have one and the same group giving rise to two essentially different functions. One can ask in this connection a great many delicate questions which I can not go into here.

In summary, you see that we can indeed have functions defined only in a region bounded by an infinity of circles and yet which are still “Fuchsian functions”, since all the group’s substitutions preserve the fundamental circle. Each of the circles of the boundary is preserved by one of the substitutions from the group, which also preserves the fundamental circle. You know, of course, that every hyperbolic substitution preserves all circles passing through the two double points.

I learn with pleasure that you are preparing a substantial piece of work of the topic of mutual interest. I shall read it with the greatest pleasure. As Mr. Mittag-Leffler told you, I am writing a paper on that theme myself; in light of its length I divided it in five memoirs:

• The 1st will appear this year, on groups of real substitutions (those I called Fuchsian groups)22endnote: 2 Poincaré (1882e).

• the 2nd on Fuchsian functions; I will soon finish writing this up33endnote: 3 Poincaré (1882b).

• the 3rd on the more general groups and functions that I call Kleinian.44endnote: 4 Poincaré (1883).

• In the 4th, I will address a range of issues sidelined in the second memoir, i.e., the proof of the existence of functions satisfying certain conditions, for instance the proof of the fact that to every Riemann surface there corresponds an analogous function and the determination of the relevant constants.55endnote: 5 Poincaré (1884b).

• Finally, in the 5th, I will discuss Zetafuchsian functions and the integration of linear equations.66endnote: 6 Poincaré (1884a).

I have to return to Paris the day after tomorrow, so I will be there Mr. Lie’s visit. I would be sad to miss the opportunity to meet this famous geometer.

You should have received the first part of my paper on curves defined by differential equations. I will send you the second part shortly, along with my memoir on cubic forms.77endnote: 7 Poincaré (1881a), (1882a), (1881b), (1882d).

Please be assured, sir, of my highest regard,

Poincaré

PTrL. Translated by R. Burns in Saint-Gervais (2016) from the original French (§ 4-47-26), with minor revisions by S.A. Walter.

Time-stamp: "15.05.2021 23:30"

## References

• H. Poincaré (1881a) Mémoire sur les courbes définies par une équation différentielle (I). Journal de mathématiques pures et appliquées 7, pp. 375–422. Cited by: endnote 7.
• H. Poincaré (1881b) Sur les formes cubiques ternaires et quaternaires I. Journal de l’École polytechnique 50, pp. 190–253. Cited by: endnote 7.
• H. Poincaré (1882a) Mémoire sur les courbes définies par une équation différentielle (2nde partie). Journal de mathématiques pures et appliquées 8, pp. 251–296. Cited by: endnote 7.
• H. Poincaré (1882b) Mémoire sur les fonctions fuchsiennes. Acta mathematica 1, pp. 193–294. Cited by: endnote 3.
• H. Poincaré (1882c) Sur les fonctions uniformes qui se reproduisent par des substitutions linéaires. Mathematische Annalen 19, pp. 553–564. Cited by: endnote 1.
• H. Poincaré (1882d) Sur les formes cubiques ternaires et quaternaires II. Journal de l’École polytechnique 51, pp. 45–91. Cited by: endnote 7.
• H. Poincaré (1882e) Théorie des groupes fuchsiens. Acta mathematica 1, pp. 1–62. Cited by: endnote 2.
• H. Poincaré (1883) Mémoire sur les groupes kleinéens. Acta mathematica 3, pp. 49–92. Cited by: endnote 4.
• H. Poincaré (1884a) Mémoire sur les fonctions zétafuchsiennes. Acta mathematica 5, pp. 209–278. Cited by: endnote 6.
• H. Poincaré (1884b) Sur les groupes des équations linéaires. Acta mathematica 4, pp. 201–311. Cited by: endnote 5.
• H. P. d. Saint-Gervais (2016) Uniformization of Riemann Surfaces: Revisiting a Hundred-Year-Old Theorem. European Mathematical Society, Zurich.