Treee

Treee is a language created by Octogeddonling (talk) 08:49, 4 January 2023 (UTC) . It replaces all letters in lambda calculus into trees of brackets and adds some mess to turn the entire code into uncomputable gibberish.
== Grammar ==
* call all the following an "operation"
* suppose the object have the form(another object...another object) and () is an object
* if the object has form(()followed by at least 3 objects), delete the outer bracket of second and third object, then replace every first object in the second object with the de-bracketed third object, than delete the first (), first object and third object's entirety. 
**for example, (()()(()(()))(()()(()(())))) outputs itself.
**this step is edited 3 times to actually create a quine
*if the object has form(((()))followed by at least 1 object), delete the first 2 objects in the outermost bracket and prints a character whose ASCII code is equal to the total number of pair of brackets in the second object
**for example, (((()))(((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))) prints a space and outputs ()
**for any given number of spaces, just repeat the code above in the same trunk
*if the object has form(((()()))followed by at least 3 objects), then if an operation to the first input ultimately halts and returns a tree with no branches, then the first four is replaced by just the second, otherwise the third object.
**for example, ((()())A(()()(()(()))(()()(()(()))))(())) reverses the halt for A. This can be used to create a paradox but it's not computable anyway
*the form((()()())followed by at least 3 objects) works in a similar way but instead of checking the halting problem it will check any paradox in the first input. Replace the first four with the second if it's well-founded and return the third if it's not.
*repeat the 4 actions until nothing can be done
*scan all objects in this layer with an operation followed by an operation of this layer each time. For example if A turns into a, than the operation of (Abcd)operates(Abcd), then operates A, then operates (abcd), then operates b
*halt and output if really nothing can be done here
== Numeric Form ==
you can rewrite the whole code into numbers, such as (()()(()(()))(()()(()(())))) to 4 0 0 2 0 1 0 3 0 0 2 0 1 0. now you can write an interpreter of no action 3 and 4 using just Brainfuck!
== Version 2 ==
*Version 2 is a simplification to the original one
*the fourth transformation is omitted
*let the transformation of (()A(B)(C)E) be:
**if A reduces to a tree without branch, aka () (()) ((()))..., the result would be (((B))E)
**else, the result will be (BC(C)E)
**if the operation above triggers a paradox, the result would be (((C))E)
*the trigger for printing is (()) now
== Version 3 ==
*Version 3 is easier to understand and it is Turing complete anyway
*The form of an operation is (()(A)(B)(C)D), as it in version 1
**if (A) reduces to a tree without branches, then the result would be the same as it in version 1.
**else, the result would be the same as (()(A)(B)((C))D) in version 1. There is an extra bracket on C.
**A paradox will output (BD).
*The form of a printing is ((())(A)B), of which it prints a Unicode character of number of brackets in A.
**that makes it compatible with other languages
== Miscellaneous ==
This language is uncomputable because obvious.
This language was inspired by SKIΩ calculus and it is supposed to have strength comparable to Xi_2 function.
Category:Languages Category:Unimplemented Category:Uncomputable Category:String-rewriting paradigm Category:2023