nyuuzyou/wikis huggingface dataset:
Indivisible

Indivisible is an OISC esolang designed by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff. The name is a reference to the fact that multiplication in this language is irreversible, and division is impossible.
== Syntax ==
An Indivisible program is made up of instructions that each use one argument, separated by whitespace. The arguments may be anything that does not contain whitespace; however, it is recommended that numbers are used.
== Semantics ==
When an Indivisible program is run, it has a list of variables, each starting at 1, and a counter, which also starts at 1. Each instruction looks at the variable corresponding to its argument and multiplies it by the counter (if it is not divisible by the counter). The counter is then incremented. Indivisible programs are run in an infinite loop and never halt.
== Computational class ==
Unbounded memory is available, so the real problem with proving Turing-completeness is doing conditional statements. It's possible to do rudimentary statements, for example assuming A is divisible by 13, a statement like "if A is not divisible by 2, multiply by 26" is possible. Using Gödel-numbering, this can be treated as "if *2 is empty, increment *2 and *13". Another problem is getting the program to halt, since it will keep chugging along forever and find more prime factors along the way, ruining the Gödel-numbering.
Since variables cannot affect each other, Indivisible's computational class would only require two variables to be Turing-complete (assuming it is).
== External resources ==
* Try it online!
Category: Languages Category: OISC Category: Unknown computational class Category: Low-level Category: 2024 Category: Implemented Category: No IO
Indurate

Indurate, also known as Friable, is a subset of the Rust programming language focused on the safety, immutability, and elegance that is lost in the disgraceful, hedonistic use of Rust proper.
== Restrictions ==
* Use of mutability is prohibited. No variables or function arguments may be marked as `mut`. Any types which allow mutability, such as the mutable reference, are similarly barred.
* Use of unsafe code is prohibited. Under no circumstances can an unsafe block be created, nor can any function or trait be marked as unsafe.
* Given the sinful and flagrant breaches of the two previous points throughout the Rust standard library, any `use` therein is prohibited, including the prelude. This chiefly targets the `std` and `core` crates.
To assure no use of the standard library, all Indurate code should begin with:
 #![no_prelude]
Additionally, the code should be compiled in Rust edition 2018 or greater, to assure that the procedural macros as well do not seep in.
== Ramifications ==
It is unclear if a useful binary could ever be created. Access to files, stdin/stdout, or any I/O functionality is unavailable. Additionally, any return value from the `main` function must implement the `std::process::Termination` trait, and as such the only possible return types are the unit type `()` and the never type `!`, neither of which can hold data. It might be possible to transmit one bit of information by deciding whether the program terminates; however, determining in the general case whether an Indurate program will terminate is currently not feasible. Nonetheless, like its parent language, library code is still entirely possible.
One major issue is allocating memory. Without that, the language would be reduced to FSA complexity. There is the unstable `box` keyword which is an alias for `Box::new()`, but it's unclear how to utilize it (e.g. by creating a linked list) without referencing the `Box` type itself.
Category:Esoteric subset
Category:Languages
Category:Implemented
Category:Usability unknown
Category:Unknown computational class
Category:2022
Inertia

