# Supplementary material

## Introduction.

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

(ak)' = k2(1-νk2)ak - k*Σn=1,2,...,k-1 anak-n + 2k*Σn≥1 anak+n,

where ak, k≥1 are the Fourier coefficients of the solutionsfor to the KS PDE. Symbolic dynamics for the above system is verified by means of the method of covering relations, as described in the article.

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

## Numerical constants used in the proof.

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

## Description of h-sets.

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 |ak| ≤ Sq-k for k>m
• a = (a1,...,am) - this is the centre of an h-set (an approximate periodic or heteroclinic point), represented as  m-dimensional vector with a1 = 0.
Note that approximate periodic and heteroclinic points have been found on the section  Π = { a1=0 ∧ (a1)'>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
Π = { (xk)k≥1 | π1E*(π≤mx-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 = (r1,...,rm) - interval vector centred at zero, with r1=[0,0]. It defines size of an h-set in the main (m-1) coordinates on the section.

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

π≤mH = a + E*B*r
Hk = [-S,S]q-k for k>m

## List of h-sets that appear in the computation.

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.

### H-sets at periodic points

• N1.txt - the h-set centred at the fixed point  a1
• N2.txt - the h-set centred at the fixed point  a2

## The C++-11 program.

### Requirements.

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

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

### Recommendations.

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.

### Compilation using gcc compiler.

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.

### Compilation using clang compiler.

In order to compile the program with the clang compiler (CAPD library must be also built with clang) one has to add CC=clang++ parameter when invoke make

Example:

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

### Compilation within docker platform.

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.

### Parameters of the program.

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&

### Output of the program.

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

1. obtained bounds on the Poincare maps,
2. information if a covering relation has been verified or not (this should not happen),
3. 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:

### Source code of the program.

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.

## Content of the archive.

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.