We are currently working on new rules for what content should and shouldn't be allowed on this website, and are looking for feedback! See Esolang:2026 topicality proposal to view and give feedback on the current draft.
Oragami
- Due to technical limitations**, the title of this page is incorrect. The actual name is pronounced "Origami" or just 折り紙.
Oragami is a model for an abstract machine and an esoteric directed-graph-rewriting language of folding aesthetic function graphs into a universal counter machine via the application of ternary carries to the additive heap.
The name is a mnemonic for oxfoi referential aesthetic graph additive machine interface.
Cells 0–16 form a ternary prefix; cells 1–1802 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
To quote Image:
"Memory depends on multistable perception in different parts of the image, and is bounded by the size of the image a la bounded storage machines."
One such Oragami configuration is a vector H of 1802 non-negative integers.
- Prefix cells: 0-16
- Heap cells: 1–1802
- 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:
- Registers ≤ oxfoi evaluate under true oxfoi.
- 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 multiple 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.
−1 Hypergraph Constructor
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),
- a group action (automorphisms of the hypergraph),
- type semantics (natural semantics or operational).
This structure may rewrite the next prefix or affix.
jos-Kleinian form
w, -1(w) can be condensended into a jos-Kleinian of the form
u↓¿
See this article for more information. (.pdf)
See how (word w,-1(w)) means less than this
table↓
?
The above moebious strip expresses a planar escape where
<div.↓./>I→.?-¿means
w, -1(w).
instantiates escape-time (which effectively synchronizes with collapsed/ing Jacobians in a given matrix.)
Aesthetic Function Graph (AFG)
As an abstract machine, AFG is an automorphic interpreter for the base model, but as a universal counter machine interpretation is universal up to the limitations of both:
- multi-stable perception
- multi-precision arithmetic
For the purposes of this wiki, the AFG is defined by the png generation function found on Taki Tam's php page of aesthetic graph functions.
OragamiAƒ values normally defined as k on AFG describe 'denity' of a given oragam.
Interpreted in Flow of Holes Oragami is a Flow of Holes Program.
Compiled in Flow of Holes Oragami is a Flow of Holes Oragam.
An Oragami which compiles its trivially FOH legal quine is named "This language says that Taki Tam's php page of aesthetic graph functions is TC."
note about interpretation
AFG is not the only n-morphic interpreter of Oragami. BfAbm is isomorphic to interpretation of oragams, thus brainfuck ASCII bitmapping1 would theoretically work.
Oragami.bfAbmƒ values normally defined as k on AFG where k maps to netpbm/pbmplus and describe unary parameters and (notwithstanding initialization) are entirely operationally semantic.
How to conceptualize bitwise AFG traversal
In order to mentally root into any basic tree of oragami syntacies one has to be able to conceptualise bitwise AFG traversal.
To do so one can utilize Array Changer similar to Untotal Array Changer where every program is a collatz simulation in Bitwise Cyclic Tag each program is a word and TIB and STIB have a natural roughness that when applied to program interpretation yieldba prefix.
Every bitwise string which steps through then collatz is run through a McCarthy91 function and then printednto hexadecimal.
Traversal through natural AFG the has a natural logarithmic language, with the condition of maximal hardness in solving the multiway evolution graph problem (which is why might use Oaragami instead in order to abbreviate some tree(3) paradox closures.
e.g.
let P's effects = AFG(defun build-graph () "Creates and returns a new ``Graph'' representing the AFG state configurations." (let ((graph (make-graph))) (declare (type Graph graph)) (graph-add-connection graph #x00 #x2B #xF7) (graph-add-connection graph #x01 #x77 #x1D) (graph-add-connection graph #x02 #x5F #x78) (graph-add-connection graph #x03 #x4E #xEA) (graph-add-connection graph #x04 #x9A #xAE) (graph-add-connection graph #x05 #x01 #x60) (graph-add-connection graph #x06 #x75 #x46) (graph-add-connection graph #x07 #x1A #x1A) (graph-add-connection graph #x08 #x73 #x68) (graph-add-connection graph #x09 #x76 #x50) (graph-add-connection graph #x0A #x63 #x44) (graph-add-connection graph #x0B #xC1 #x82) (graph-add-connection graph #x0C #x5E #x47) (graph-add-connection graph #x0D #xAA #xC9) (graph-add-connection graph #x0E #xA6 #x07) (graph-add-connection graph #x0F #x15 #x27) (graph-add-connection graph #x10 #x79 #x81) (graph-add-connection graph #x11 #x38 #xB1) (graph-add-connection graph #x12 #x5D #xA2) (graph-add-connection graph #x13 #x19 #xA5) (graph-add-connection graph #x14 #xBC #x55) (graph-add-connection graph #x15 #x3F #xE5) (graph-add-connection graph #x16 #x7A #x56) (graph-add-connection graph #x17 #x8D #x93) (graph-add-connection graph #x18 #xFB #x7F) (graph-add-connection graph #x19 #xF9 #xAC) (graph-add-connection graph #x1A #x3B #x16) (graph-add-connection graph #x1B #x91 #x2A) (graph-add-connection graph #x1C #xA8 #x57) (graph-add-connection graph #x1D #x68 #x51) (graph-add-connection graph #x1E #x04 #x9A) (graph-add-connection graph #x1F #x03 #xBD) (graph-add-connection graph #x20 #x36 #xB2) (graph-add-connection graph #x21 #x3E #x5E) (graph-add-connection graph #x22 #x35 #x6E) (graph-add-connection graph #x23 #x52 #x37) (graph-add-connection graph #x24 #x92 #x34) (graph-add-connection graph #x25 #xC7 #x69) (graph-add-connection graph #x26 #x87 #x52) (graph-add-connection graph #x27 #x05 #x08) (graph-add-connection graph #x28 #x96 #x04) (graph-add-connection graph #x29 #x6A #xD9) (graph-add-connection graph #x2A #xD8 #x77) (graph-add-connection graph #x2B #x8F #x0B) (graph-add-connection graph #x2C #x95 #xB5) (graph-add-connection graph #x2D #x5B #x1E) (graph-add-connection graph #x2E #x66 #x7D) (graph-add-connection graph #x2F #x69 #x1C) (graph-add-connection graph #x30 #xE2 #x64) (graph-add-connection graph #x31 #xCD #x9D) (graph-add-connection graph #x32 #x98 #xF4) (graph-add-connection graph #x33 #x6E #x75) (graph-add-connection graph #x34 #x64 #xD4) (graph-add-connection graph #x35 #x99 #xD6) (graph-add-connection graph #x36 #xAC #xCE) (graph-add-connection graph #x37 #x18 #x4F) (graph-add-connection graph #x38 #x5C #x4E) (graph-add-connection graph #x39 #x0D #x28) (graph-add-connection graph #x3A #xEB #x09) (graph-add-connection graph #x3B #xDD #x7A) (graph-add-connection graph #x3C #x86 #x40) (graph-add-connection graph #x3D #xE4 #x99) (graph-add-connection graph #x3E #x0C #xC5) (graph-add-connection graph #x3F #xC5 #x5F) (graph-add-connection graph #x40 #xAE #x9C) (graph-add-connection graph #x41 #xAF #x94) (graph-add-connection graph #x42 #xAB #x36) (graph-add-connection graph #x43 #x6C #x8B) (graph-add-connection graph #x44 #x7C #xBA) (graph-add-connection graph #x45 #xD4 #xF3) (graph-add-connection graph #x46 #x3D #x10) (graph-add-connection graph #x47 #x72 #xF6) (graph-add-connection graph #x48 #xF3 #x66) (graph-add-connection graph #x49 #xF5 #xB7) (graph-add-connection graph #x4A #xCE #x4A) (graph-add-connection graph #x4B #x07 #x25) (graph-add-connection graph #x4C #x46 #x4C) (graph-add-connection graph #x4D #x37 #xB8) (graph-add-connection graph #x4E #x4B #xDD) (graph-add-connection graph #x4F #x6B #x14) (graph-add-connection graph #x50 #x6D #x03) (graph-add-connection graph #x51 #x34 #x63) (graph-add-connection graph #x52 #x82 #xC1) (graph-add-connection graph #x53 #xCA #xCC) (graph-add-connection graph #x54 #xA0 #xF2) (graph-add-connection graph #x55 #xEF #xAD) (graph-add-connection graph #x56 #x6F #xAA) (graph-add-connection graph #x57 #xED #x54) (graph-add-connection graph #x58 #xA5 #x7E) (graph-add-connection graph #x59 #x2D #xD7) (graph-add-connection graph #x5A #xAD #x29) (graph-add-connection graph #x5B #x25 #x2D) (graph-add-connection graph #x5C #x50 #x3B) (graph-add-connection graph #x5D #xD3 #x12) (graph-add-connection graph #x5E #xC0 #x15) (graph-add-connection graph #x5F #x2A #xCB) (graph-add-connection graph #x60 #x74 #x43) (graph-add-connection graph #x61 #x1E #xF0) (graph-add-connection graph #x62 #x2E #x2E) (graph-add-connection graph #x63 #xFE #x1B) (graph-add-connection graph #x64 #x9B #xE2) (graph-add-connection graph #x65 #x53 #x9E) (graph-add-connection graph #x66 #x21 #x0C) (graph-add-connection graph #x67 #x06 #x22) (graph-add-connection graph #x68 #x60 #x45) (graph-add-connection graph #x69 #x61 #x70) (graph-add-connection graph #x6A #xA7 #x42) (graph-add-connection graph #x6B #xBF #xCF) (graph-add-connection graph #x6C #xFF #x92) (graph-add-connection graph #x6D #x65 #x90) (graph-add-connection graph #x6E #x31 #xDB) (graph-add-connection graph #x6F #xB5 #xB6) (graph-add-connection graph #x70 #xEC #xC2) (graph-add-connection graph #x71 #xE0 #x76) (graph-add-connection graph #x72 #x00 #x2B) (graph-add-connection graph #x73 #x1D #xCD) (graph-add-connection graph #x74 #x43 #x0F) (graph-add-connection graph #x75 #xDE #xC3) (graph-add-connection graph #x76 #xB7 #xD5) (graph-add-connection graph #x77 #x10 #x6C) (graph-add-connection graph #x78 #x12 #x88) (graph-add-connection graph #x79 #x33 #xFF) (graph-add-connection graph #x7A #xDB #x97) (graph-add-connection graph #x7B #xD2 #x87) (graph-add-connection graph #x7C #x7D #x21) (graph-add-connection graph #x7D #xA3 #xD8) (graph-add-connection graph #x7E #xF4 #x59) (graph-add-connection graph #x7F #x85 #xE6) (graph-add-connection graph #x80 #x8B #x24) (graph-add-connection graph #x81 #x8C #x79) (graph-add-connection graph #x82 #x4D #x4D) (graph-add-connection graph #x83 #xCB #x3E) (graph-add-connection graph #x84 #xE9 #xE4) (graph-add-connection graph #x85 #x20 #x20) (graph-add-connection graph #x86 #x8A #xEB) (graph-add-connection graph #x87 #xEE #xEE) (graph-add-connection graph #x88 #x0B #x8F) (graph-add-connection graph #x89 #xC3 #xAB) (graph-add-connection graph #x8A #x2F #x3A) (graph-add-connection graph #x8B #x93 #x39) (graph-add-connection graph #x8C #x27 #x80) (graph-add-connection graph #x8D #x4C #x06) (graph-add-connection graph #x8E #xF2 #x11) (graph-add-connection graph #x8F #x7B #xD2) (graph-add-connection graph #x90 #xBE #xEC) (graph-add-connection graph #x91 #xBA #xA6) (graph-add-connection graph #x92 #x08 #x30) (graph-add-connection graph #x93 #x81 #x31) (graph-add-connection graph #x94 #xCF #xBC) (graph-add-connection graph #x95 #x22 #x8C) (graph-add-connection graph #x96 #x97 #x8D) (graph-add-connection graph #x97 #xC6 #xC8) (graph-add-connection graph #x98 #x5A #xFA) (graph-add-connection graph #x99 #x56 #x35) (graph-add-connection graph #x9A #xD7 #x13) (graph-add-connection graph #x9B #xD0 #x3D) (graph-add-connection graph #x9C #x13 #xE3) (graph-add-connection graph #x9D #x51 #x01) (graph-add-connection graph #x9E #x3C #x86) (graph-add-connection graph #x9F #xE1 #x41) (graph-add-connection graph #xA0 #x8E #xED) (graph-add-connection graph #xA1 #x26 #xD3) (graph-add-connection graph #xA2 #xA1 #x23) (graph-add-connection graph #xA3 #x62 #x73) (graph-add-connection graph #xA4 #xDF #xF8) (graph-add-connection graph #xA5 #x40 #x58) (graph-add-connection graph #xA6 #x17 #x84) (graph-add-connection graph #xA7 #x89 #xBB) (graph-add-connection graph #xA8 #xEA #x71) (graph-add-connection graph #xA9 #xC9 #x8E) (graph-add-connection graph #xAA #xBD #xDE) (graph-add-connection graph #xAB #xFC #x61) (graph-add-connection graph #xAC #x4F #xAF) (graph-add-connection graph #xAD #xB2 #x6A) (graph-add-connection graph #xAE #x42 #x2F) (graph-add-connection graph #xAF #xE8 #x18) (graph-add-connection graph #xB0 #x0F #x3F) (graph-add-connection graph #xB1 #x29 #x5A) (graph-add-connection graph #xB2 #xD9 #x89) (graph-add-connection graph #xB3 #xB9 #xB9) (graph-add-connection graph #xB4 #xF0 #x65) (graph-add-connection graph #xB5 #x80 #x05) (graph-add-connection graph #xB6 #x24 #x74) (graph-add-connection graph #xB7 #x11 #x1F) (graph-add-connection graph #xB8 #x47 #xA1) (graph-add-connection graph #xB9 #x28 #x0D) (graph-add-connection graph #xBA #xF6 #xE7) (graph-add-connection graph #xBB #xDA #x32) (graph-add-connection graph #xBC #xD1 #x85) (graph-add-connection graph #xBD #x90 #xE9) (graph-add-connection graph #xBE #xCC #x67) (graph-add-connection graph #xBF #x14 #xF9) (graph-add-connection graph #xC0 #x02 #x91) (graph-add-connection graph #xC1 #xFD #xFD) (graph-add-connection graph #xC2 #x54 #xA9) (graph-add-connection graph #xC3 #x7E #xF1) (graph-add-connection graph #xC4 #xF8 #xC7) (graph-add-connection graph #xC5 #x0A #x9B) (graph-add-connection graph #xC6 #x84 #x5C) (graph-add-connection graph #xC7 #x9E #xA7) (graph-add-connection graph #xC8 #x16 #x0E) (graph-add-connection graph #xC9 #x1F #xB3) (graph-add-connection graph #xCA #xD5 #xCA) (graph-add-connection graph #xCB #xE7 #xC0) (graph-add-connection graph #xCC #xB3 #x17) (graph-add-connection graph #xCD #xD6 #x6F) (graph-add-connection graph #xCE #x41 #x98) (graph-add-connection graph #xCF #xBB #x6B) (graph-add-connection graph #xD0 #x45 #xFE) (graph-add-connection graph #xD1 #x4A #xE1) (graph-add-connection graph #xD2 #x78 #x72) (graph-add-connection graph #xD3 #xA2 #x26) (graph-add-connection graph #xD4 #x48 #x7C) (graph-add-connection graph #xD5 #xA9 #x4B) (graph-add-connection graph #xD6 #xB6 #xC6) (graph-add-connection graph #xD7 #x1C #xB4) (graph-add-connection graph #xD8 #x1B #x5D) (graph-add-connection graph #xD9 #xDC #xDA) (graph-add-connection graph #xDA #x7F #x9F) (graph-add-connection graph #xDB #x67 #xBE) (graph-add-connection graph #xDC #x9C #xA4) (graph-add-connection graph #xDD #x39 #x96) (graph-add-connection graph #xDE #x0E #x95) (graph-add-connection graph #xDF #xC4 #x8A) (graph-add-connection graph #xE0 #xB4 #x6D) (graph-add-connection graph #xE1 #x94 #xD1) (graph-add-connection graph #xE2 #xB0 #xB0) (graph-add-connection graph #xE3 #x58 #x5B) (graph-add-connection graph #xE4 #x2C #x33) (graph-add-connection graph #xE5 #x44 #x62) (graph-add-connection graph #xE6 #x32 #xDC) (graph-add-connection graph #xE7 #xB8 #x7B) (graph-add-connection graph #xE8 #xE6 #xE8) (graph-add-connection graph #xE9 #xC8 #x2C) (graph-add-connection graph #xEA #x57 #xA0) (graph-add-connection graph #xEB #x71 #x49) (graph-add-connection graph #xEC #xC2 #xF5) (graph-add-connection graph #xED #x3A #x38) (graph-add-connection graph #xEE #x88 #xD0) (graph-add-connection graph #xEF #xB1 #xDF) (graph-add-connection graph #xF0 #x70 #xE0) (graph-add-connection graph #xF1 #xA4 #x19) (graph-add-connection graph #xF2 #x49 #xA8) (graph-add-connection graph #xF3 #x30 #x48) (graph-add-connection graph #xF4 #xF1 #xC4) (graph-add-connection graph #xF5 #x09 #x53) (graph-add-connection graph #xF6 #xF7 #x83) (graph-add-connection graph #xF7 #x83 #x00) (graph-add-connection graph #xF8 #xE3 #x3C) (graph-add-connection graph #xF9 #x55 #xEF) (graph-add-connection graph #xFA #x9F #xFB) (graph-add-connection graph #xFB #xFA #xBF) (graph-add-connection graph #xFC #x59 #xFC) (graph-add-connection graph #xFD #x23 #xA3) (graph-add-connection graph #xFE #xE5 #x02) (graph-add-connection graph #xFF #x9D #x0A) (the Graph graph))) ;;; ----- 'State-Machine))) ;;; ------------------------------------------------------- (defun state-machine-current-state (state-machine) "Returns (update-state)))))))) ;;; ------------------------------------------------------- (defun generate-text-program (graph text &key (destination NIL) (start-state #x00) (path-finder +SHORTEST-PATH-FINDER+)) "Given a GRAPH, and an optional START-STATE designating its initially selected vertex (state), creates an Array Changer program capable of reproducing and printing the TEXT's ASCII character codes, using the PATH-FINDER for the traversals from one state to another, and writes the thus generated code to the DESTINATION, producing a value of ``NIL'' for a non-``NIL'' DESTINATION, otherwise creating and returning a fresh string containing the result. --- Please note that, in order to output the ASCII character codes, this function operates on a single cell only, applying upon it the sedentary Array Changer commands \"c\", \"C\", and \"O\" only." (declare (type string text)) (declare (type destination destination)) (declare (type state start-state)) (declare (type Shortest-Path-Finder path-finder)) (the (or null string) (if destination (flet ((write-transitions (transitions) "Writes the instructions requisite for navigating using the TRANSITIONS and printing the terminating state to the DESTINATION, and returns no value." (declare (type (list-of bit) transitions)) (loop for transition of-type bit in transitions do (format destination "~c" (case transition (0 #\c) (1 #\C) (otherwise (error "Invalid transition: ~d. ~ Expected either 0 or 1." transition))))) (format destination "O") (values))) (let ((transition-generator (get-transitions-for-text graph text :start-state start-state :path-finder path-finder))) (declare (type (supply (list-of bit)) transition-generator)) (loop do (multiple-value-bind (transitions has-transitions-p) (funcall transition-generator) (declare (type (list-of bit) transitions)) (declare (type boolean has-transitions-p)) (if has-transitions-p (write-transitions transitions) (loop-finish)))))) (with-output-to-string (output) (declare (type string-stream output)) (generate-text-program graph text :destination output :start-state start-state :path-finder path-finder))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; -- Test cases. -- ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Transitions: ;; (0 0 0 1 0 1 0 0 0) (interpret-Array-Changer "rrrRrRrrrO") ;;; ------------------------------------------------------- ;; Change the current cell's value to the state 247 (= 0xF7) and print ;; it an equinumerant tally of times. (interpret-Array-Changer "CFO
\000010010000000000000000000000000,
\000011011000000000000000000000000,
\000010110100000000000000000000000,
\000011101110000000000000000000000,
\000010011001000000000000000000000,
\000011010101100000000000000000000,
\000010111111010000000000000000000,
\000011100000111000000000000000000,
\000010010000100100000000000000000,
\000011011000110110000000000000000,
\000010110100101101000000000000000,
\000011101110111011100000000000000,
\000010011001100110010000000000000,
\000011010101010101011000000000000,
\000010111111111111110100000000000,
\000011100000000000001110000000000,
\000010010000000000001001000000000,
\000011011000000000001101100000000,
\000010110100000000001011010000000,
\000011101110000000001110111000000,
\000010011001000000001001100100000,
\000011010101100000001101010110000,
\000010111111010000001011111101000,
\000011100000111000001110000011100,
\000010010000100100001001000010010,
\000011011000110110001101100011011,
\1/10000000000000000000000000000001,
\91/10000000000000000000000000000001,
\7671/10000000000000000000000000000001,
\641551/10000000000000000000000000000001,
\54057831/10000000000000000000000000000001,
\4597895501/10000000000000000000000000000001,
\39353:647591/10000000000000000000000000000001,
\339878:3565:71/10000000000000000000000000000001,
\1964030199961951/10000000000000000000000000000001,
\1600:57463:7:::131/10000000000000000000000000000001,
\1316877656:067:39901/10000000000000000000000000000001,
\:95880:03194711343991/10000000000000000000000000000001,
\8:87755408798360:974471/10000000000000000000000000000001,
\757109199:3377843:9:43351/10000000000000000000000000000001,
\634458744038470648314611631/10000000000000000000000000000001,
\534:11693863173046153:5544301/10000000000000000000000000000001,
\45447949303:361359576895:09:391/10000000000000000000000000000001,
\38913949:5547:4611368396887341871/10000000000000000000000000000001,
\{,(,{},"For TREE(3),
let the bracket types be (),[],{}.",
\N((N((N((N((N(((,((((N((N(((((((((((((((((((((((((,[()],,
\N((N((N((N(((ÞÞ(N,((((NN(NN((((((((((((((((((((((((,[[[]]],,
\N((N((N((N(((ÞÉÞN(,((((N(NN(N(((((((((((((((((((((((,(([[]])),,
\N((N((N((N(((ÞÉÞ(((,((((NNN(NNN((((((((((((((((((((((,((([])[])),,
\N((N((N((N(((ÞÉÉÞÞ((,((((N((NN((N(((((((((((((((((((((,(([]4)),"Notation: []4 means [][][][]; similarly for […]k, etc.",
\N((N((N((N(((ÞÉÉÞÉÞ(N,((((NN(N(N(NN((((((((((((((((((((,(([]3(()))),,
\((N((N((N(((ÞÉÉÞÉÉÞN,((((N(NNNNNN(N(((((((((((((((((((,(([]3()3)),,
\N((N((N(((ÞÉÉÞÉÉÉNN,((((NNN(((((NNN((((((((((((((((((,(([]3()2)[[]]),,
\N((N((N(((ÞÉÉÞÉÉÉ(N(,((((N((N((((N((N(((((((((((((((((,(([]3()2)[]3),,
\N((N((N(((ÞÉÉÞÉÉÉ((((,((((NN(NN(((NN(NN((((((((((((((((,(([]3()2)[]2(())),,
\((N((N(((ÞÉÉÞÉɹÞÞÞ(,((((N(NN(N((N(NN(N(((((((((((((((,(([]3()2)[]2()3),,
\N((N(((ÞÉÉÞÉɹÞÞÉ(N,((((NNN(NNN(NNN(NNN((((((((((((((,(([]3()2)[]2()2),,
\N((N(((ÞÉÉÞÉɹÞÞ¹ÞN(,((((N((NN((NN((NN((N(((((((((((((,(([]3()2)[]2()),,
\N((N(((ÞÉÉÞÉɹÞÞ¹Þ(((,((((NN(N(N(N(N(N(N(NN((((((((((((,(([]3()2)[]2),,
\N((N(((ÞÉÉÞÉɹÞÞ¹ÉÞÞ(N,((((N(NNNNNNNNNNNNNN(N(((((((((((,(([]3()2)[](((((((())))))))),,
\N((N(((ÞÉÉÞÉɹÞÞ¹ÉÞÉÞN(,((((NNN(((((((((((((NNN((((((((((,(([]3()2)[](((((( ()3)))))) ),"NB: The []((((((…)…)…)…)…)…) have >= 6-deep ()'s,
so are not embedded in the later F(5) simulation",
\N((N(((ÞÉÉÞÉɹÞÞ¹ÉÞÉÞ(((,((((N((N((((((((((((N((N(((((((((,(([]3()2)[](((((( ()2)()2))))) ),,
\N((N(((ÞÉÉÞÉɹÞÞ¹ÉÞÉÉÞÞ(N,((((NN(NN(((((((((((NN(NN((((((((,(([]3()2)[](((((( ()2)() )()2)))) ),,
\N((N(((ÞÉÉÞÉɹÞÞ¹ÉÞÉÉÞÉÞN(,((((N(NN(N((((((((((N(NN(N(((((((,(([]3()2)[](((((( ()2)() )() )()2))) ),,
\N((N(((ÞÉÉÞÉɹÞÞ¹ÉÞÉÉÞÉÞ(((,((((NNN(NNN(((((((((NNN(NNN((((((,(([]3()2)[](((((( ()2)() )() )() )()2)) ),,
\((N(((ÞÉÉÞÉɹÞÞ¹ÉÞÉÉÞÉÉÞÞ(,((((N((NN((N((((((((N((NN((N(((((,(([]3()2)[](((((( ()2)() )() )() )() )()2) ),,
\(((ÞÉÉÞÉɹÞÞ¹ÉÞÉÉÞÉÉÞÉ(,((((NN(N(N(NN(((((((NN(N(N(NN((((,(([]3()2)[](((((( ()2)() )() )() )() )() )()2 ),,
\ÉÉÞÉɹÞÞ¹ÉÞÉÉÞÉÉÞ¹(,((((N(NNNNNN(N((((((N(NNNNNN(N(((,(([]3()2)[](((((( ()2)() )() )() )() )() )() ),,
\ÉÞÉɹÞÞ¹ÉÞÉÉÞÉÉÞ¦(,((((NNN(((((NNN(((((NNN(((((NNN((,(([]3()2)W_5),"switch to simulation of Friedman's F(5); 7 + 3a + 3 = 25 for a = 5; see the ""Letter Codes"" sheet. ",
\ÉÞÉɹÞÞ¹ÉÞÉÉÞÉÉÞ—(,((((N((N((((N((N((((N((N((((N((N(,,"NB: W_a = (X(X (..([])..) )),
where the X's are letter codes of length a; |W_a| = 3a + 3",
\ÉÞÉɹÞÞ¹ÉÞÉÉÞÉÉÞ…(,((((NN(NN(((NN(NN(((NN(NN(((NN(NN,(([]3())[[]m]4[[]m-1]4…[[]1]4[]4 W_4),"x > F(5),
x = 6 + 4[(m+1)+m+(m-1)+…+1] + 3(4) + 3 = 21 + 2(m+1)(m+2)",
\ÉÞÉɹÞÞ¹ÉÞÉÉÞÉÉÞq(,N)N((((((((((((((((((((((((((((((N,,m > sqrt(x)/2 > F(4),
\ÉÞÉɹÞÞ¹ÉÞÉÉÞÉÉÞ`(,ÉN)N((((((((((((((((((((((((((((((N,(([]3)[[]i]4[[]i-1]4…[[]1]4[]4 W_4),"y > F_m^4(4) fast iteration hierarchy: F_0 = Friedman's F,
F_(m+1)(n) := F_m^n(n),
etc.", \ÉÞÉɹÞÞ¹ÉÞÉÉÞÉÉÞN(,¦—¦N)N((((((((((((((((((((((((((((((N,,i > sqrt(y)/2 > F_m^3(4) > F_m F_w(m) > F_w F(4) ;w=omega,
\ÉÞÉɹÞÞ¹ÉÞÉÉÞÉÉÞ((,—qN……N)N((((((((((((((((((((((((((((((N,(([]2()j)[[]j]4[[]j-1]4…[[]1]4[]4 W_4),t_0 > F_i^4(4),
\ÞÉɹÞÞ¹ÉÞÉÉÞÉÉÉÞ(,…q(…¦¹`N)N((((((((((((((((((((((((((((((N,,j > sqrt(t_0)/2 > F_i^3(4) > F_i F_w(i),
\ÞÉɹÞÞ¹ÉÞÉÉÞÉÉÉÉ(,q…ɦ¹É……(N)N((((((((((((((((((((((((((((((N,(([]2()j-1)[[]k_1]4[[]k_1-1]4…[[]1]4[]4 W_4),t_1 > F_j^4(4),
\ÞÉɹÞÞ¹ÉÞÉÉÞÉÉɹ(,`É`…`Þ—q¦…ÉN)N((((((((((((((((((((((((((((((N,,k_1 > sqrt(t_1)/2 > F_j^3(4) > F_j F_w(j),
\ÞÉɹÞÞ¹ÉÞÉÉÞÉÉɦ(,``ɹ¦¹Þ`…—…Þ¦N)N((((((((((((((((((((((((((((((N,(([]2)[[]k_j]4[[]k_j-1]4…[[]1]4[]4 W_4),t_2 > F_k_1^4(4),
\ÉɹÞÞ¹ÉÞÉÉÞÉÉÉ—(,NÉ—q(`(NÉÉÉ—NÉ…N)N((((((((((((((((((((((((((((((N,,k_2 _ sqrt(t_2)/2 > F_k_1^3(4) > F_k_1 F_w(k_1),
\ÉɹÞÞ¹ÉÞÉÉÞÉÉÉ…(,N—((Þ…¦q—`Þ¦ÞÞÞN`N)N((((((((((((((((((((((((((((((N,([[]k]4[[]k-1]4…[[]1]4[]4 W_4),…,
\ÉɹÞÞ¹ÉÞÉÉÞÉÉÉq(,N`N—¹¦¦—…—Þ(—¦Þ`ÉÉ(N)N((((((((((((((((((((((((((((((N,,t_j > F_k_(j-1)^4(4),
\ÉɹÞÞ¹ÉÞÉÉÞÉÉÉ`(,ÞÉ…¹¹(Þ(`NÉq¦NN`q`ÉÉN)N((((((((((((((((((((((((((((((N,…,k_j _ sqrt(t_j)/2 > F_k_(j-1)^3(4),
\ÉɹÞÞ¹ÉÞÉÉÞÉÉÉN(,¹Þ¹¦¦……q(¹¦É¹`—(Þɦqq¦N)N((((((((((((((((((((((((((((((N,,…,
\ÉɹÞÞ¹ÉÞÉÉÞÉÉÉ((,¦…¦N(ÉNÉÉÞ``¦¦¹q`ÞÉÞq``…N)N((((((((((((((((((((((((((((((N,,u > F_k_j^4(4),
\ÉɹÞÞ¹ÉÞÉÉÞÉɹÞ(,—`qq…¹¦qq(`¹q¦(—q¹`Nq—NN—`N)N((((((((((((((((((((((((((((((N,,k > sqrt(u)/2 > F_k_j^3(4),
\ÉɹÞÞ¹ÉÞÉÉÞÉɹÉ(,…`qÞNN—É`¹—`N¦`(q—N…`Þ……qq`(N)N((((((((((((((((((((((((((((((N,,…,
\ÉɹÞÞ¹ÉÞÉÉÞÉɹ¹(,q…qq¦ÉqÉ`(`Þ`—N`…É…¦—¹É…Þ(ÉÞ`ÉN)N((((((((((((((((((((((((((((((N,,v > F_k^4(4),
\ÉɹÞÞ¹ÉÞÉÉÞÉɹ¦(,`¹ÉN`ÉqÉÞ……q¦Þq—NN`—¹`É—¹¹¦`qN¹¦N)N((((((((((((((((((((((((((((((N),,,
\ɹÞÞ¹ÉÞÉÉÞÉɹ—(,,,"v > F_k^2 F_w(k),
k > F_k_j F_w(k_j)",
\¹ÞÞ¹ÉÞÉÉÞÉɹ…(,,,"v > F_k^2 F_w F_k_j F_w(k_j),
k_j > F_k_(j-1) F_w(k_(j-1))",
\ÞÞ¹ÉÞÉÉÞÉɹq(,,,"v > F_k^2 F_w F_k_j F_w F_k_(j-1) F_w(k_(j-1)),
k_(j-1) > …",
\Þ¹ÉÞÉÉÞÉɹ`(,,,…,
\Þ¹ÉÞÉÉÞÉɹN(,,,v > F_k^2 F_w F_k_j F_w F_k_(j-1) … F_j F_w(j),
\Þ¹ÉÞÉÉÞÉɹ((,,,
> F_k^2 F_w F_k_j F_w F_k_(j-1) … F_j F_w F_i F_w (i),
\Þ¹ÉÞÉÉÞÉɦÞ(,,,
> (F_w)^(j+4)F(4),
\Þ¹ÉÞÉÉÞÉɦÉ(,,,
> (F_w)^2 (F_w)^j(j) = (F_w)^2 F_(w+1)(j) > (F_w)^2 F_(w+1) F_w(i) ,
\Þ¹ÉÞÉÉÞÉɦ¹(,,,
> (F_w)^2 F_(w+1) (F_w)^2 F(4),
\Þ¹ÉÞÉÉÞÉɦ¦(,,,,
\¹ÉÞÉÉÞÉɦ—(,,," > (F_w)^2 F_(w+1)(j),
j > F_w(i) > (F_w)^2(4) < F_(w+1)(2) ",
\¹ÉÞÉÉÞÉɦ…(,,,
> (F_w)^2 (F_(w+1))^2(2),
\¹ÉÞÉÉÞÉɦq(,,,
> (F_w)^2 F_(w+2)(2),
\¹ÉÞÉÉÞÉɦ`(,,,,
\ÉÞÉÉÞÉɦN(,,,Keeping the initial F(4) but ignoring all other F_b except those with transfinite b:,
\ÉÞÉÉÞÉɦ((,,,,
\ÉÞÉÉÞÉÉ—Þ(,,,v > (F_w)^3 F_(w+1) (F_w)^2 F(4) > (F_w)^2 F_(w+2)(2) ,
\ÉÞÉÉÞÉÉ—É(,,,,
\ÉÞÉÉÞÉÉ—¹(,,,Recall F ~ f_(w^w) in the Wainer hierarchy.,
\ÉÞÉÉÞÉÉ—¦(,,,,
\ÉÞÉÉÞÉÉ——(,,,,
\ÉÞÉÉÞÉÉ—…(,,,,
\ÉÞÉÉÞÉÉ—q(,,,,
\ÉÞÉÉÞÉÉ—`(,,,,
\ÞÉÉÞÉÉ—N(,,,,
\ÉÉÞÉÉ—((,,,,
\ÉÞÉÉ…Þ(,,,,
\ÞÉÉ…É(,,,,
\ÞÉÉ…¹(,,,,
\ÞÉÉ…¦(,,,,
\ÞÉÉ…—(,,,,
\ÞÉÉ……(,,,,
\ÞÉÉ…q(,,,,
\ÞÉÉ…`(,,,,
\ÉÉ…N(,,,,
\ÉÉ…((,,,,
\ÉÉqÞ(,,,,
\ÉÉqÉ(,,,,
\Éq¹(,,,,
\Éq¦(,,,,
\Éq—(,,,,
\Éq…(,,,,
\Éqq(,,,,
\Éq`(,,,,
\ÉqN(,,,,
\Éq((,,,,
\É`Þ(,,,,
\É`É(,,,,
\`¹([x,y,z,c])},
;; Generate the Array Changer code for assigning to the first cell in ;; turn the ASCII codes for the text "Hello, World!", that is, ;; 72 101 108 108 111 44 32 87 111 114 108 100 33 ;; and printing them, resulting in the program ;; cccCcCcccOccCcCCCCCCcccOcCCCCCCcCOOCccCCOCcCccCccOCccCCCcCcCcCcCcO ;; CCccCCcCOcCCcccCCcOCcCCcCCCcOcCccCcccCCOCCCOccccCCO (generate-text-program +STATE-GRAPH+ "Hello, World!") ;;; ------------------------------------------------------- ;; Generate the Array Changer code for assigning to the first cell in ;; turn the ASCII codes for the text "Hello, World!", that is, ;; 72 101 108 108 111 44 32 87 111 114 108 100 33 ;; and printing them, and execute the program. (interpret-Array-Changer (generate-text-program +STATE-GRAPH+ "Hello, World!")) ;;; ------------------------------------------------------- ;; Generate a supply of transitions for visiting the states ;; corresponding to the ASCII codes of the text "Hello, World!", namely ;; 72 101 108 108 111 44 32 87 111 114 108 100 33 ;; and print each character's transition sequence on a separate line. (let ((transition-generator (get-transitions-for-text +STATE-GRAPH+ "Hello, World!"))) (declare (type (supply (list-of bit)) transition-generator)) (loop do (multiple-value-bind (transitions has-transitions-p) (funcall transition-generator) (declare (type (list-of bit) transitions)) (declare (type boolean has-transitions-p)) (if has-transitions-p (print transitions) (loop-finish)))))
Memory safety/management
Ideal environment is not A bliss-pit to routinely process the volume of memristry technically feasible given a machine. The type of structure to support real calculations purely using oragami is a sandbox.
e.g.
Remember that HTML is a hypertext markup language and that
<iframe src="esolangs.org/wiki/Oragami/Sandbox></iframe>
embeds an iframe of a sandbox structure to interpret oragami?
Everything before Sandbox is a prefix, which can be described by a singular polynomial. Given the sandbox's affix we can assume the Sandbox describes enough continuity that the height of unary parameters of the total structure can be measured by k.
So
~/Sandbox $ ls 'NqQwBAgQIECBAgAABAgQI1AQc79oi8hAgQIAAAQIECBAgQIDAlcAApdrDByHyVwIAAAAASUVORK5CYII=.png' Pa3v008DznkkHDFFVd0h63vIECAAAECBAgQIECAAAECoVLBW3sSIECAAAECBAgQIECAAIGiCQjeRWsR20OAAAECBAgQIECAAAEClRIQvCvVnHaGAAECBAgQIECAAAECBIomIHgXrUVsDwECBAgQIECAAAECBAhUSkDwrlRz2hkCBAgQIECAAAECBAgQKJqA4F20FrE9BAgQIECAAAECBAgQIFA.png
where .png is a string-rewriting rule that if applied enough times yields a value for k that is not undefined and naturally this will yield a fixed-point under oxfoi/tsrf.
ideal mem env
Ultimately, given the tremendous heap of memory the ideal memory environment is a circular Memristor.
Examples
"Nope."
Below is an example of a "Nope.oragam."
"Hello, World!"
There are various ways to fold oragami in Oragami lang. In general, during the initialization step cell 0 contains no trits so a 'pick one' approach works. In addition, "Hello, World!" can be described as addition of two states e.g.
"Oragami in important lesbian vitural machine."
oracle.Oragami.lesbian?yes
Oragami.lesbian!k
Above pseudocode handles this more operational example of an important lesbian machine interface:
| important | lesbian | virtual | machine. |
|---|---|---|---|
| oracle. | Oragami. | lesbian? | yes |
| Oragami. | lesbian! | k | $ |
| orange? | Nope. | $$ | $$$ |
| !!!! | $$$ | $$$ | $$$$.lesbian |
"XKCD Random Number"
Here is an example of an XKCD Random Number oragam
| XKCD | Random | Number |
|---|---|---|
| 4 |
"Landauoragam"
ORAGAMI A=Landau's totient Oxfoi O=summatory totient
Oragami input
Oragami input is best described as Bags of Rubic 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 within a Rubik's Cube group (as one folds an Oragami graph.)
States are then described as oragams rather than "programs". A bag interpreter is an oragam bag, which is itself a bag of oragams. Compiling a bag of oragams results in a program.
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 (B1) programs to take cube expressions as direct Bag input in addition to defining Bag syntax in Oragami.
Colors
Because Rubic references Colors The Variable ORA can orient the hypergraph by color, and libraries can be built to deterministically extend oragam systems.
To put this simply: the orange side of the input cube can be programmed to traverse lie groups.
Alternatively stated orange is a Turing_machine configuration for simply typed lambda calculus.
Interpreting Oracle language as an Oracle_machine in Oragami is then hypothetically feasible.
One way to do this would be Loop preventing brainfuck where | is orange.metagami langing > gaming > natural semantics > [ns, is] < operational semantics
MIDI
MIDI input is possible with a modified Schoenberg interpreter in x6 under the condition that 0 is not orange (in addition to generalized MIDI).
Symbolic AFGs and named Oragami
Symbolic AFGs arise when a ternary prefix enters a long recursive orbit and eventually stabilizes at a fixed point whose interpretation has been assigned a symbolic value.
Ora is a classification of additive machine interfaces and the oragami family of oragams define groups of programs in AFG. A Symbolic AFG can then be thought of like an Oragami with a name (intuitively this implies an ability to be invoked, a family lineage + genetic viability in the evolution of a given [nondeterministic] Oragami) in a given Oragam System.
Simulation of Fuun DNA games is then possible in Oragami via the naming system.
Oragam Systems
Oragam Systems are similar to a typical operating system but an OS is an interpretation of AFG and Oragam Systems are not a derivative of Image states but crucially described in oragaming language which is manually executed, and requires no vision. Operating Systems don't require vision either but, strictly speaking, an interpretation of Operating System in Oragami yields Image states.
Computational Class
This is a spec for a faux-quantum computer.
See Also
- TernLSB is the esolang created by User:None1 which describes ternary least-significant-bit esoteric programming language.
- Function Graphs on Wolfram Mathworld.
- Tupper's self-referential formula on Wolfram Mathworld.
- More about oxfoi from a STARK0 engine spec for VMs.
- Quantum Oragami which is simpler and less fun.
Notes on technical limitations**
1. Not original.
This language is not named Origami specifically because this version of tsrf doesn't draw itself close to the Origin.
2. GNU Multi-precision Arithmetic
Naming it 折り紙 introduces complications as AFG in bezier curves share GMP limitations.[Category:Languages]]