# Tag: Mathematics

## Truth

Proposition calculus deals with statements and the relation between statements, where each of them can only be in one of two states; . Therefore, when working with finitely many connected propositions, one can algorithmically determine all possible truth values of all atomic and thus connected propositions.

*Truth* is command-line tool which was written to precisely perform those computations; computing a logical expression’s truth value. Download link: truth.py

A list of all supportet operators can be seen by invoking the tool with a `--help`

flag.

This project was inspired by Albert Menne’s *Einführung in die Logik*^{1}; the operator syntax used is similar to his, translated to be 7-bit-ASCII-compatible.

*Truth* can be used to either verify universally true statements, e.g. *tertium non datur* and a property of the replication, *verum sequitur ex quodlibet*.

-(p&-p) <-> 1 , 1 <- p 1 0010 1 1 1 1 0 1 1001 1 1 1 1 1

Though not only absolute truth, but also complete relational equivalence between two expressions can be shown.

(p->q)|(r>-<s) <-> q|(r|s)&-(r&s)|-p 01 0 1 0 0 0 1 00 000 01 000 110 10 0 0 0 0 0 1 00 000 01 000 001 01 1 1 0 0 0 1 11 000 01 000 110 11 1 1 0 0 0 1 11 000 01 000 101 01 0 1 1 1 0 1 01 110 11 100 110 10 0 1 1 1 0 1 01 110 11 100 101 01 1 1 1 1 0 1 11 110 11 100 110 11 1 1 1 1 0 1 11 110 11 100 101 01 0 1 0 1 1 1 01 011 11 001 110 10 0 1 0 1 1 1 01 011 11 001 101 01 1 1 0 1 1 1 11 011 11 001 110 11 1 1 0 1 1 1 11 011 11 001 101 01 0 1 1 0 1 1 00 111 00 111 110 10 0 0 1 0 1 1 00 111 00 111 001 01 1 1 1 0 1 1 11 111 00 111 110 11 1 1 1 0 1 1 11 111 00 111 101

Complete contravalence can also be shown.

-(p/-p>-<0)|p->q<-r >-< p&-q&r 0 0110 1 0 101 01 0 1 001000 0 1101 1 0 110 01 0 1 111000 0 0110 1 0 101 11 0 1 000100 0 1101 1 0 111 11 0 1 100100 0 0110 1 0 101 01 1 1 001001 0 1101 1 0 010 00 1 1 111011 0 0110 1 0 101 11 1 1 000101 0 1101 1 0 111 11 1 1 100101

^{1}Menne, Albert: *Einführung in die Logik*. Bern: Francke, 1966. (= Dalp-Taschenbücher; 384 D)

## Lyapunov Fractal

Lyapunov fractals are mathematical objects living in the plane, graphing regions of stability or chaos regarding a certain logistical map following an ever-changing population growth, alternating between two values.

I implemented a Lyapunov fractal viewer in Java 1.8 which lets you freely move around the plane, set sequences and iteration depths to explore the fractal. Source code can be seen below or downloaded, as can the Java executable (Lyapunov.java, Lyapunov.jar).

My first encounter with this fractal was whilst browsing Wikipedia and stumbling across its Wikipedia entry. Since it was a fractal and looked fairly intricate and thus explorable, I set out to write my own renderer — I chose to implement it in Java, as it is a compiled language with a nice set of GUI libraries. Since Wikipedia listed an algorithm for generating Lyapunov fractal images, I thought an implementation would be fairly straight-forward. However, als always, the devil is in the detail and I quickly noticed that while the short Wikipedia entry looks convincing and well-written at first glance, lacks to answer deeper questions regarding the very topic it is about.

The following is a description of the fractal generation algorithm. It is a modified version of the algorithm detailed by Wikipedia which addresses certain ambiguities the original had (more on those later).- Take as input a complex point and a sequence consisting of the letters and ; for example .
- Construct a function which returns the zero indexed -th sequence entry and wraps around to the sequence’s start once the sequence’s end is hit.
- Construct a function which selects either or .
- Let and define .
- Calculate the Lyapunov exponent as follows.

