Supplementary material

to the article

A geometric method for infinite-dimensional chaos: symbolic dynamics for the Kuramoto-Sivashinsky PDE on the line


Daniel Wilczak and Piotr Zgliczyński

Table of content.


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

Numerical constants used in the proof.

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

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:

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

H-sets along a1->a2 heteroclinic chain

H-sets along a2->a1 heteroclinic chain

The C++-11 program.


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


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


tar xvfz supplement.tgz
make CAPD=/home/users/wilczak/capd-capdDynSys-5.0.59/bin/


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


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


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

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

an auxiliary file which contains two global functions used to measure and print time of computation
an auxiliary file which contains global functions implementing projections and embeddings between Poincare sections and full phase space
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.
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.
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