Self-Completing String

Self-Completing String — Grammar Edition

Rotating Subject + Predicate or flat random tokens. Halts via Stopword, Loop, Entropy.

Seed (optional)

Mode Random tokens Grammar: Subject + Predicate

Halting mode Any (eager) Two-of-three All three

Max steps

Stopwords

Loop head N

Loop tail M

Ignore function words True False

Entropy threshold

Entropy window

Min tokens before halting

Completion pressure (%)

Word banks (big lexicon by part of speech)

Comma or newline separated. Paste thousands.

Nouns (N)

Verbs (V)

Adjectives (Adj)

Adverbs (Adv)

Prepositions (Prep)of, in, into, within, without, through, across, under, over, between, before, after, beside, beyond, against, toward

Determiners (Det)the, a, an, this, that, these, those, each, every, no, some, any, my, your, our, their, his, her, its

Conjunctions (Conj)and, but, or, nor, yet, so, for

Proper Nouns (Proper)Nullion, Yodabund, Azazel, Beelzebub, Lumea, Moloch, Mammon, Murmur, Gradle, the Martyr

Formulas (rotating Subject + Predicate)

Subject formulas (one per line) Det Adj N Det N PN N of N Det N of PN Det Adj N of N

Predicate formulas (one per line) V Prep Det N COP Adj V Det N V Prep PN V V Adv V Prep Det Adj N COP N V Det Adj N

steps0 unique0 ratio0.00 stateidle press0%

Copied

Autocatalytic Grammar

Autocatalytic Grammars

Rules generate new rules during derivation. The grammar evolves while you generate text.

Output

Tip: Generate runs a full derivation from the start symbol and lets the grammar evolve as it fires.

Live Grammar

Format: Nonterminal -> production | production. Terminals in quotes, nonterminals bare.

Advanced Settings

Seed (blank = random)

Max Steps per Run

Autocatalysis Rate

Termination Damping

Start Symbol

Catalyst Target Nonterminals (comma)

Starter Grammar (Editable)

# Initial seed: minimal - will grow itself. S -> A B A -> "hunger" | "faith" | "silence" | "salt" | "prayer" B -> C | D C -> "descends" | "circles" | "abides" D -> "loosens" | "burns" | "returns"

Lexicon

river, stone, ember, light, shadow, vow, grain, breath, ash, ladder, mirror, gate, thread, hunger, faith, silence, salt, prayer, dusk, tongue, sleep, thunder, root, wing, seed, wheel, debt, chain, desert, psalm

Runtime Stats

lexicon: 0 rules: 0 firings: 0 spawned: 0 mutations: 0

Autocatalytic Grammars - How it works

Autocatalytic Grammars treat a context free grammar as a living system. As the text is derived, the rules that fire can synthesize new rules and graft them back into the grammar in real time.

Basic usage

• Generate builds a complete sentence or line starting from the start symbol (default S) and allows the grammar to mutate as it runs.
• Starter Grammar is editable. Change it and click Load Starter to reset the live grammar.
• Lexicon is the pool of words used when new rules are synthesized.
• Runtime Stats show how many rules you have, how often they fire, and how many new ones have been spawned.

Autocatalytic loop

• Firing: The engine rewrites the leftmost nonterminal with one of its productions.
• Catalysis: With probability set by Autocatalysis Rate, the fired rule creates a new production.
• Grafting: The new production is inserted into a target nonterminal, immediately changing the grammar.
• Damping: As steps accumulate, the engine slowly prefers more terminal heavy productions to help runs terminate.

Parameters

• Seed: Fix this for reproducible runs. Leave blank for fresh randomness.
• Max Steps per Run: Upper bound on how many derivation steps a single Generate call may take.
• Autocatalysis Rate: Higher values mean more new rules and faster drift in the grammar.
• Termination Damping: Higher values bias the system toward stopping sooner.
• Targets: A comma separated list of nonterminals that will receive most of the new productions.

Exporting to RPG

Use the Export Grammar button to open a popup containing the current grammar in RPG style (LHS -> RHS | RHS). You can copy that text and paste it directly into your Recursive Production Grammar (RPG) engine.

This page is Blogger safe: no external libraries, no network calls. Everything runs in the browser.

Exported Grammar (RPG Format)

Copy this context free grammar directly into your Recursive Production Grammar (RPG) engine.

Open RPG (Schrodinger Poetry)

Nonsense Poem Generator

Nonsense Poem Generator (CC + V + CC)

Lines

Words/line (min)

Words/line (max)

Casing
lowercase Title UPPERCASE