Since calculating the limit as goes to infinity is rather difficult in practice, one can simply use a sufficiently large and pretend to have reached infinity. - Output a color value according to . I chose green for and blue for , using arbitrarily defined value ranges to map to an actual color.

```
// choose a or b according to Seq and n
static double r(String Seq, int n, double a, double b) {
if (Seq.charAt(n%Seq.length()) == 'A') return a; else return b;
}
// calculate a pixel color (0x00rrggbb) for given parameters
static int LyapunovPixel(double a, double b, String Seq, int N) {
// array of all x_n; x_0, the starting value, initialize all x_n values
double[] X = new double[N+1]; X[0] = .5;
for (int n = 1; n <= N; n++) X[n] = r(Seq,n-1,a,b)*X[n-1]*(1-X[n-1]);
// calculate the Lyapunov exponent (to a certain precision dictated by N)
double lmb = 0;
for (int n = 1; n <= N; n++)
lmb += Math.log(Math.abs(r(Seq,n,a,b)*(1-2*X[n])))/Math.log(2);
lmb /= N;
// infinity was hit, use a black pixel
if (Double.isInfinite(lmb)) return 0x000000;
// color pixel according to Lyapunov exponent
double MIN = -1, MAX = 2;
if (lmb < 0) return ((int)(lmb/MIN*255))<<8;
else return ((int)(lmb/MAX*255))<<0;
}
```

Coming back to Wikipedia’s algorithm, there were a few things I found irritating at best when attempting my implementation and thus addressed in the algorithm description seen above. A closer look at potentially misleading or ambiguos statements follows, together with my reasoning to resolve them.
It is not clear whether the sequence is zero or one indexed, though it has to be zero indexed as evaluates to , implying the definition of and thus .

It is not clear which logarithm is meant; the natural logarithm, a generic or the dyadic logarithm — the latter is actually used. To find the actual logarithm base, I dug deeper and used Wikipedia’s external links to find a post by Earl Glynn, answering this question.

It is not clear what is meant by the second half of the sentence beneath the Lyapunov exponent. It reads *“… dropping the first summand as for .”* As the sum starts with and one would not dare to calculate for , this sentence’s existence bewilders me.

It is not clear how exactly the colors are derived, only that they have something to do with the Lyapunov exponent. I simply chose arbitrary values that looked convincing for mapping to a pixel color.

One of the most frustrating*bugs*I came across was an unexplainable axis flip. My code generated the fractal just fine except for the fact that every image was flipped along the diagonal crossing the origin with a angle to the horizontal. It was as though the coordinates were swapped somewhere in my code and I simply could not figure out where.

Finally, after hours of looking at the same code over and over again, a closer look at Earl Glynn’s post brought an end to my misery. Just below the three welcoming fractal renderings, a screenshot of their software is shown — complete with a blue and red line indicating the coordinate system’s orientation. and are — contrary to all coordinate systems involving parameters named after the first two letters in the latin alphabet — indeed flipped. Wikipedia’s images must have simply ran with this decision, without noting it.

Because of this flip, when one wants to render images specified in the reversed sequence format, they simply have to swap all letters (for example becomes ).

As Glynn themself says, *“I would have reversed the ‘a’ and ‘b’ labels to be consistent with normal ‘x’ and ‘y’ axes conventions, but conform here with the same convention as used by Markus.”* (Referring to Mario Markus, co-author of *Lyapunov Exponents of the Logistic Map with Periodic Forcing*.)

`.png`

files and named according to their parameters. A list of program controls follows.
- Mouse dragging lets one pan the complex plane.
- Mouse scrolling lets one zoom the complex plane.
- Pressing
*N*evokes a dialogue box where one can specify an iteration depth . - Pressing
*S*evokes a dialogue box where one can enter a sequence . - Pressing
*R*resets all fractal parameters to the default. - Pressing
*P*initiates a 4K fractal rendering. The 4K fractal rendering thread can be killed by exiting the program prematurely, thus losing (!) the rendering.

`// Java 1.8 code; written by Jonathan Frech, 2017`