nyuuzyou/wikis huggingface dataset:
Truthiness

Truthiness and falsiness are mutually exclusive qualities that a value can have. By definition, the boolean value true will be truthy, whereas false is falsy. Truthiness (and falsiness) are used for conversion to booleans, especially for implicitly converting to booleans for commands that require them.
In Python, 0, False, "" and empty collections are all falsy, and most other values are truthy, which allows all values to be used as an if statement condition.
 if "a":
 "This branch will run"
 if "":
 "This branch will not run"
In other languages, truthiness is not defined for most data types. For instance, in Haskell, only the booleans True and False can be used in if expressions.
 a = if True then "This string will be returned" else "This string will be ignored"
In some languages, truthiness is not defined for any data type. For example, in ///, building the truthiness oneself is the way of writing conditionals.
== The Nature of Truth and The Nature of Truthiness ==
Truthiness and truth are related concepts, but not the same. The dictionary definition of 'truthy' means something that feels true, whether or not it is. Likewise, a value can be truthy if a program believes it to be true, regardless of whether it is true or not. Outside of logic programming and mathematical proofs, truth is less important than truthiness in programming. To put it another way, a programmer tells her program what to do and think, and should be able to tell it to believe anything is true/truthy, regardless of whether it is really true. In the subjectivity of an algorithm, malleable truthiness supplants the absolutes of truth and falseness.
"True" has two distinct uses. It describes statements that match the real world, which aren't truthy in a program that lies to itself. It also describes provable mathematical facts. The latter, information that can be deduced a priori, is truthy in most programs. For example, 1 < 2 is predominantly a truthy statement, but programming.IsFun() could go either way based on what the programmer decides.
Truth is a bit of a snafu, so if you want a definition, a more encyclopedic wiki would be better.
== Non-Boolean Truthiness ==
Some languages, especially probabilistic ones, allow shades between true and false. The standard boolean operators, NOT, AND, OR etc, can be adapted to work on a probability between one and zero, instead of just 1 or 0. In fact, many systems of probability dispense with 1 and 0 on the Bayesian premise that nothing is ever certain, so no probability can ever reach either absolute. This fuzzy logic is common in neural network programs that operate on Bayesian principles.
Category:Concepts
Truthlang

Truthlang is an esoteric programming language created by User:Oshaboy. It's not quite a Truth Machine. 
== Overview ==
 0: prints 0 then halts
 1: prints 1 indefinitely
Only 1 command is allowed per program. Whitspace is ignored. Everything else is a Syntax Error. Therefore there are only 2 valid programs. This isn't quite a Truth Machine because as opposed to recieving input from stdin its "input" is the source code. You can't even write a Truth Machine in it. A Truth Machine is NOT a valid interpreter for Truthlang unless it ignores Whitespace and checks for Syntax Errors.
== Implementation == 
A Compiler. It compiles to Machine Language through C. So it is blazing fast. Not an interpreter like inferior esolangs. 
Category:Joke_languages
Category:Output only
Category:Implemented
Category:Unusable for programming
Category:2021
Category:Languages
Category:Declarative paradigm
Try

Try is a esolang where you write esolang specs to code
== Commands ==
 [name] is a esolang where you [val] : set name to value
 == [Topic] == : define a procedure called Topic
 === [Subtopic] === : define paramerter called Subtopic
 Also look at the discussion page for [Something] : set Something to input from user
 [name] is a [val] : set name to val
 The output is [var/val] : output var/val
== Examples ==
* Try/hello world
Category:Languages Category:2024
TrytePusher

TrytePusher is a computer designed by Unname4798. It is like BytePusher, but it uses ternary.
== Technical specifications ==
Memory: 282.429.536.481 trytes (writable)
 4.261.625.379 trytes (addressable)
Picture quality: 6561x2187 (27:9), 729-level RGB, 100fps
Audio quality: 59049hz, 2-tryte, 1 channel, 729 instruments, from 50hz to 5364.4hz, cooldown of 1/9 seconds
Input: 729 keys (27x27 layout), mouse
CPU speed: 53.144.100 hz
CPU: TryteTryteJump
 A - 4 trytes
 B - 4 trytes
 C - 3 trytes
