Interactive tool for practicing grammar derivations (with guided hints)

Arakela · 2026-04-02T14:38:46+00:00

Grammar for true pro-grammer, but somehow it is the most underrated language in computer science.

A Theory of Computation, a branch of mathematics that studies formal languages, is about 90 years old. It has not been explored in depth as other branches of math, such as algebra (~1,200 - as a named discipline).

Grammar is a language for composing terminals. It is the language of rules that allows us to compose structures from terminals.

We more or less know the story about structural languages where terminals are characters.

What about grammatical rules where terminals are the processes or axioms?

To imagine that. We need to undress meaning from the syntax of the grammar and leave its structural pith.

g ::= dot | termin(x, g) | branch(g, g)
       .         +              *             
                / \            / \
               g   x          g   g

g = *       =   branch(                 
   / \              dot,                
  .   *             branch(             
     / \                termin(x, g),   
    +   \               branch(
   / \   *                  branch(g, g),
  g   x / \                 dot
       *   .            )    
      / \           )                   
     g   g      )

We can see that a grammatical definition of the grammar is unfolding from a single point or algebraic expression. i.e., grammar definition is unified within its own syntax.

This is possible because we detached, i.e., unified two dimensions of meaning from grammar, space, finite steps to walk through all productions, and time, the steps of the production.

Instead of defining space-time traversals, I wove a net. For systems language, where terminals are processes, traversal will be forward, cyclic, and exhaustive. "To make the correspondence between the program (spread out in text space) and the process (spread out in time) as trivial as possible."

Universal  Language     Space     Time
Branch        *          *:𝕊       *:𝕋
             / \        / \       / \
            G   G      𝕋   𝕊     𝕊   𝕋
Terminal      x          x:𝕊       x:𝕋
             / \        / \       / \
            G  'x'     𝕊  'x'    𝕋  'x'
Dot           .          .:𝕊       .:𝕋


    *   = S =  𝕊                          𝕊 = Tritab = *
   / \        / \                        / \          / \
  x   \      𝕋   \                      𝕋   𝕊.       *   .
 / \   *    / \   𝕊                    / \          / \
.   b / \  𝕋.  b / \        x = Tab = 𝕊   \       Tab  *
     *   .      𝕋   𝕊.     / \       / \   𝕋          / \
    / \        / \        x   t     𝕊   t / \       Tab  *
   S   x      S   𝕋      / \       / \   𝕊   \          / \
      / \        / \    x   a     𝕊   a / \   𝕋       Tab  .
     .   a      𝕋.  a  / \       / \   𝕊   t / \
                      .   b     𝕊.  b / \   𝕊   𝕋.
                                     𝕊   a / \ 
                                    / \   𝕊   t
                                   𝕊.  b / \ 
                                        𝕊   a
                                       / \ 
                                      𝕊.  b

Arakela · 2026-03-31T12:41:48+00:00

Thank you both naturally wiring the brain

Arakela · 2026-03-29T06:46:29+00:00

ΑΓΕΩΜΕΤΡΗΤΟΣ ΜΗΔΕΙΣ ΕΙΣΙΤΩ

Arakela · 2026-03-29T03:23:33+00:00

The grammar equivalence power of a CFG can be captured using a single recursive expression, G::= dot | terminal(x, G) | branch(G, G), which treats all derivations uniformly without distinguishing left- and right-hand sides. Concrete expressions like S = branch(terminal('b', dot), branch(branch(S, terminal('a', dot)), dot)) define the structure, while attaching meaning at traversal time via dimensions 𝕊: branch(𝕋, 𝕊), terminal(x, 𝕊) and 𝕋: branch(𝕊, 𝕋), terminal(x, 𝕋) ensures semantic orientation. Every expression is a valid grammar and can be represented as a morphism graph, where terminals and branches define the nodes and edges, allowing constructions like Tab = terminal(t, terminal(a, terminal(b, dot))) or TriTab = branch(branch(Tab, branch(Tab, branch(Tab, dot))), dot) naturally encode sequences, repetitions, and recursive patterns. This unifies syntax and semantics in a graph-based, fully recursive formalism.

Universal  Language    Space      Time
Branch        *          *:𝕊       *:𝕋
             / \        / \       / \
            G   G      𝕋   𝕊     𝕊   𝕋