phonotactics-lite couplet rhyme punctuation

Poem

Settings — edit clusters & vowels (optional)

Comma/space separated lists. With phonotactics-lite on, “ng” is coda-only, onsets avoid vowel-final clusters, and codas avoid vowel-initial clusters.

Onsets

Vowels

Codas

Word Generator

Consonant-Cluster Word Generator (CC + V + CC)

lowercase Title UPPERCASE phonotactics-lite

Pattern: Onset + Vowel + Coda. Click the word to copy • Press Space to generate • Use Speak to hear it.

Settings — edit clusters & vowels (optional)

Comma/space separated. You can add digraphs like ai, ea, oo. “ng” is coda-only when phonotactics-lite is on.

Onset clusters (beginnings)

Vowels (nucleus)

Coda clusters (endings)

Syntax Mandala

Reflexive Grammar Visualizer — draws its own parse tree.

Preset English Mini Pantheon Mini Brackets Custom

Use | for alternatives.

Start Steps

Ready

Speed Cap Seed

Each | is random; add a seed for reproducible runs.

About — Syntax Mandala

Generates sentences from a context-free grammar and draws their parse as a radial mandala.

Neural Grammar Distiller

Neural Grammar Distiller - Recovered Scripture

Hard-coded Pantheon corpus -> tiny recurrent model -> PMI chunking -> PCFG -> scripture.

Options (tuck away)

Embed dim
Hidden EMA alpha
Epochs
LR
PMI threshold
Min freq (pair)
Max rule len
Samples

idle

-

rules: -

perplexity: -

Recovered RulesPCFG

Recovered ScriptureS -> terminals

Debug / Logs

What this does

---

1. Tiny recurrent context: embeddings + exponential moving context (alpha) trained to predict next word.
2. Structure signals: token surprisal & PMI -> likely constituents and boundaries.
3. Induction: greedy chunking to X1, X2... then count expansions -> PCFG.
4. Generation: sample S to produce recovered scripture.

Context Sensitive Grammar

Entanglement Engine Context Sensitive Grammar

Example: Entangle: AB → A x B Classic: aⁿ bⁿ cⁿ (Type-1) Mirror: w → w w (toy) — Custom —

Top-down · Blogger-safe · single file

Grammar Rules (one per line), format LHS -> RHS. Use | for alternatives.

Options (steps & speed)

Max Steps

Speed (ms)

Ready.

Outputstep 0

len 1

Legend: ⟨S⟩ start · → rewrite · ∅ epsilon

Leftmost single-site rewrite (deterministic)

Tip: Context sensitivity comes from multi-token LHS (e.g., A B -> A x B). Use a preset and press Run.

About: Entanglement Engine

A compact emulator for Type-1, context-sensitive rewriting. This Simple Mode hides advanced controls so the poem is easy to run on Blogger.

Deterministic run: applies the leftmost applicable rule once per step. “Run” repeats until Max Steps or no rule applies.

Scripting Language — Quick Guide

1) Tokens

• Input/output are space-separated tokens: e.g., A B x. Upper/lowercase have no special behavior.
• The engine starts from the preset’s start string (shown in each example).

2) Rule Syntax

LHS -> RHS

• One rule per line. The arrow is a literal ->.
• Alternatives: separate multiple RHS options with | (each option is a separate rule).
• Epsilon (empty): use a blank RHS or aliases ∅, epsilon, eps, ε to delete the LHS.
• Comments: anything after ; or // on a line is ignored.

3) Context Sensitivity

The LHS may be multiple tokens. A rule matches only when the entire LHS sequence occurs, so rewrites can depend on neighbors.

A B -> A x B
A x B -> A x x B

“Insert x between A and B” only triggers when A is immediately followed by B.

4) Execution Model

• Step: apply one rewrite at the leftmost match; then print the string.
• Run: repeat Step until Max Steps or no rules apply.
• Deterministic: if multiple rules match at the same position, the earlier rule (higher in the list) fires.

5) Mini Cheat-Sheet

# basic form
A -> x y z

# multi-token LHS (context required)
A B -> A x B

# alternatives
S -> A S A | B S B | A A | B B

# epsilon (delete)
C B ->    ; removes the sequence "C B"

# comments
A B -> A x B   ; insert x between A and B

6) Tips

• For strict Type-1 experiments, avoid contracting rules (don’t make RHS shorter than LHS).
• Put more specific rules earlier if they compete with general ones.
• Use short tokens for structural symbols (e.g., A, B, x), and words for terminal text if you like (AND, light, debt).