Bring to Another

• Bring to Another
  • Sample programs
    • [S0] Rule 110
    • [S1] Stdin
    • [S2] FizzBuzz
    • [S3] Hello World
    • [S4] Modulo
    • [S5] truth-machine
    • [S6] this thing
    • [S7] null
    • [S8] check if odd
    • [S9] the K combinator
    • [S10] oprimized truth-machine
  • Other artifacts
  • Observations
  • Known facts
    • Known instructions
  • Current assumptions
    • Likely instructions
    • Addresses
  • Hypotheses
  • Analysis of S7 and S6

Sample programs

[S0] Rule 110

This outputs a rule 110 triangle and crashes after 100 iterations

​​​​/from 1 to 7 after pushing:
​​​​#1V #2V (#V:)
​​​​/colors:
​​​​#^~~(#V=DEC)^V~:[/=/]
​​​​/memory:
​​​​&[23][34][77]
​​​​/show
​​​​(77,a,77)
​​​​{[01] >>> 0 1 0 1 7 5 2 4 2 3 1 2
​​​​[==] <<< 6 4 5 3 2 %%%%%%%%%%%%%%
​​​​<<5 >>> 2 3 4 5 1 2 4}

[S1] Stdin

This reads stdin until EOF

​​​​[&&]

[S2] FizzBuzz

This repeatedly checks if counter (whatever that is) is divisible by either 5 or 3 in an infinite loop.

​​​​($)/([3][5][0]) 0 000 =

