- Introduction
- Numerical constants used in the proof
- Description of h-sets
- List of h-sets that appear in the computation
- The C++-11 program
- Requirements
- Recommendations
- Compilation using gcc compiler
- Compilation using clang compiler
- Compilation within docker platform
- Parameters of the program
- Output of the program
- Source code of the program
- Content of the archive

The Kuramoto-Sivashinsky PDE (referred in the sequel as KS equation), after imposing odd and periodic boundary conditions, can be rewritten as an infinite-dimensional ODE

(a_{k})' = k^{2}(1-νk^{2})a_{k}- k*Σ_{n=1,2,...,k-1}a_{n}a_{k-n}+ 2k*Σ_{n≥1}a_{n}a_{k+n},

where `a _{k}`,

We constructed two sequences of covering relations along numerically observed heteroclinic chains joining two selected periodic solutions in both directions. Then, using rigorous integrator for the KS equation, we were able to check assumptions of an abstract topological theorem, which guarantees the existence of symbolic dynamics.

The purpose of this document is to provide

- an information about numerical constants and settings used in the computation
- definition of h-sets and Poincare sections used in the computation
- an instruction of how one can compile and run the C++ program, which check assumptions of the topological theorem

The following constants were used in our computation. Some of them are mentioned in the article.

`q = 3/2`- this is geometric decay ratio used to define infinite tails (see data structures**GBound**and**HSet**in the article)`m = 15`- number of leading coordinates of an h-set represented explicitly in the computer memory (see data structure**HSet**in the article)`d = 4`- order of the Taylor method and the High Order Enclosure

In order to reduce overestimation in rigorous computation of Poincare maps, each h-set is embedded into a different Poincare section, which is almost orthogonal to the vector field near the centre of this h-set (an approximate heteroclinic point).

Each h-set that appears in the computation is described by the following data:

`S > 0`- constant used to define geometrically decaying tail`|a`for_{k}| ≤ Sq^{-k}`k>m``a = (a`- this is the centre of an h-set (an approximate periodic or heteroclinic point), represented as_{1},...,a_{m})`m-`dimensional vector with`a`._{1}= 0*Note that approximate periodic and heteroclinic points have been found on the section*`Π = { a`_{1}=0 ∧ (a_{1})'>0 }`E`-`m×m`- almost orthogonal matrix (up to floating point accuracy) used to define Poincare section. First column of the matrix is close to flow direction at`a`, while the remaining columns span`(m-1)`-dimensional subspace of the section. Formally, the section is given by`Π = { (x`_{k})_{k≥1}| π_{1}E*(π_{≤m}x-a) = 0 }`B`-`m×m`- shape matrix of an h-set. First row and first column of this matrix is set to`(1,0,...,0)`just to simplify further notation. The remaining`(m-1)×(m-1)`block defines affine change of coordinates.`r = (r`- interval vector centred at zero, with_{1},...,r_{m})`r`. It defines size of an h-set in the main_{1}=[0,0]`(m-1)`coordinates on the section.

The above data structure `[S,a,E,B,r]` defines an h-set `H` by

π_{≤m}H = a + E*B*r

Hfor_{k}= [-S,S]q^{-k}k>m

Below we give list of links to `24` text files. Each file contains a record `[S,a,E,B,r]` of data, as described above.
File names correspond to notation used in the article.

- N1.txt - the h-set centred at the fixed point
`a`^{1} - N2.txt - the h-set centred at the fixed point
`a`^{2}

- N0_12.txt - the h-set
`N`^{0}_{1->2} - N1_12.txt - the h-set
`N`^{1}_{1->2} - N2_12.txt - the h-set
`N`^{2}_{1->2} - N3_12.txt - the h-set
`N`^{3}_{1->2} - N4_12.txt - the h-set
`N`^{4}_{1->2} - N5_12.txt - the h-set
`N`^{5}_{1->2} - N6_12.txt - the h-set
`N`^{6}_{1->2} - N7_12.txt - the h-set
`N`^{7}_{1->2} - N8_12.txt - the h-set
`N`^{8}_{1->2} - N9_12.txt - the h-set
`N`^{9}_{1->2} - N10_12.txt - the h-set
`N`^{10}_{1->2}

- N0_21.txt - the h-set
`N`^{0}_{2->1} - N1_21.txt - the h-set
`N`^{1}_{2->1} - N2_21.txt - the h-set
`N`^{2}_{2->1} - N3_21.txt - the h-set
`N`^{3}_{2->1} - N4_21.txt - the h-set
`N`^{4}_{2->1} - N5_21.txt - the h-set
`N`^{5}_{2->1} - N6_21.txt - the h-set
`N`^{6}_{2->1} - N7_21.txt - the h-set
`N`^{7}_{2->1} - N8_21.txt - the h-set
`N`^{8}_{2->1} - N9_21.txt - the h-set
`N`^{9}_{2->1} - N10_21.txt - the h-set
`N`^{10}_{2->1}

