# Bring to Another

[TOC]

## 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)/([][][])

>[!Warning] Discarded
>This program is believed to be and unfinished version of S2 that likely doesn't work
### [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).
3) line-initial `/` is a comment
4) `n 000 =` acts as `goto line n`
- note though, that in the original file it said `000= whatever`
5) loops behave like bf*
6) 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
- ???
3) `[...]` 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
8) `[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
9) `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
10) `{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
12) `(...)` is a function application
- [•] would mean numbers are functions that repeat argument n times
- [+] λ-calculus has been mentioned
13) `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