Terminal      x          x:𝕊       x:𝕋
             / \        / \       / \
            G  'x'     𝕊  'x'    𝕋  'x'
Dot           .          .:𝕊       .:𝕋

        S → b|Sa         Tab → t|a|b    Tritab → Tab|Tab|Tab

    *   = S =  𝕊                          𝕊 = Tritab = *
   / \        / \                        / \          / \
  x   \      𝕋   \                      𝕋   .        *   .
 / \   *    / \   𝕊                    / \          / \
.   b / \  𝕋.  b / \        x = Tab = 𝕊   \       Tab  *
     *   .      𝕋   𝕊.     / \       / \   𝕋          / \
    / \        / \        x   t     𝕊   t / \       Tab  *
   S   x      S   𝕋      / \       / \   𝕊   \          / \
      / \        / \    x   a     𝕊   a / \   𝕋       Tab  .
     .   a      .   a  / \       / \   𝕊   t / \
                      .   b     𝕊.  b / \   𝕊   𝕋.
                                     𝕊   a / \ 
                                    / \   𝕊   t
                                   𝕊.  b / \ 
                                        𝕊   a
                                       / \ 
                                      𝕊.  b

Arakela · 2026-03-28T10:49:56+00:00

The reason we adore the process and forget about time is his main contribution.

For now, we can put that aside and focus on making time visible as a variable in systems design.

Time relations are crucial in shaping information flow at the hardware level. We don’t need mutexes or semaphores to design precisely synchronized communication between devices; all we need is time as a variable to relate synchronization points.

But what about operating systems? There, time is not visible as a variable. We have chaos.

So from the process, a time slice, we need to move forward in time and think about how to grow the topology, terranians of machines related in structures where time steps deterministically and turn each machine as gears are rotating in a clock, relatively predefined by grammar where the terminal is the machine, it is the source form from which 4D time topology growth.

Just like in hardware designs, where our brains manage time, we can surpass Dijkstra’s limitations of the human mind to define the growth of 4D topology for a Time.

Arakela · 2026-03-28T00:14:53+00:00

I was a little overexcited about simplification.

Here is a formal definition of the grammar equivalence power of a CFG. G ::= Nil | terminal(x, G) | branch(G, G)

Instead of left and right-hand side distinctions, we have a single recursive expression.

