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.

Yggdraphyll

From Esolang
Jump to navigation Jump to search

Yggdraphyll (pronounced in-selfie) is an esolang by invented by User:Miui and influenced by User:Salpynx, A bliss-pit, and Grill Tag. Ainselfie-tag system is configured by two strings:

  1. S(seed)
  2. N(rule number)


Inselfie-tag both the seeds and rule indices describe some group of Johnson solids and characterize any generic tag system in the process. Guesses produced through selfie-tag sometimes expand other derivatives of genera tag while Yggdraphyll itsælf configures tag productions.

Configuring a tag language

  1. Given a configurable machine=GT/C=Constant:F=Factorial::G=Group/a CFG T
  • We can guess whether a configuration is a Thupit.
  • A group of guesses is tabled into a group table.

Group table

Thue(Guess) Johnson(¡Characteristic Factor[CF]!)
Catalan(°Characteristic Quotient [CQ]°)
  1. Thue is the identity of a grammatical element.
  2. A guess is composed thue-grammatically and placed on a table.
  3. Identity=x*y iff PEMDAS≈True<Grammar of element<Identity element.
  4. The order of operations decomposes when a guess evaluates to true and T≠t.
Production

process follows

  1. Each seed ¡ is sown and composed with the index n of the rule (e.g. a seed sown in timespace).
  2. Guesses grow into evaluations to yield products. If 🍇 is a guess then ¡ ∘ n = r where r is a product.
  • If the top row is unbroken, the ruliad of the evaluation process is ignored.
  • If rows>2 (with truthy wrapping) append r ∘ r (i.e. ! (Cofactorial)) to the rule number (indexed only when lines>2)
  • If the row 2 is also grammatically correct append r ∘ ¡ (i.e. n) to the production.

Tag expansion

The Yggdraphyll group table contains a subset of symbols that can directly implement Grill Tag using a pushdown automata PA(i.e. an appendage named Sinn)

  • Pushdown(P)
  • 10 (command): Use ! (J)
  • 11 (command): Use ° (C)
  • 0 (data): Use ::= (G)
  • Automate(A)

this yields Althunasennen

an example via Combinator Junk parlance is given

GT!<->SinnNS
S:1010101010101010101
N:0101010101
G:succ(0)
S : (N -> (N -> N) -> N -> N) -> (N -> N -> N) -> N -> N -> N
  church : N -> (N -> N) -> N -> N
  K : (N -> N) -> N -> N -> N
    succ

products

Dynamic productions are either thorny flowers (🌹) or viney fruit products (🍇/🍷) while any categorical thupits are either 🍯 or .999 grams of pure gold. A=Althun F=flower U=fruit A/B T=honey

(Thun, appendage)
Th ∧ Y B
F U T
A F F F F
U F U U
T F U T

golden products

To produce a golden product, the impurity needs to be removed. Golden products are seeds which lead to more solid guesses. To obtain a golden product a diagonal grill tag must produce its cardinal seed (see appendage). This can be solved with the Tower of Hanoi.

a pseudo rust codel is given 

fn gold(n: i32, source: char, destination: char, auxiliary: char) {
    if n == 1 {
        return;
    }

    gold(n - 1, source, auxiliary, destination);
    gold(n - 1, auxiliary, destination, source);
}

fn golden_rule_configuration(n: i32) {
    let mut gold_config = String::new();
    for i in (0..n).rev() {
        final_config += &"1".repeat(i as usize);
        final_config += &"0".repeat((n - i) as usize);
    }
    println!("{}", gold_config);
}

fn main() {
    let mut n = String::new();
    loop {
        println!("Enter amount of gold in grams:");
        n.clear();
        std::io::stdin().read_line(&mut n).expect("Impure");
        let n: i32 = match n.trim().parse() {
            Ok(num) if num > 0 => num,
            _ => {
                println!("Number of grams should be a positive integer.");
                continue;
            }
        };
        
        gold(n, 'A', 'B', 'C');
        golden_rule_configuration(n);
        break;
    }
}

a seed produced by this process can be graded into pure gold Au192, carat gold Au128 else rose gold Au160. It takes 24 Flow of Holes programs to create 🍯 from .999 grams of pure gold.

example product: [🍯,n grams gold] (this allows 0s to be replaced with 🍯 and 1s with 1-9) To enumerate characteristics of a production such as thorny, viney , fruit , product , or gold the recursion rules are rounded either by a thorny91 function or a viney91 function. 🍯+either91 function will evaluate to 🍇,🌷 or 🍷.

exceptional products