Inertia is 'another' language inspired by User:Hanzlu's usable language definition. But this time, the language is actually quite usable.
== Description ==
Note that the language Inertia has nothing to do with inertia... it contains assignments on a lazy-evaluated tape. The first cell on the tape can be accessed by 1 and has 1 stored in it, the second by 2 and has 2 stored in it, etc, until infinity.
1 = 2 Assign cell #1 to cell #2.
= 1 Output cell # 1.
1 = (Gotos are the easiest control structure. :) ) Jump to the line stored by the accumulator 1.
= Left-shift the tape (i.e. perform 0 = 1, 1 = 2, etc. It's lazy-evaluated.)
Category:2020
Category:Languages
Category:Cell-based
Category:Unimplemented
Category:Low-level
Category:Usability unknown
InfChessPro

You have a infinite chess board that starts blank. Make a file with lines numbered like this and execute from top to end:
 1. 3,1,5,0
 2. nothing=K6,0
 3. nothing;1,1!1
Notes:
* abs1 and abs2 are absolute positions, as in row,col where row and col are numbers. White pawns (uppercase) go forward increasing row number, black pawns (lowercase) go backward decreasing row number.
* rel1 and rel2 are relative positions, as in row,col where row and col are numbers relative to the position that the piece is moving from.
These are the commands:
* abs1,abs2 = moves a piece from abs1 to abs2 if it can move like that in the normal rules of chess. There is no castling, enpassant, promotion, and a piece can move as far as it wants. You are not allowed to move a piece of your own color if doing so would put any king(s) of your color in check or keep any king(s) of your color in check.
* name=typeabs1 = adds a piece to space abs1 if that space is vacant (you can even place kings where it would be in check or place pieces if it would not get you out of check). The name can be any name with letters, numbers, underscores, and it doesn't have to be unique you can have multiple pieces with the same name (even if they are different color or type). The type is a letter indicating the type of chess piece, uppercase for white or lowercase for black.
* name,abs1 = moves a piece called name to abs1 position (using same moving rules as above). If multiple pieces with the same name, tries the newest one first, if that one isn't successful it tries the next newest one, and so on.
* name;rel1 = same as above but relative movement instead.
* ^ = always successful but has no effect.
* "text = output text.
* %name = output the number of pieces with that name.
After each command you can optionally put ? or ! followed by a line number. If ? and command is successful, it goto line number. If ! and command is not successful, then it goto line number. You can put * anywhere to input a number.
You can have comments with # at front of line, with no numbers.
== Proof of turing complete ==
This is (I think) proof of turing complete. You can make a register machine with any number of registers. Each one is a named rook. For example:
 1. x=R0,*
 2. y=R1,*
 3. z=R2,*
and you need something to stop it from moving too far backward (such as pawns), for example:
 4. stop=P0,-1
 5. stop=P1,-1
 6. stop=P2,-1
It is possible to do increment, decrement, and jumps and stuff:
 7. z;0,-1?7
 8. x;0,-1!11
 9. y;0,1
 10. z;0,1?8
 11. "stop
== Examples ==
Beer program:
 1. Amount=K99,0
 2. Beer=P0,0!4
 3. Beer;1,0?3!2
 4. Drunk=k-1,0
 5. %Beer
 6. "bottles of beer on the wall.
 7. %Beer
 8. "bottles of beer.
 9. "Take one down, and pass it around.
 10. Drunk;1,0!14
 11. %Beer
 12. "bottles of beer on the wall.
 13. ^?5
 14. "No more bottles of beer on the wall.
Infbf

Infbf is an esoteric programming language by User:Fyr.
It is a derivative of brainfuck with an infinite-dimensional hypercube tape where each dimension has two cells.
The brainfuck commands > and < are repurposed as rotation to a different dimension, instead | is used for moving to the other cell in the current dimension.
A brainfuck program can be converted into an Infbf program by replacing each > and < with |> and <|.
== Commands ==
Command	Description
> 	Increment the dimension
< 	Decrement the dimension
| 	Move to the other cell in the current dimension
+ 	Increment the current cell
- 	Decrement the current cell
. 	Output a character from the current cell
, 	Input a character and store it in the current cell
[ 	Jump forward to the matching ] if the current cell is zero
] 	Jump back to the matching [ if the current cell is nonzero
== Examples ==
A program that prints "Hello World!":
 ++++++++[|++++>[|++>|+++<<|+++|>|+>|-<]|+>|+<<|->|+>|-<<]|>|.>|---.+++++++..+++.<|.|<|-.|.+++.------.--------.>|+.<|++.
== External resources ==
* Haskell implementation
Category: 2018
Category: Brainfuck derivatives
Category: Cell-based
Category: Implemented
Category: Languages
Category: Multi-dimensional languages
Category: Turing complete
InfiniTUM

InfiniTUM is a language made by User:iconmaster that stands for Infinite TUring Machine. It is a language that describes Turing machines with one twist: there is an infinite tape with infinite values, and the head has an infinite number of states. Rather than rulesets, state and value change is dependant on mathematical expressions.
== Description ==
An InfiniTUM program is a series of if statements: If the state is in a range, set the state and the value to the result of an expression, and then move the head. They are structured like this:
 IF condition
 STATE state_expression
 VALUE value_expression
 MOVE direction
The first three arguments, condition, state_expression and value_expression, must be mathematical expressions, and the last one must be either <, >, or X. The first argument is the condition to check. If it is true, the machine sets the head's state to the second argument, the value under the head to the third, and moves the head based on the fourth. The following variables may be used:
* s: the head's state number.
* v: the value under the head.
If the MOVE statement is a <, it moves the head to the left; if it is >, it goes to the right; if it equals X, the program halts.
The tape is initially filled with all 0's, and the state is 1.
== Examples ==
Counts up forever:
 IF s != 0
 STATE s+1
 VALUE s
 MOVE >
==Interpreter==
* Common Lisp implementation of the InfiniTUM programming language.
Category:Languages
Category:Implemented
Category:2011
Category:Turing complete
InfiniTick

Description
InfiniTick is an esolang created in 2017. It is a descendant of the Tick language. It twist is that the program runs in an infinite loop, making it hard to stop. It runs on an infinite memory of tape cells.
How the program runs
The commands are executed from the start of the tape.
 >>+*>>-<-
 ^
When the executor reaches the end of the tape, it loops back to the beginning.
 >>+*>>-<-
 ^<------^
Commands
Command	Description
> 	Move the data selector right
< 	Move the data selector left
+ 	Increment the current data cell. Truncate overflow: 255+1=0
- 	Decrement the current data cell. Truncate underflow: 0-1=255
* 	Add the ASCII value of memory cell at the data selector to the output stream
& 	Raise an error, i.e. stop the loop
/ 	Skip the next command if the current data cell value is zero
\ 	Skip the next command if the current data cell value is non-zero
==Examples==
===Hello, world!===
This program outputs the message “Hello world!” once and terminates the program by aid of an error:
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 *+++++++++++++++++++++++++++++*+++++++**+++*>+++++++++++++++++++++++++++
 +++++*<++++++++*>+++++++++++++++++++++++++++++++++++++++++++++++++++++++
 ++++++++++++++++++++++++*+++*>++++++++++++++++++++++++++++++++++++++++++
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*>++++
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 ++++++++++++++++++++++++*>+++++++++++++++++++++++++++++++++*&
===ASCII character list===
The following program prints all ASCII characters in their codes' natural order, helming the termination by conditionally checking for a non-zero current cell value:
 *+\&
==Interpreter==
* Common Lisp implementation of the InfiniTick programming language.
Category:LanguagesCategory:Cell-basedCategory:2017Category:Implemented
Infinifuck

infinifuck is a brainfuck derivative created by User:Quelklef. It is exactly equivalent to brainfuck, except for the following differences and/or clarifications:
# Cells are unbounded nonnegative integers
# - has no effect if the target cell is 0
# The tape is unbounded both to the left and the right
# On EOF, , will zero out the target cell
# Output via . treats the target cell as modulo 128
infinifuck is designed to be like brainfuck, but be an easier target to compile to.
There is an infinifuck interpreter built-in to esoglot.
=== Compilation ===
Infinifuck may be compiled to (certain implementations of) brainfuck via the replacements listed in the table below. PREAMBLE must be prepended to the resulting brainfuck code (this means that infinifuck is not quite a Trivial brainfuck substitution, though it wouldn't be hard to turn it into one).
The target brainfuck implementation is expected to have a doubly-unbounded tape with 7-or-more-bit wrapping cells and for , to, on eof, either zero out the current cell or have no effect.
Details of how this works can be found here.
infinifuck instruction	equivalent brainfuck instructions
PREAMBLE 	>>>+
> 	[>>>]>>>[-]+
< 	<<<<<<<<<[<<<]>>>[-]+
+ 	>+[>+<-<->>[-<+<+>>]<[->+<]+<[>-<[-]]+>[->>>+<[>-<-]+>[<->->>[[>>>]>+>>]<<[-<<<<[>>[->>>+<<<]>+<<<-<<<]>]<+>]<->]<-[>+<[-]]+>]<[<<<]>>>
- 	[>>>]<<<[->>[-<+<+>>]<<[->>+<<]>[<+>[-]]<[->+<]+>>>>[-<<<+>>>]<<<<->[<+>[-]]<[->+<]+<<<]>>>>[-<->>[-<+<+>>]<<[->>+<<]+>>>>+<<<[[-]>>>-<<<]>->>]<<<<[<<<]>>>
[ 	[>>>]<<<[->>[-<+<+>>]<<[->>+<<]>[<+>[-]]<[->+<]+>>>>[-<<<+>>>]<<<<->[<+>[-]]<[->+<]+<<<]>>>>[-<
] 	[>>>]<<<[->>[-<+<+>>]<<[->>+<<]>[<+>[-]]<[->+<]+>>>>[-<<<+>>>]<<<<->[<+>[-]]<[->+<]+<<<]>>>>]<
, 	[>>[-]>]<<<[<<<]>>>>>,<<
. 	>>.<<
Category:Languages
Category:2020
Infinite-noise automata

Infinite noise automata, abbreviated INA, is a model of computation made by User:RainbowDash. That, given enough time, can perform a required computation it does this by generating an endless stream of digits based on an initial seed. Here, "infinite noise" simply refers to a continuous stream of digits that is fluctuated by a starting seed.
A simple explanation of an infinite noise automata:
* The machine takes one or more digits as a seed, this is the input.
* Using a given function on the input it creates a stream of digits. Each digit produced is a "Generation"
* Read certain generations in certain orders for your output.
Let it be noted that, infinite noise automatas can not halt based off of the seed, they can only be halted at a generation given at the start.
==Further explanation==
These machines range from hyper-specific to very broad in their use. Each machine is defined by a function, that is applied every generation. The output of that function is the output for that generation. The machines can include registers to store numbers and aid in the creation of generations. 
For example, to build a INA that can add or subtract from a number, create a PRNG based on the generation number that either increments or decrements the starting number every generation. then find a generation that adds or subtracts a specific target value from the starting number. You can then run the INA until it reaches that generation to perform the desired calculation.
==Instructions on the use of the machine.==
To make a INA useful, you'll need to identify the correct generation for your output. 
You can use another machine to search each generation with specific inputs.
If a generation’s output matches against a reference truth table, you have found the right one. 
Once you have identified it, run the INA then, let it progress to that generation, and read the output.
You can use Combinational logic by stringing INA's outputs to other INAs inputs to increase the usefulness of the machines.
</pre>
==Examples of infinite noise automatas==
===== Logic Gate Machine JS =====
This is an infinite noise automata that generates every logic gate possible, in a linear fashion. This example also showcases a generation that simulates a NAND gate.
const gen = 39
for (let i = 0; i < 4; i++) {
 console.log(i.toString(2).padStart(2,'0'),":",logicGatesINA(i,gen))
}
function logicGatesINA(seed,generations) {
 let num;
 for (let i = 0; i < generations; i++) {
 let length = Math.floor(Math.log2(i + 1)) + 1;
 num = i - (Math.pow(2, length - 1) - 1);
 //console.log((num >> position) & 1) Print out each generation
 }
 return (num >> seed) & 1
}
Category:Computational modelsCategory:2024
Infinite loop

An infinite loop is a program that loops infinitely, never stopping.
For example, the C program below:
 main(){main();}
is an infinite loop.
That is an example of using recursion.
Another example using unconditional jumps:
 main() {
 a:
 goto a;
 }
Another using loops
 main() {
 while(1);
 }
Or, in pseudocode:
 Forever:
 #we have nothing here
==Implementability==
Most languages which support loops can create an infinite loop via ensuring that the loop's termination condition will never be satisfied. However, there are some exceptions:
* Some languages only support loops whose number of iterations is predictable in advance (e.g. wikipedia:BlooP). These languages tend to be primitive recursive. (The lack of an infinite loop inherently implies that a language is not Turing-complete.)
* Some languages use a mechanism to ensure that all programs terminate (such as a finite supply of some resource that's required to run commands). Creating an intended-to-be-infinite loop in such a language will cause it to suddenly halt during some iteration of the loop.
* Some languages have a built-in infinite loop detection (e.g. Incident), and will break out of a loop if they detect one. It is, however, often still possible to create an infinite loop in these languages via making it sufficiently complex that the language's infinite loop detector cannot detect it; but if the language's computational class is low enough (e.g. a finite state automaton), it's possible for the infinite loop detector to be perfect and thus for there to be no way to elude it.
* Some languages are reversible. In this case, if it's possible for a program to enter an infinite loop (but it does not start in one), reversing program flow would break out of the loop after the number of iterations that had occurred so far. As such, an infinite loop in such a language must contain some sort of iteration counter (either directly or encoded in some way), unless the entire program is trivially an infinite loop; and in some languages (e.g. BackFlip, which has finite storage), such a counter is impossible to implement.
There might also be other reasons for which an infinite loop is impossible despite the language containing general-purpose looping constructs.
==See also==
* Infinite loop (esolang)
* 0 Bits, 0 Bytes
Category:Program forms
Infinite loop (esolang)

Infinite loop (esolang) is an esolang created by User:None1.
==Commands==
There is only 1 command: [CODE], which executes CODE forever. Other characters are NOPs.
Since it just has commands for infinite loop, it has no I/O and is completely unusable for programming.
==Examples==
===Infinite loop===
 []
another one:
 [][]
and another one:
 
and another one:
 [:D]
fifth: 
 [囸你妈，退钱！]
sixth: 
 [锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷]
seventh: 
 [[[[...]]]]
8th:
 [Technically, there are infinitely many infinite loops.]
==Interpreter==
===Python===
prog=input()
prog=.join(filter(lambda x:x in '[]',prog))
n=0
for i in prog:
 if i=='[':
 n+=1
 else:
 if not n:
 raise Exception('Unmatched ]')
 else:
 n-=1
if n:
 raise Exception('Unmatched [')
if prog:
 while 1:
 pass
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:No IO
Category:Implemented
Infinite state machine

An infinite state machine is a state machine with countably infinitely many states.
== Turing completeness ==
A Turing machine has three stateful components; the infinite tape, the infinite tape pointer (head), and the finite state register.
Any arbitrary Turing machine can be converted into an infinite state machine by directly translating the states into the infinite state machine. With this, the lower part of the infinite state register represents the finite state register of the Turing machine.
The higher part of the infinite state register is split into two arbitrarily large sections, one for the infinite tape, and the other for the infinite pointer.
The infinite state machine's infinite state space is then filled with countably infinitely many copies of the finite states, such that there exists one copy for each combination of infinite tape state and infinite head state.
With this, all modifications to the head, and tape, are representable by state transitions alone. Reads are constant, for any given state a read will always return the same result, as it is simply a portion of its state number, which is unchanging. Writes are large-distance transitions. Local transitions correspond to transitions in the original FSM which have no write.
If some omnipotent being were to follow this guide (or a finite being approximating it), care must be taken to ensure that all loops are translated properly. Loops generally will not only transition between local states (as that will initiate an unending loop), but also to longer distance states which represent changes to the head and/or tape.
== Handling input ==
Input can be handled by encoding all possible inputs that can be entered into the infinite state space. E.g. consider the user inputs a true bit. State ...72 receives this, then transitions to ...73 (in the copy/universe where the input is true) if it were false then it would transition to ...73 (in the universe where it is false). Input is the only type of conditional transition that cannot be baked into the states.
== Turing equivalence ==
It can also be proven that arbitrary infinite state machines can be mapped onto Turing machines. Split up the infinite tape into countably infinitely many chunks of arbitrarily large size. Each of these chunks contains the state's transition rule. For an infinite state machine without input, only one arbitrarily large number is required to encode the transition rule. For an infinite state machine with input, two are used, one for if the input is true, and another for false.
If the Turing machine begins at the tape location denoting state 0, it can perform an arbitrary multiple of an arbitrary number of moves in order to reach any of the infinite states. This can be thought of as a limit of a compiled program, with the size of the chunks approaching infinity.
Category:Computational models
Category:Turing complete
Infinity

Infinity is a concept of something beyond any finite number. An infinity can either describe size, where it's called a cardinal infinity, or place, where it's called an ordinal infinity. While there are multiple levels (infinitely many, in fact), the term "infinity" is often used to mean any of the infinities, especially when it doesn't matter which infinity is used.
Many esoteric programmers seem to have a torturous relationship with infinity. It could be said that mathematicians embrace infinity, engineers aggrieve it, and programmers, being both mathematicians and engineers, are obliged to ignore it lest their heads explode.
Several computational models reference infinity as part of their description - for example, the length of the tape of a Turing machine, or the (maximum) size of the stack of a push-down automaton.
To please strict constructionists who object that they just can't afford that much tape, these structures may also be described as unbounded - meaning that they are finite, but may grow when needed without limit. This, of course, acts exactly the same as having an infinite tape to begin with, so the concepts are equated in the far, far, far majority of cases.
There also exist models of computation where the program is represented as infinitely many non-dynamic instructions. Such a program is termed transfinite. Note that such a program is equivalent to having a source file of infinite size, rather than simply having an infinite loop (which corresponds to infinitely many dynamic instructions).
==External resources==
* Wikipedia:Infinity
Category:Concepts