Oragami

Oragami is a recursive heap language defined over 1802 natural-number cells. Cells 0–16 form a ternary prefix; cells 17–1801 form the heap. The prefix selects an Aesthetic Function Graph (AFG). A descending ray from cell 1802 writes a ternary affix. Prefix and affix rewrite each other under primitive recursion.

Two constants define the recursion:

   oxfoi = 0xffffffff00000001
   tsrf  = Tupper’s self-referential formula

Memory Model

An Oragami configuration is a vector H of 1802 non-negative integers.

• Prefix cells: 1-17
• Heap cells: 17–1801
• The prefix determines the active AFG.
• The affix modifies the next prefix via carrying into 0 of the next graph.

Recursion

Oragami uses two primitive-recursive rays:

• A prefix ray from 0 → oxfoi
• An affix ray from 1802 → tsrf

The prefix ray reads the ternary prefix:

   T(i) = H(i) mod 3

The affix ray writes a ternary affix A into the carry structure. Because the affix is primitive-recursive, A(0) may prefix the next prefix, and that prefix may prefix the next, enabling self-modifying recursion.

tsrf and the Register Lattice

The integer encoded by tsrf is interpreted as the effective oxfoi-value for any register whose magnitude exceeds oxfoi:

   if H(i) > oxfoi then oxfoi_eff(i) := tsrf_integer

This creates a two-level evaluation scheme:

1. Registers ≤ oxfoi evaluate under true oxfoi. 2. Registers > oxfoi evaluate under tsrf-derived oxfoi_eff.

This induces a lattice of fixed points in the lower register.

Symbolic Fixed-Point Encoding

Let F be the set of fixed points reachable under the lower-register semantics. Implementations may assign symbolic interpretations:

   f ∈ F  ↦  σ

where σ is a symbol or word.

Some ternary prefixes cycle thousands of times before stabilizing at a fixed point f. When this occurs, the affix recursion writes the corresponding symbol σ into the heap. In this way, Oragami can emit words such as “HELLO WORLD” purely through recursive fixed-point dynamics.

The −1 Operator

The operator −1 acts on words as a hypergraph constructor. Given a word w, −1(w) produces a labeled hypergraph whose labels induce:

• a class structure (equivalence on positions), and
• a group action (automorphisms of the hypergraph).

This structure may rewrite the next prefix or affix.

Aesthetic Function Graph (AFG)

The AFG is a 17×106 grid derived from the ternary prefix. It determines how carry propagates. The AFG is the only visible structure of the program.

Hello World

A program is considered “Hello World” if its induced AFG, drawn as a 17×106 grid, contains the literal phrase:

   HELLO WORLD

The phrase may appear anywhere in the grid.*

Note: AFGs that visibly contain letters (such as “HELLO WORLD”) are a special case. In general, an AFG is simply the 17×106 aesthetic relation graph selected by the ternary prefix. Most AFGs contain no recognizable symbols at all.

Symbolic AFGs arise only when a ternary prefix enters a long recursive orbit and eventually stabilizes at a fixed point whose interpretation has been assigned a symbolic value. The visible letters are therefore not drawn directly; they are the geometric shadow of a fixed point in the lower-register lattice.

Thus, while Oragami programs *may* produce AFGs containing text, this is an emergent phenomenon rather than a primary feature of the language.

Computational Class

Oragami is believed to be Turing-complete. The language supports unbounded natural-number growth in its 1802-cell heap, self-modifying ternary prefix/affix recursion, and a fixed-point lattice capable of encoding symbolic values. The prefix recursion can simulate arbitrary state transitions, while the heap and carry structure provide unbounded storage.

Because the −1 operator induces a group action on words, Oragami can implement controlled rewriting systems. Combined with tsrf-folding and the ability to reach symbolic fixed points, these mechanisms allow Oragami to emulate a universal register machine or cyclic tag system.

No formal proof is known, but the components required for universality are present: unbounded memory, conditional branching via prefix cycles, and self-modifying recursion.

Program input

Oragami input is best described as Bags of Rubik's cube algorithms, which are defined in relation to the folds of the oragami you wish to carry. It is therefore described as sets of permutations on a Rubik's cube, as one folds an Oragami graph.

Because Bag can express algebraic primitives as symbolic rewrite rules, it can be used on the AFG to define Rubik’s‑cube generators, commutators, and move sequences, allowing Oragami programs to take cube expressions as direct Bag input in addition to defining Bag syntax in Oragami.