There is an exception at the floor above degree two[3,4+] rows which will produce a Mjolnir91, there is effectively no delta between i/o of the thorny91 and viney91 functions.

Mjolnir(91)

Initial word:[i,o]!Mjolnir(91)
                   1331/0\[29,30]
                     313321E\1/
                       3321E33/1\
                         21E3333\3/
                           E3333331/5\!(Input/Exception/Output\8\11\13).

This gives us 1008 different functions we can do to each emoji or valid evaluation.

Interpretation

Interpretation is Pietfood where grape emoji is magenta and strawberry is spicy. Effectively in certain tables thorny91 is a spicy function and and viney91 is a strawberry function while Mjolnir91 is always strawberry spicy.

Mjolnir91 rolls a stack of guesses and provides 2009 functions (doubles) for each address. This allows a Mjolnir91 to be prefixed and can hypersort (divide) products into silver Ag or copper Cu (++) 

   x y S ...
       ╚ S ...

So we can realize a discreet extension to a selfie-tag system similar to roll-context from Piet++ with limited dimension and execute a program.

Program execution

Given what we know about any general ExceptionTrackingCounterMachine we can specify rules.

  1. A program containing 🐅 will run a valid 🐅; if 🐯 is a tiger the program runs.
  2. If a program contains a 🐅 but any rule is false it will not run.

example truth machine

100gold is prime
 🍯100 🐅
        ╚ 🐯2999509

McCarthy 91

An example of an McCarthy_91_function: Mjolnir91==carat/🐯

restrictions

The McCarthy 91 example is ℒ-recursive so registers can only support an a-k coding system. The ternary prefixes thorny and viney do support mu recursion up-to the superset L.

XKCD Random Number Generator

Random number always 4 guess 2^136279841-1 is 2 carats=4

"Nope" forms

  1. Nope.2 carats≠4
  2. Nope!2≈4
  3. Any further iterations:∞

Real Fibonacci

Fibonacciis Fibonacci 1

🌹/🍇 Fibonacci(🌻/🍍)

a complex/imaginary Fibonacci sequence in Yggdraphyll:
The 🐝🐝 made 🍯 in the 🐅💀!!
(this program can interpret Zymbol-Lang so no more program forms are needed to describe this esolang.)

Pitfalls, implementations e.t.c.

This language relies on a type of tail recursion that means a given python interpreter works sometimes

As a rule of thumb a tarpit in its own language this lang is called a cattail. To effectively avoid cattails during assembly we can implement mental models and only compile a program when it works.

Implementation

👋🌍✨
1
2
🫧
4
🐝
🫧
7
8
🫧
🐝
11
🫧
13
14
🫧🐝
"ᎣᏏᏲ, ᏣᎳᎩ ᎦᏬᏂᎯᏍᏗ!" ¶

ᎦᏁᎸᏗ(ᎯᏃᎮᎵ) {
    ? ᎯᏃᎮᎵ % 15 == 0 { <~ "ᎤᎦᎾᎸᏄᎾᏍᏛ" }
    _? ᎯᏃᎮᎵ % 3  == 0 { <~ "ᎤᎦᎾᎸ" }
    _? ᎯᏃᎮᎵ % 5  == 0 { <~ "ᏄᎾᏍᏛ" }
    _ { <~ ᎯᏃᎮᎵ }
}

@ Ꭲ:1..15 {
    >> ᎦᏁᎸᏗ(Ꭲ) ¶
🦢♾️ (🦢) ♾️ 🦢 ♾️ 🦢🦢 ♾️ 🦢🦢🦢 ♾️ 🦢🦢🦢🦢🦢🐯¶
(
♾️ (🦢) ♾️ 🦢 ♾️ 🦢🦢 ♾️ 🦢🦢🦢 ♾️ 🦢🦢🦢🦢🦢
)// FizzBuzz — 🌍 Universal Emoji
// Identifiers: emojis. Operators: always symbolic. Output: emojis.

>> "👋🌍✨" ¶

🎯(🔢) {
    ? 🔢 % 15 == 0 { <~ "🫧🐝" }
    _? 🔢 % 3  == 0 { <~ "🫧" }
    _? 🔢 % 5  == 0 { <~ "🐝" }
    _ { <~ 🔢 }
}

@ i:1..15 {
    >> 🎯(i) ¶
}
target



Computational class


Yggdraphyll is ℒ-equivalent (#ℒ-equivalence) to ℒ-hard over ℒ-complete at MAX_SAFE_INTEGER(2999509)/tiger(hash). It would not be considered Turing-complete but supports new guesses for optimizing machines, exception tracking machines, and complex rounding mode specifications.



See also