See also:
• TrybblePusher
Category:Languages
Tsaf

== about ==
tsaf is the esolang version of fast.
in tsaf all the commands are numbers
syntax : (tsaf syntax - fast syntax)
 3110 - idx
 2870 - add
 3221 - sub
 3241 - mul
 3099 - div
 3111 - mod
 2985 - cat
 3117 - eql
 6909 - incIdx
 6760 - decIdx
 3189 - set
 3069 - get
 5828 - print
 3338 - str
 3188 - int
info:
 thelanguage is on a tape variable system with length of [256].
 3110 lets you set the pointer
 the operations are all performed [holder <op>= inp]
 3069 sets the holder to the parameter
example: (hello world)
 5828 : 3338
 3189 : 3338 : hello,~world!
 3069 : 3338 : 0
 5828 : 3338
== external resources ==
compiler:
 compiler.java
Category:Implemented Category:Languages
Tttt

==Intro==
===what is Tttt?===
Tttt is a programming language that is so simple that it has 10 characters:
1.) a
2.) b
3.) c
All the way to j.
===the data===
The data is kind of like brainfuck, an array of cells, 3 in the original, and infinite in Ttttt. There is a pointer, also like brainfuck.
===the symbols===
# a gets the cell under the pointer and adds 2 to it. Why 2? So it is inefficient!
# b gets the cell under the pointer and subtracts 1. There is no limit for cells. -infinity to +infinity.
# c pushes the pointer forward by one.
# d pushes the pointer backward by two.
# e prints the ascii character of the cell under the pointer.
# f prints the value of the cell under the pointer.
# g prints a new line.
# h does a brainfuck (ASCII) input.
# i is a brainfuck ‘[‘.
# j is a brainfuck ‘]’.
k and l can be used for comments. Example:
 k this is a comment l.
==programs==
===Hello, World!===
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaeabaaaaaaaaaaaaaaeabaaae
eabaebbbbbbbbbbbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
bbbbbbbbbbbbebbbbbbbbbbbbeabaa
aaaaaaaaaaaaaaaaaaaaaaaaaeaaaa
aaaaaaaaeabaebbbbbbebbbbbbbbeb
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
bbbbbbe
That took me a while to make.
One line:
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaeabaaaaaaaaaaaaaaeabaaaeeabaebbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbebbbbbbbbbbbbeabaaaaaaaaaaaaaaaaaaaaaaaaaaaeaaaaaaaaaaaaeabaebbbbbbebbbbbbbbebbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbe
===Truth-machine===
hchdcicbdcbjcifjf
You need two inputs. The first one is zero. The second one is 1 or 0.
aaaicaaaacdbjhcibcdbcjcdifjf
You only need one input for this truth machine, which can be either 0 or 1.
==Implementations==
This is an implementation in Python which works with the examples above. However, it is not the official implementation.
def run_tttt(data: str) -> None:
 code = list(data)
 variables = [0, 0, 0]
 pointer = 0
 which_var = 0
 while pointer < len(code):
 if 'a' == code[pointer]:
 variables[which_var] += 2
 elif 'b' == code[pointer]:
 variables[which_var] -= 1
 elif 'c' == code[pointer]:
 which_var += 1
 elif 'd' == code[pointer]:
 which_var -= 2
 elif 'e' == code[pointer]:
 print(chr(variables[which_var]), end="")
 elif 'f' == code[pointer]:
 print(variables[which_var], end="")
 elif 'g' == code[pointer]:
 print("\n", end="")
 elif 'h' == code[pointer]:
 variables[which_var] = ord(input())
 elif 'i' == code[pointer]:
 if variables[which_var] == 0:
 while code[pointer] != 'j':
 if code[pointer] == 'k':
 pointer += code[pointer:].index('l')
 pointer += 1
 elif 'j' == code[pointer]:
 if variables[which_var] != 0:
 while code[pointer] != 'i':
 if code[pointer] == 'l':
 while code[pointer] != 'k':
 pointer -= 1
 pointer -= 1
 pointer -= 1
 elif 'k' == code[pointer]:
 pointer += code[pointer:].index('l')
 pointer += 1
