where the iterator is defined as

The render resolution is kept at a recognizable minimum as not to overburden the machine tasked with creating it. Source: mandelbrot-set.sb3

]]>is its own multiplicative inverse, showing that does not hold in a general commutative Ring with one.

This phenomenon is uniquely characterized by the following equivalence:

*Proof. Negated replication.*

Let be a unit polynomial of non-vanishing degree . Let denote its multiplicative inverse, i.e. .

*Claim.* The polynomial has non-vanishing degree .

*Proof.* Suppose . Since , it follows from that is a zero divisor. However, at the same time implies that is a unit, arriving at a contradiction.

Since both , one concludes as well as .

Existence of the desired ring elements is assured by the following construction.

Let rise discretely.

If , implying , holds, since the construction arrived at this point, one finds

The above condition is met for at least one , since otherwise would imply , which is impossible since and is a unit element.

By construction, as well as are given.

*Negated implication.*

Setting , one calculates

,

showing .

*q.e.d.*

As a corollary, the property follows for any integral domain.

Furthermore, looking at , this ring’s zero divisors are , with no mutual zero divisors summing to zero. Using the above, follows.

It defines

an isomorphism in the category **Set**.

It defines

a non-commutative ring without one of cardinality four in which every element is a zero divisor with left-annihilating element **Λ**:

*Thanks to Nathan Tiggemann for finding this marvelous algebraic structure.*

Generalizing, any commutative ring with one **R** induces a non-commutative ring without one on which **Λ** acts as an omni-right-annihilator, namely

.

As a corollary, by constructing the above ring using the reals, one obtains a ring with a (left-factored) polynomial ring housing a polynomial of degree one having uncountably many roots:

.

]]>

With me almost surely not being able to solve this problem thru proof, I took the route of silicon-assisted problem analysis: simulation. However, even on very large lattice segments, the beam often either escapes or exists only for a very short time — as seen above.

Source code: mmm_visualize.py, mmm_simulate.py

An example of a rather intricate path which eventually escapes the chosen view:

After seeing the beams often escape my view frames, I decided to also simulate the problem without visualization — both to potentially get a performance increase as well as to lift the constraints of finite imagery. My results for running ten simulations are as follows:

$ python mmm_simulate.py 10 [X] Exceeded the maximum visited mirrors threshold of 1000000. [X] Exceeded the maximum visited mirrors threshold of 1000000. [.] Visited 5110 mirrors before falling into a loop. [X] Exceeded the maximum visited mirrors threshold of 1000000. [.] Visited 4 mirrors before falling into a loop. [X] Exceeded the maximum visited mirrors threshold of 1000000. [X] Exceeded the maximum visited mirrors threshold of 1000000. [X] Exceeded the maximum visited mirrors threshold of 1000000. [X] Exceeded the maximum visited mirrors threshold of 1000000. [X] Exceeded the maximum visited mirrors threshold of 1000000.

One can clearly see that whilst some paths are of minuscule lengths, others far exceed those, traversing over a million mirrors until getting stopped as to not fry my machine.

My professor’s conjecture states that any given mirror configuration almost surely — meaning with probability **1** — causes the beam of light to fall into a cycle.

In some sense it appears intuitively clear — escaping requires an infinite amount of mirrors to be placed correctly, however: could the beam also find a sneaky way around a lot (in the sense of being of non-vanishing measure) of configurations, squeezing elegantly and indefinitely around all obstacles? After running my simulations doubts in the former increase, leaving me cluelessly in the dark, waiting for a proper proof to be formalized.

As of the 24th of April 2019, krrp is kindly included in the TIO language collection, making krrp interpretation available from within the web. Great thanks go out to TIO for providing this service.

krrp is a functional, dynamic, interpreted and (theoretically) Turing-complete esolang implemented only using standard C. As such, on top of designing the actual language, any data structures, memory management and general auxiliary functionality deviating from the lacking capabilities offered by C had to be home-brewed and hand-crafted. A time-consuming task — I have been working on this language for the past year. However, it gives the language a certain purity, as its high-level functional approach rests firmly and closely on the state-changing, mutable and segmentation-faulting depths that are the C language.

As far as the language itself goes, I intentionally went with a sparse set of core features, in spirit aligned with functional pioneers like Lisp. Most constructs are represented using only one or a few bytes, leading to a compressed, though (possibly disputably) surprisingly legible source code look:

./krrp -c ',^k:?<k2k+@-k1@-k2.$20.' $6765.

In eighteen bytes, the above program fully represents the Fibonacci recurrence relation, an additional five are required to apply the implementation and compute — counting zero-indexed.

However, also higher-level computations are possible using krrp; `LxLyLzE`

representing the standard algebraic list data type:

./krrp -c '\L\M [map]^n:[pow]2n.[range]0$12.' L1L2L4L8L$16.L$32.L$64.L$128.L$256.L$512.L$1024.L$2048.E

True to its esoteric appearance, krrp is also capable of some rather unorthodox behavior:

./krrp -c '!f^g:g581. f^ij:*+jii. f^_:-0_. f^xyz:-x*yz.' $65. $-5. $-3.

With that being said, I can only hope that you will give krrp a try and wish all of you …

./krrp --str -c ']]>\L[append][map]^c:+*8$11.c.L$-16.L9L$24.L$24.L$33.EL$32.[append][filter]^z:|>%z20<$100.z.L2L$69.L$97.L4L$115.L$90.L8L$116.L$101.L$114.L$22.E L$46.E'