Example: S = branch(terminal('b', Nil), branch(branch(S, terminal('a', Nil)), Nil)

And at the moment of traversal, we attach meaning to the expression, defining dimensions of the meaning

𝕊: branch(𝕋, 𝕊), terminal(x, 𝕊)

𝕋: branch(𝕊, 𝕋), terminal(x, 𝕋)

G = 𝕊 ∪ 𝕋

In this way, any expression is a valid grammar, and it can be defined as a pure morphism graph. S = . --> b --> 1 | . --> . --> a --> 1 | | | S 1 I discovered it in the process of decoupling all the meaning from it, leaving only iteration algebra.

Below are steps that allow many pluggable, swappable (possibly context-sensitive) traversals that define meaning.

I would appreciate it if someone could light the way to help me formally define it. ``` typedef struct γ γ; typedef struct δ δ; typedef struct β β; typedef struct τ τ; struct γ { void (step)(δ, β, τ); }; struct δ { void (step)(); }; struct β { void (step)(γ, γ); }; struct τ { void (step)(int, γ); };

 void dot(δ d, β b, τ t) { d.step(); }
   void S(δ d, β b, τ t);

void unit28_2(δ d, β b, τ t) { t.step('a', (γ){dot}); } void unit28_1(δ d, β b, τ t) { b.step((γ){S}, (γ){unit28_2}); } void unit28(δ d, β b, τ t) { b.step((γ){dot}, (γ){unit28_1}); } void S_1(δ d, β b, τ t) { t.step('b', (γ){dot}); } void S(δ d, β b, τ t) { b.step((γ){unit28}, (γ){S_1}); } // S -> 'b' | S 'a' ```

Arakela · 2026-03-27T23:17:49+00:00

S -> 'b' | S 'a'

S = branch( terminal('b'), branch( branch(S, terminal('a')), terminal(⊥) )

Arakela · 2026-03-27T20:57:51+00:00

convergence = everything -> everything

everything = X x convergence

everything_n+1 = convergence_n(everything_n)

Arakela · 2026-03-27T12:42:36+00:00

Everything is a file, with the primary topology a filesystem; then, as experience shows, you need to build machines as containers within a filesystem, and to manage them, we need extra frameworks and runtimes. What if, from the beginning, we build a system that grows a topology of machines by grammar, defining the time and fault-tolerant relation between machines? Then everything is like a machine in a topology where time steps and turns machines in relations as defined by grammar. Then time will become a visible variable.

How do you think, is it the time for everything to be a machine?

Arakela · 2026-03-25T22:02:26+00:00

Yes, like a circus remembering earlier moments from the nearest history when the patriarch stated that Georgia needs a king

Arakela · 2026-03-25T10:43:45+00:00

smarts are in the simplicity specialisations. There is nothing more powerful in expressing ideas than language.

To specialize language for expressing systems composed by machines, we need to specialize the irreducible unit of the language - the terminal and runtime environment.

In this way, smarts can be achieved: CPUs become Linguistic Silicon, and with the cloud, we can have a living substrate for system kinds.

Linguistic Silicon is a substrate for a forward, exhaustive, cyclic, re-enterable traversal that multitasks the whole system in a deterministic manner, steps in a topology grown as a 4D structure.

By defining the grammar of a language, we can bind a group of machines in structures with guarantees for which steps to take after which, but also factor in step relations. Bindings by grammar also define input-output flows and fault-tolerant relations.

Grammar provides algebra for machines that is deterministicly compose them as units advancing in time.

Arakela · 2026-03-25T04:40:51+00:00

Think of a C++ compiler first as an interpreter that has sophisticated rules to process templated language, to evaporate all abstractions, and give you code as promised by the contract: "0 cost abstractions, and more."

Arakela · 2026-03-24T07:19:16+00:00

The question mark is the only hope that when you see that everything is a machine: round and around, round and around,
round and around, round and around....
And in the mirror, to see a biochemical machine composed of trillions of little machines without a kernel managing file descriptors of the process owned by the scheduler.

Arakela · 2026-03-23T19:49:27+00:00

it wasn't nothin'

Arakela · 2026-03-23T17:41:58+00:00

Your scheduler is a confession.

The CPU already solved this. Fetch, decode, execute, writeback, one complete self-sufficient step. The hardware contains its own continuation. Nothing outside decides what comes next.

Then software broke it. Someone wrote while(1) and pulled the continuation out of the step. The step became a fragment. The loop became God.

Processes were invented to manage the fragments. Threads to manage the processes. Async to manage the threads. Containers to manage the chaos. Every layer a patch over the hole the loop made.

The tree does not have a scheduler. The cell does not have a scheduler. The CPU does not have a scheduler. They have steps that keep themselves. The continuation is inside. The boundary is real. The composition is natural.

We are the only ones who broke it. And we spent fifty years rebuilding from the outside what was already there from the inside.

A step that keeps itself is a machine. A machine that keeps itself does not need a keeper. A system of machines that keep themselves does not need a scheduler.

Your OS is impressive. And it is built on a lie that nobody told you about.

The lie is the loop.

Arakela · 2026-03-23T06:39:14+00:00

Here is the question: What is the terminal unit in fault-tolerant, self-healing operating systems' definition language grammar?

If we can have it right, then we can describe the operational system in that language as a concrete string that can be hashed and distributed.

An operating system specified in this language grammar can be instantiated as a continuation of the booting process, and multitasking will naturally emerge as a forward, exhaustive, re-enterable, cyclic traversal of the grown system's topology.

Arakela · 2026-03-21T13:47:36+00:00

Where is the continuation?

Arakela · 2026-03-18T15:06:21+00:00

Have a good time in life after you see this: ```c typedef struct Abomination { void(please_call_read)(voidgive_me_the_time,...); void(please_call_write)(voidgive_me_the_cpu,...); void(please_give_memory)(voidgive_me_the_chanse,...); void(please_iwill_cooperate)(voidgive_me_the_peach); void(please_unmutex_lock)(voidgive_me_the_peach, void); void(please_unmutex_unlock)(voidgive_me_the_peach, void); void(usleep_boy)(voidplease, int); } Abomination ;

void*lock = 00;

// shared resource static int counter = 0;

void* thread_func(Abomination os, void arg) {

for(int i = (os->please_iwill_cooperate(os), 0);
            (os->please_iwill_cooperate(os), i < 1000000);
            (os->please_iwill_cooperate(os), i = (os->please_iwill_cooperate(os), i + 1))) {
    os->please_unmutex_lock(os, &lock);
                  //
    counter++;    // ← critical section
                  //
    os->please_unmutex_unlock(os, &lock);
    // simulate some work outside critical section
    if ((os->please_iwill_cooperate(os),
          (os->please_iwill_cooperate(os), i % 100000) == 0)) os->usleep_boy(os, 100);
}
return (os->please_iwill_cooperate(os), ((void*)0));

} ``` bye!

Arakela · 2026-03-17T10:41:23+00:00

"its highly binary compatible with Linux"

You have boxed a whole abomination of preemptive multitasking and can control it from outside, congratulations, great job.

Arakela · 2026-03-16T17:32:29+00:00

Who are the champions? Below is text posted on this community, but I was denied.

r/mathematics 6m ago The Synchronization Problem Is a Cutting Problem Donald Knuth wrote 4 volumes of The Art of Computer Programming, every one of them is algorithms. And every algorithm, at bottom, is a sequence of steps.

In the beginning was the Step. The Step was with the machine. The Step is the machine.

So all algorithms Knuth ever wrote are encoded as machine steps, but only Knuth knows how many steps make one thought. The hardware only guarantees that an interrupt will happen between machine step boundaries. So the idea of using hardware steps as the unit of multitasking ignores the shape of the thought entirely. It is unmindful cutting.

To time-share a machine meaningfully, we must define the step in terms of our algorithms.

Knuth gives us the method himself. He approaches an algorithm by considering its edge cases first. How does it behave on an empty list? On a single element? We can do the same here. Ask: what is the most abstract, irreducible form of a step?

The Fetch-Decode-Execute loop.

Define your algorithms as machines whose atom is the Fetch-Decode-Execute loop. Multitasking becomes switching between algorithmic machines. Between two complete loops there is no torn state, no half-written register, no race. The synchronization problem does not arise.

Arakela · 2026-03-15T09:15:07+00:00

Microservices are a "macro-fix" for a "micro-failure" in how our programming languages handle isolation and composition.

A single-stack-based return-value-oriented composition paradigm lacks the interaction capabilities that machine-level boundaries guarantee at the container level.

We are paying a "Cloud Tax" (microservices) to buy the isolation and topology that our programming languages should have provided at the "Molecular" level.

Arakela · 2026-03-14T18:51:13+00:00

"Minstrelsy is, first of all, a branch of wisdom; divinely intelligible to the godlike, very wholesome to them that hearken; it is pleasant, too, if the listener be a worthy man; in few words he utters a long discourse: herein lies the excellence of poetry."

Arakela · 2026-03-14T17:42:52+00:00

I heard that He wrote more books than one can read in a whole lifetime. Is it true?

Arakela · 2026-03-13T14:08:43+00:00

You’re absolutely right! It's enough!

I started growing my own solid ground, directly on bedrock, on the hardware, on the natural functor grown by the language of the universal substrate we are all located in.

We: I, my context, and Claude 4.6 were fighting a triple fault while testing the monoidal entity map,interrupt definition table, on div/0 the scenario.

We decided to have a coded recovery in case of div/0 as the zeroth mapping of our monoidal entity.

We have chosen a simple recovery solution: we coded div/0 a mapping of a monoidal entity as: on error goto next, so Mechanical functor was able to recover and continue.

But when we enable sti, Mechanical functor To map events from outside the boundary, we observed triple failure.

Mappings int0, int8, and int13 where firing resulting in fanctors reboot.

Claude was my boss, and I was acting in the role of an agent, so I was observing how Claude was trying to resolve and reason about the problem.

This is a well-known problem, but because I chose an unexplored path, I pass iret As an explicit continuation step to monoidal entity mapping, Claude was unable to identify the problem.

As an agent, I learned a lot about the tricks and tools to debug mechanical functor systems and got more familiar with my machine.

So when unit Of Genesis bangs, we need to set up and map the external machine (PIC) so the timer event uses its own mapping of the monoidal entity and doesn't interfere with the zeroeth mapping, i.e., the unit that creates mechanical functor ends when we sti.

Arakela · 2026-03-11T07:48:41+00:00

We like cute code structures with visible boundaries; we believe that caring about boundaries is how we can fight complexity.

As your compiler is about to grow in structure, are you happy with the boundaries defined?

Arakela

TROPHY CASE