Category:Languages Category:Implemented Category:Cell-based
Ttttt

Now if you want to know how Ttttt works, go to Tttt, because who doesn’t like go to statements. The 2 differences between Tttt and Ttttt is that Tttt has three memory slots, Ttttt uses infinite. Also Tttt has no nested loops. Ttttt does.
==Hello, world==
Most programs are the same. This is hello, world.
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaeabaaaaaaaaaaaaaaeabaaae
eabaebbbbbbbbbbbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
bbbbbbbbbbbbebbbbbbbbbbbbeabaa
aaaaaaaaaaaaaaaaaaaaaaaaaeaaaa
aaaaaaaaeabaebbbbbbebbbbbbbbeb
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
bbbbbbe
So yeah.
The one line version is:
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaeabaaaaaaaaaaaaaaeabaaaeeabaebbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbebbbbbbbbbbbbeabaaaaaaaaaaaaaaaaaaaaaaaaaaaeaaaaaaaaaaaaeabaebbbbbbebbbbbbbbebbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbe
This nested loop program wouldn't work in Tttt, not only because it has three nested loops, but because if there were only three spaces possible, even if it could cycle through the spaces indefinitely, it would be incrementing and decrementing the same spot at the same time.
aaiccaaiccaaiccaadbjdbjdbjccccccbe
It outputs ÿ.
==Implementations==
This is an implementation in Python, but it is not the official implementation.
def run_ttttt(data: str) -> None:
 code = list(data)
 variables = [0, 0, 0]
 pointer = 0
 which_var = 0
 while pointer < len(code):
 if 'a' == code[pointer]:
 variables[which_var] += 2
 elif 'b' == code[pointer]:
 variables[which_var] -= 1
 elif 'c' == code[pointer]:
 which_var += 1
 if which_var == len(variables):
 variables.append(0)
 elif 'd' == code[pointer]:
 which_var -= 2
 while which_var < 0:
 variables = [0] + variables
 which_var += 1
 elif 'e' == code[pointer]:
 print(chr(variables[which_var]), end="")
 elif 'f' == code[pointer]:
 print(variables[which_var], end="")
 elif 'g' == code[pointer]:
 print("\n", end="")
 elif 'h' == code[pointer]:
 variables[which_var] = ord(input())
 elif 'i' == code[pointer]:
 if variables[which_var] == 0:
 nest_counter = 0
 while code[pointer] != 'j' or nest_counter >= 0:
 pointer += 1
 if code[pointer] == 'i':
 nest_counter += 1
 elif code[pointer] == 'j':
 nest_counter -= 1
 elif code[pointer] == 'k':
 pointer += code[pointer:].index('l')
 elif 'j' == code[pointer]:
 if variables[which_var] != 0:
 nest_counter = 0
 while code[pointer] != 'i' or nest_counter >= 0:
 pointer -= 1
 if code[pointer] == 'j':
 nest_counter += 1
 elif code[pointer] == 'i':
 nest_counter -= 1
 elif code[pointer] == 'l':
 while code[pointer] != 'k':
 pointer -= 1
 pointer -= 1
 elif 'k' == code[pointer]:
 pointer += code[pointer:].index('l')
 pointer += 1
Category:Languages
Category:Cell-based
Category:Implemented
Tuesday