The program is written in C++11. In order to compile the program one needs to

- have a C++11 compiler - we tested the program with
**g++**and**clang++**compilers - install the
**CAPD library**version**capd-capdDynSys-5.0.59.tar.gz**

Before you compile the CAPD library make sure that the system satisfies all **requirements**.

You can follow the **compilation instruction** or just type from the command line (under linux with gcc):

tar xvfz capd-capdDynSys-5.0.59.tar.gz

cd capd-capdDynSys-5.0.59

./configure --without-gui --without-mpfr

make -j lib

The program is highly parallelized by means of the C++11 threading. We strongly recommend to run the program on a computer equipped with as many cores as possible.

We tested the program on a computer with `128 Intel(R) Xeon(R) CPU E7-8867 v4 @ 2.40GHz` processors. The computation finished within approximately **40 minutes**.

The program can be compiled and run on any personal computer. Estimated time of computation on a personal computer/laptop with quite modern processor having 2 physical cores (4 threads) should not exceed **14 hour**.

The program does not require large RAM memory - `1GB` is more than enough.

Before compilation of the program make sure, that you downloaded and compiled the CAPD library. Let `path` be relative or absolute path to the directory, where the library is built.

In order to compile the program, one needs to extract the archive into an empty directory and invoke `make CAPD=path/bin/`.

Example:

tar xvfz supplement.tgz

make CAPD=/home/users/wilczak/capd-capdDynSys-5.0.59/bin/

or

make CAPD=../capd/bin/

The above command generates an executable `main` in the current directory.

Example:

make CC=clang++-4.0 CAPD=/home/users/wilczak/capd-capdDynSys-5.0.59/bin/

This is the easiest way to build and run the program, if you are familiar with the **docker** platform. Copy **supplement.tgz** into an empty directory and invoke

tar xvfz supplement.tgz

docker build -t ksproof $(pwd)

docker run -v $(pwd):/outdir -ti ksproof

The second command builds the docker image based on Ubuntu 18.04, installs all necessary standard libraries, compiles the CAPD library and then compiles the program - see **Dockerfile** for the details.

The third command runs the program and redirects its output to the file `output`.

When the program is called without parameters

./main

it automatically recognizes the maximal number of available CPUs on the machine and uses all of them to perform computation. Alternatively, we can provide a parameter which specifies maximal number of CPUs to be used by the program (should not exceed the number of available CPUs)

./main 64

Optionally (but recommended) we can redirect the output of the program to a file, say `output`

./main 64 > output&

The program prints (rather rarely) to the standard output information about the progress of the computation. In particular:

- obtained bounds on the Poincare maps,
- information if a covering relation has been verified or not (this should not happen),
- final report from computation.

The program creates also the text files `hsets/N1.txt, hsets/N2.txt, hsets/Ni_jc.txt` which contain definitions of all `h-sets` and Poincare sections, as **described above**.

The order of data printed by the program is not deterministic due to asynchronous execution of tasks. Here are sample outpus of the program when run on a computer with 128 and 4 threads, respectively:

The program is built on the **CAPD library** which provides in particular

- interval arithmetics
- data structures and algorithms of linear algebra
- data structures and algorithms for automatic differentiation
- data structures and algorithms for rigorous integration of ODEs
- data structures and algorithms for rigorous computation of Poincare maps

Here we give an overview on the code specific for the computer-assisted proof of chaos in the KS equations. The program is split into five files

- tictac.h
- an auxiliary file which contains two global functions used to measure and print time of computation
- embeddings.h
- an auxiliary file which contains global functions implementing projections and embeddings between Poincare sections and full phase space
- ProofData.h
- data structure which stores all h-sets used by the program. It's method
`init`is used to initialize them from the precomputed approximate fixed points and heteroclinic points. - KSPoincareMap.h
- this file contains code responsible for computation of Poincare maps in the proper coordinate systems. Two implemented classes (for nonrigorous and rigorous computation) are wrappers for the general class
`PoincareMap`from the CAPD library. - main.cpp
- the main program. It runs asynchronous tasks which compute Poincare maps and check inclusions required for covering relations.

The archive **supplement.tgz** consists of

- subdirectory
**hsets**which contains text files`Ni.txt`and`Ni_jc.txt`with definitions of h-sets as records`[S,a,E,B,r]`. These files are generated by the program. - subdirectory
**data**which contains input data for the program, like approximate heteroclinic points, precomputed coordinate systems. - subdirectory
**src**with the source code of the program **Makefile**- rules to build the executable**Dockerfile**- rules to build the docker image**index.html**- the present document**output_128_threads**- sample output of the program.**output_4_threads**- sample output of the program.