An alternate and more likely interpretation of the original description would say that
it independantly checks for % 5 == 0 and % 3 == 0, making it have two outputs (the choice of the numbers 3 and 5 supports this, since then it becomes FizzBuzz except there's no output)

[S3] Hello World

A hello world

​​​​104 101 108 108 111 44 32 119 111 114 108 100 33 ;;;;;;;;;;;;;

The bytes might be in the wrong order this is very clear since in other text programs we have in reverse order

[S4] Modulo

Checks if 3 is divisible by 3.

​​​​(3)/([][][])

[S5] truth-machine

​​​​[&&]||WSA-aø-------------------------------------------------------------
​​​​---------------------æpå<å<++-------------<.+----------------------------
​​​​---------------------------------øa[ø]------!<>^^---[^]!!!!$|---|´´´
​​​​...≠<!><!>!<>+·+·+·*#@(@):[ø]~<>!´<!||+++<>!{"%} 

The original description is as follows:

this code should be a truth machine if i used ø and ! right way.
i hate myself for creating the data pointer and indexable memory, since now
the code looks like this bullshit!!!

[S6] this thing

​​​​>[#∩∅]<#V∩1(#∩V)∅:∅[∅]

is a tape setup for some turing machine.
The note says that is uses substacks and "subsets"

[S7] null

​​​​[∅∩[0∩0]]

This program is called "null". It likely creates an empty object of some kind

[S8] check if odd

​​​​[&&]-()/(2){101 117 114 84 4(;) 68 000 =} 97 101 115 108 97 70 5(;)±

checks if user input is odd or not

[S9] the K combinator

​​​​(λ)/(x)?[Aₙ.x](P)

creates a function P that will take a input A and a input x and will output a function that will always return x

[S10] oprimized truth-machine

​​​​[&&]-(){"%}%

a optimized version of the truth-machine

Other artifacts

Some notes found say:

1. the memory where in hex.
2. In bring to another time matterd. A lot.
3. &'s very used for a lot of things.
4. Numbers has other meaning's than just numbers.

A TODO list says:

5. since the color section is only the push form 1 to 7 then ill just delete dat comment
6. see if any brackets have been done wrong

A notes.txt says:

7. information:
8. the language is called "bring to another"
9. lambda calculus!!!
10. goto? yes! maybe ill use 000
11. loops are just brainfuck loops idk
12. try to describe it. i swear i need to do this before i forget it
    note: i did forget it. i shouldve done that:D

A weird_features.txt says:

13. it has substacks now. yaay
14. substacks can hold instructions

a logo:

Observations

• There are 14 %s in S0
  • this is probably the width of the field
• whatever - and + are, they are not arithmetic operations
• < and > do not cancel eachother
• operator ordering seems very inconsistent
• There are a lot of symbols. It is probable that not all of them are instructions.

Known facts

1. this is stack-based, although it also appears to have functions(lots of them in fact).
2. line-initial / is a comment
3. n 000 = acts as goto line n
   • note though, that in the original file it said 000= whatever
4. loops behave like bf*
5. what's a consistency??(very inconsistent)

Known instructions

<number>   push decimal number onto the stack
;          pop [n] and output as ASCII
%          pop [n] and output as a number
n(E)       where n is a number causes E to be repeated n times

Current assumptions

1. the /colors: comment is erroneous, and the following line is actually part of the previous step (A5)
2. [...] makes some sort of sub-stack

Likely instructions

{E}        some sort of loop (likely bf-style)
$          push the number of times this has been encountered
a b =      set address b to value a within indexable memory
[E]        create substack of some sort
"          duplicate top of stack
(E)        appears to be related to function application and to binding variables

Addresses

0000    Holds the instruction pointer

Hypotheses

1. [...] creates a sub-stack

   • ???

2. [...] is related to memory

   • Contradicts T4
   • [+] appears thrice in /memory

3. & is related to memory

   • [+] appears only in /memory
   • [-] operator order is reversed compared to 0 000 =

4. &[...] is a special syntax unrelated to [...]

   • [+] uses hexadecimal numbers, rest of program seems to use decimal (S4 A1)
   • [+] resolves operator order discrepency (H3)
   • [-] why would the syntax change so much

5. [a][b][c] is unrelated to [...]

   • This is to be assumed false until all else fails.
     Because this'd complicate everything way too much
   • [+] it everywhere in S0
   • [?] there are no command that does that
   • [-] no concrete evidence

6. DEC decrements

   • [+] the name
   • [+] its used with V which is related to memory in some way
   • [-] no real evidence
   • [?] it could just be a label of some kind
   • [-] what would rule 110 need that for

7. {E} is brainfuck loop

   • confirmed
   • [+] in notes.txt 11
   • [+] one of the only free tokens
   • [+] there needs to be A loop
   • [+] S5 practically confirms it

8. (...) is a function application

   • [•] would mean numbers are functions that repeat argument n times
   • [+] λ-calculus has been mentioned

9. n(E) = λE.n E where n is a church numeral where the function we apply n times is taken as first argument

Analysis of S7 and S6

​​​​[&&]-()/(2){101 117 114 84 4(;) 68 000 =} 97 101 115 108 97 70 5(;)±

This checks if an input is odd or even and prints "true" or "false" in response

​​​​(λ)/(x)?[Aₙ.x](P)

This is supposed to be equivalent to a K combinator, (λxλA.x), bound to P per the description

The first program, according to what we know, can be broken down as follows:

[&&]     Take the input
-        <unknown>
()       <unknown>
/        <unknown>
(2)      <unknown>
{        Jump past block if nonzero
    ...     Load ASCII "True" onto stack
    4       Load length of string (4) onto stack
    (...)   Apply to 4, which causes repetition
       ;        Put character from stack
    68      Load pointer 0068 (one past EOP)
    000     Load address 0000 (IP). 
    =       Jumps to index 68, which is the ± or past EOF
            -> The effect is halting the program
}        End loop block
  (ditto)
±        <unknown>

(A)/(B) seems to be it's own structure unrelated to (E). / has only ever appeared alone or in that context, and (E) being a function application, should be invalid at the start of the program.

The - is responsible for some sort of input processing.
The ()/(2) causes a modulus by 2

And the rest is explained.

However (A)/(B) has to be a pretty generic structure and not specifically modulus, since it also shows up in the K combinator:

​​​​(λ)/(x)?[Aₙ.x](P)

Fortunately it is known that P, x, and a are names here.
If (E) is an application, then at the surface it looks like the prior code creates a function that binds the a function to the argument. It would seem logical if λ was responsible for that, but that is a guess.
? does not appear anywhere else. . appears in only one other program.

It is also worth bringing

​​​​($)/([3][5][0]) 0 000 =

into the analysis, as it also is related to modulus and has this structure