Tuesday is an esoteric programming language created by Tanner Swett in 2013. It is a matrioshka language inspired by Thue.
== Language description ==
Parsing a Tuesday program consists of removing all lines whose first non-whitespace character is a number sign (#), followed by removing all whitespace characters, followed by parsing the result according to the following grammar:
 <program> ::= {<statement> ";"} <expression>
 <statement> ::= <expression> ":" <expression>
 <expression> ::= { lowercase English letter | uppercase English letter | "(" <expression> ")" }
In the below, an *expression* is a (possibly empty) sequence of lowercase letters, uppercase letters, nonce symbols, and/or correctly matched parentheses.
Each statement represents a rewrite rule, meaning "replace (left hand side) with (right hand side)", where the left hand side is a pattern using uppercase letters as variables, and the right hand side is a template using the same uppercase letters to refer to whatever those letters matched on the left hand side.
Execution begins with replacing each uppercase letter in the expression at the end of the program (the current expression) with a new nonce symbol, distinct from all letters, parentheses, and previously introduced nonce symbols. Each occurrence of the same letter must be replaced with the same symbol; occurrences of different letters must be replaced with different symbols.
From then on, execution consists of repeatedly making an unspecified legal replacement until it is no longer possible to make a legal replacement. A legal replacement consists of replacing a substring of the current expression, the matched substring, with another substring, the replacement substring, such that:
* The replacement is done according to some rule.
* For each uppercase letter that occurs on the left hand side of the rule, that letter has an assignment, which is an expression that does not contain any uppercase letters. (Different occurrences of the same letter can't have different assignments.)
* The assignment of each uppercase letter that occurs on the right hand side of the rule, but not the left hand side of the rule, is a new nonce symbol (distinct from all letters, parentheses, and previously introduced nonce symbols). Different uppercase letters can't have the same nonce symbol as their assignment.
* The matched substring is equal to the result of replacing every uppercase letter in the left hand side of the rule with its assignment.
* The replacement substring is equal to the result of replacing every uppercase letter in the right hand side of the rule with its assignment.
== Sample program ==
These rules ought to implement the SKI calculus, where the application of x to y is denoted by x(y), and the entire expression is surrounded with parentheses:
 (s(X)(Y)(Z)R): (X(Z)(Y(Z))R);
 (k(X)(Y)R): (XR);
 (i(X)R): (XR);
Notice that the above shows that Tuesday is Turing complete.
Category:Languages Category:Turing complete Category:2013
Tueue

Tueue is a Queue-based esolang designed by User:ChuckEsoteric08. It consists of two queues, as well as one accumulator.
==Specification==
As said before, Tueue consists of Two queues and one accumulator.
1QU will return bottom of first queue.
2QU will return bottom of second queue.
ACC will return Accumulator.
x and y are arguments.
ENQ x 	Enqueue x to current queue.
DEQ 	Dequeue element from current queue
SWP 	Swap current queue
INC x 	Increment accumulator by x
DEC x 	Decrement accumulator by x
MUL x 	Multiply accumulator by x
DIV x 	Divide accumulator by x
LAB x 	Declare label x
JMP x 	Goto label x
IQJ x y	If bottom of current queue is x goto label y
IAJ x y	If accumulator is x goto label y
MOV x y	copy x to y
OUT x 	Output x as an integer
ASC x 	Output x as an ASCII character
ADD 	Dequeue bottom two elements from queue, and enqueue result of addition of them
SUB 	Dequeue bottom two elements, a and b and push result of b-a
IQE x 	If current queue is empty goto x
COM x 	Comment
==Examples==
===Hello, World!===
 ASC 72
 ASC 101
 ASC 108
 ASC 108
 ASC 111
 ASC 44
 ASC 32
 ASC 87
 ASC 111
 ASC 114
 ASC 108
 ASC 100
 ASC 33
===Bitwise Cyclic Tag Interpreter===
Because There is no input, you should initialise program and data.
====Initialising Program====
For 0:
 ENQ 0
For 1:
 ENQ 1
====Initialising Data====
After initialising program add this code:
 ENQ @
 SWP
And then:
For 0:
 ENQ 0
For 1:
 ENQ 1
After initialising data add this command:
 SWP
====Interpreter itself====
 LAB SRT
 
 COM Halt if data string is empty.
 SWP
 IQE END
 SWP
 
 MOV 1QU ACC
 DEQ
 ENQ ACC
 IAJ 0 EX0
 IAJ 1 EX1
 IAJ @ IEM
 JMP SRT
 
 LAB EX0
 SWP
 DEQ
 SWP
 JMP SRT
 
 LAB EX1
 SWP
 IQJ 0 SJM
 SWP
 IQJ @ IF@
 SWP
 ENQ 1QU
 SWP
 ENQ 1QU
 DEQ
 JMP SRT
 
 LAB SJM
 SWP
 ENQ 1QU
 DEQ
 JMP SRT
 
 LAB IF@
 DEQ
 ENQ @
 SWP
 ENQ 1QU
 SWP
 ENQ 1QU
 DEQ
 JMP SRT
 
 LAB IEM
 DEQ
 ENQ @
 IQE END
 JMP SRT
 
 LAB END
===Looping Counter===
This looping counter prints the first ten lines:
 COM The accumulator maintains the current line number.
 MOV 1 ACC
 
 COM The first queue maintains the line's number of printed asterisks.
 ENQ 0
 
 LAB printLine
 IAJ 11 haltProgram
 
 LAB printAsterisk
 ASC 42
 ENQ 1
 ADD
 IQJ ACC concludeCurrentLine
 JMP printAsterisk
 
 LAB concludeCurrentLine
 ASC 10
 INC 1
 DEQ
 ENQ 0
 JMP printLine
 
 LAB haltProgram
==Interpreter==
* Common Lisp implementation of the Tueue programming language.
Category:Languages Category:Turing complete Category:Queue-based Category:Implemented
Tuplary

The tuplary programming language was created by Daniel Borowski. The language is composed entirely of brackets and sometimes spaces, other characters are ignored.
==Examples==
===Example Fibonacci Program===
 ]] ][][ [][ [ ][]
 [][][][] [][ ] [[][][][]] [[][][]] [][ [ [] [[][][]] ][] ][]
 ] [] [][ [ ][]
 [][][][]
 [][]
 ] [] ] ][][ [][ [ ]]][ [[][]] ][] ]]]] ] ][][ [][ [ ]]][ [[][][]] ][] 
 [][]
 ]]
 ] [][] [][ ] ][][ [][ [[][][][][][][]] ][] ][
==Documentation==
===Writing values===
====Numbers====
To write a number you put [[]+].
:In the plus, you write a [] repeated by how long is your number.
Examples:
:2 = [[][][]]
:7 = [[][][][][][][][]]
:4 = [[][][][][]]
:3 = [[][][][]]
To make a number negative you put a ] to the beginning of the number.
Examples:
:-2 = ][[][][]]
:-7 = ][[][][][][][][][]]
:-4 = ][[][][][][]]
:-3 = ][[][][][]]
====Characters====
To write a character you write a number but, instead, your put it inside of a ]+[.
:In the plus you write a number that it can only be in the range of 1-26 (a-z).
Examples:
:a = ] [] [ characters that aren't brackets are ignored (sometimes)
:e = ] [][][][][] [
:h = ] [][][][][][][][] [
:p = ] [][][][][][][][][][][][][][][][] [
To make a character uppercase you put a [ to the end of the character.
Examples:
:A = ] [] [ [
:E = ] [][][][][] [ [
:H = ] [][][][][][][][] [ [
:P = ] [][][][][][][][][][][][][][][][] [ [
If you want to use special characters like spaces you put a ] at the start of the character and you need to use a new alphabet, this alphabet:
space = ]][][
= = ]][][][
. = ]][][][][
: = ]][][][][][
[ = ]][][][][][][
] = ]][][][][][][][
\ = ]][][][][][][][][
( = ]][][][][][][][][][
) = ]][][][][][][][][][][
_ = ]][][][][][][][][][][][
< = ]][][][][][][][][][][][][
> = ]][][][][][][][][][][][][][
{ = ]][][][][][][][][][][][][][][
} = ]][][][][][][][][][][][][][][][
^ = ]][][][][][][][][][][][][][][][][
$ = ]][][][][][][][][][][][][][][][][][
# = ]][][][][][][][][][][][][][][][][][][
@ = ]][][][][][][][][][][][][][][][][][][][
; = ]][][][][][][][][][][][][][][][][][][][][
, = ]][][][][][][][][][][][][][][][][][][][][][
? = ]][][][][][][][][][][][][][][][][][][][][][][
' = ]][][][][][][][][][][][][][][][][][][][][][][][
~ = ]][][][][][][][][][][][][][][][][][][][][][][][][
=====Strings=====
To write an string you put a ][+][
:In the plus you write the characters
Example:
:Hey = ][ ][][][][][][][][][ ][][][][][][ ][][][][][][][][][][][][][][][][][][][][][][ ][
===Variables===
==External resources==
*documentation
Category:Languages
Turin

Turin is based of Turing-machine, employing an infinite tape of bit-valued cells in conjunction with a very simple state machine.
==Architecture==
There is an infinite tape of bit-valued cells, all starting by default with 0. A pointer exists pointing at the currently selected cell.
There is also a state, that defaults to START.
==Syntax==
The program starts with an header which determines the format expected by the input and output facilities:
 IN <mode>
 OUT <mode>
The mode may assume the following options: ASCII (signifies ASCII text input or output), BIN for direct binary transmission, and HEX in order to entertain communications in the hexadecimal format.
The example
 IN ASCII
 OUT ASCII
specifies that the input was interpreted as ASCII text. It is then converted to binary and transferred to the tape.
First, a command starts with a conditional:
 <activatingState>~<activatingSymbol>
The activatingState imposes the state requisite for the commands' execution, completed by the necessity of the bit-valued activatingSymbol to be satisfied by the tape's current cell, whence ensues the ultimate action.
For instance with
 START~0
the following commands are executed if current state is START and the value under the pointer was 0.
===Commands===
 Commands
Command	Description
> 	Move pointer left
< 	Move pointer right
0 	Write a 0 under the pointer
1 	Similar to 0 except that it writes a 1
==Examples==
===Hello world===
Hello world:
 OUT ASCII
 IN ASCII
 START~0:0>1>0>0>1>0>0>0>0>1>1>0>0>1>0>1>0>1>1>0>1>1>0>0>0>1>1>0>1>1>0>0>0>1>1>0>1>1>1>1>0>0>1>0>1>1>0>0>0>1>1>1>0>1>1>1>0>1>1>0>1>1>1>1>0>1>1>1>0>0>1>0>0>1>1>0>1>1>0>0>0>1>1>0>0>1>0>0>0>0>1>0>0>0>0>1>
To create this, first I convert the phrase Hello,World! into binary.
Then I added > in between.
===Hexadecimal Output===
This program replicates the text “FACE” on the tape by mediation of the respective hexadecimal digits, whose bits form the catena 1111 1010 1100 1110:
 OUT HEX
 IN HEX
 START~0:1>1>1>1>1>0>1>0>1>1>0>0>1>1>1>0
==Interpreter==
* Common Lisp implementation of the Turin programming language.
Category:2022 Category:Unknown computational class Category:Implemented Category:Languages Category:Cell-based
Turinf machine

Turinf machine is a Turing machine that has infinitely, but countably, many states.
== Overview ==
Memory model is the same as in ordinary Turing machine (infinite tape of bits). The only difference is that a Turinf machine program is allowed to have infinitely many states, but the number of states must be countable.
It is important to note that the set of all Turinf machine programs is uncountable. That means that some of them we have no way to represent in a finite number of characters. For some Turinf machine programs, we can define all the states by creating an ordinary Turing machine that generates all the states. However, the set of all ordinary Turing machines is countable, so the number of Turinf machine programs generated in such manner would be countable. Therefore, some Turinf machine programs cannot be an output of an ordinary Turing machine.
== Syntax ==
Syntax is implementation dependent. If a formal syntax is required (for this to be a programming language), let the source code be an array of states separated by new lines and each state is represented either as the "HALT" string (for halting states), or as two groups of 3 space-separated decimal non-negative integers enclosed in parentheses (for non-halting states) - the first group is for the current pointed bit being 0 and the second is for 1. In each group, the first number is 0 or 1 (0 - do not invert the memory bit, 1 - invert the memory bit), the second one is 0 or 1 (0 - go left, 1 - go right), and the third one is the next state (0-indexed). The initial state is the state with index 0.
== Computational class ==
It is debatable what the computational class of this programming language is. On the one hand, since we have no way to represent some of the possible programs, we may consider Turinf machine uncountable. On the other hand, a Turinf machine program is not capable of solving the halting problem for an ordinary Turing machine on itself. However, since we have infinitely many states, we can encode all bits of a Chaitin's constant, effectively encoding solutions to halting problems for all possible ordinary Turing machines.
Category:Languages
Category:Unknown computational class
Category:Unimplemented
Category:2020