nyuuzyou/wikis huggingface dataset:
Minsky Swap

Minsky Swap is an esolang based on Minsky machines and created by User:PythonshellDebugwindow.
==Memory==
Programs in Minsky Swap have access to two unbounded registers; however, only one of these registers can have "focus" at a time. The current register is pointed to by a register pointer.
==Syntax and Semantics==
Minsky Swap code is split onto two lines. The first line is the actual code to be executed and is known as the code line, and the second line contains a list of numbers and is known as the jump line. The code line is split into characters, each character being a command; the commands are listed below.
Command	Effect
+ 	Increment the register under the register pointer
~ 	If the register under the register pointer is nonzero, decrement it; otherwise, jump to command M, where M is the Nth number in the jump line and this ~ is the Nth tilde in the code line
* 	Swap the register pointer between the first and second register
==Readable Minsky Swap Notation==
Readable Minsky Swap Notation (RMSN) is a more readable notation for Minsky Swap. It is reminiscent of Portable Minsky Machine Notation. In RMSN, each command is on one line. inc(); increments the current register; decnz(N); decrements the current register if it's nonzero, and jumps to line N (1-based) otherwise; and swap(); swaps the register pointer.
==Computational class==
Minsky's 2-register machine (sec 14.1 of Computation: Finite and Infinite Machines ) uses 2 registers, r, and s
and has 4 commands in its most basic form:
* r+ : inc(); for register 1: r
* r-(n) : decnz(N); for r (jump happens iff register IS zero)
* s+ : inc(); for register 2: s
* s-(n) : decnz(N); for s (jump happens iff register IS zero)
Any Minsky 2-register machine code can be translated unambiguously to Minsky Swap as follows:
2-reg MM	MS
r+ 	+
r-(N) 	~(N)
s+ 	*+*
s-(N) 	*~(N)
Furthermore, for every target N of any jump, insert a double-swap / no-op: **.
For any 2-reg MM source code, there will be a finite number of these. As a no-op, they do not affect the program behaviour.
Then adjust the N of every jump instruction to point to the first * (swap) if it is a r- or to the second * (swap) if it is a s-.
This way the intended r or s register is always correctly targeted for any possible path through the code, and the various decnz(N) have a fixed register every time they are encountered.
This adding of no-ops to jump targets is probably unnecessary for Turing completeness. If anything, allowing the same block of code to target either register 1 or 2 depending on how it was jumped to gives the language more flexibility and reduces the amount of code needed to get a potential effect, but it makes it harder to reason about. Adding the no-ops and fixing the target registers so that register 1 is always current upon entering and exiting a composite-command makes the 2-reg Minsky machine translation clear. 
==Implementations==
A Python interpreter by User:Bangyen.
Category:Languages Category:2020 Category:Implemented Category:Turing complete
Minsky machine

A Minsky machine is a finite-state automaton with access to a number of unbounded registers or counters. These registers can be thought of as monosymbolic stacks (i.e. stacks of all the same symbol.)
===General Minsky machine===
In a general Minsky machine, two operations are available on each register:
* increment it; and
* decrement it unless it is zero, in which case follow an alternate state transition.
Minsky machines with two or more registers have been shown to be in the same computational class as Turing machines. Because of this, and because of their simplicity, they can be used to prove several esoteric programming languages to be Turing-complete as well.
The canonical reference is Minsky's book, Computation: Finite and Infinite Machines (Prentice-Hall International, 1967; ISBN 0131655639), in which he calls these machines program machines. 
A proof of Turing-completeness is also given in the textbook Aho, Ullman, The Theory of Parsing, Translation, and Compiling, (1972; ISBN 0139145567).
===The section 14.2 Minsky machine===
In section 14.2 of Minsky's book, he also describes a variation which is Turing-complete with only one register; this variation requires that the machine has operations to:
* multiply the register by a constant; and
* check to see if it is divisible by a constant, and if so, divide by that constant and effect an alternate state transition.
Multiplying and dividing a number 2^x 3^y by prime numbers 2 and 3 is computationally equivalent to incrementing and decrementing x and y respectively. Checking for divisibility is the same as checking if x and y are equal to zero, since p^0 is not divisible by p (as long as p \neq 1). Therefore, a Minsky machine with functions for multiplication and conditional division can simulate any two-register Minsky machine, which can simulate any Turing machine and is thus Turing complete.
The section 14.2 Minsky machine has been used to demonstrate the Turing-completeness of FRACTRAN.
==See also==
* OISC
* Portable Minsky Machine Notation
* Szewczyk notation for Minsky machine
* Generalized Minsky machine, a generalization allowing an arbitrary universe of recursive polynomial types instead of just \mathbb N.
* Alternating 1-based Minsky machine
* Mel
* Gregušová-Korec universal Minsky machine
* Short Minsky Machine Notation
* Pointer-based Minsky machine
==External resources==
* 
* 'Counter machine' article at Wikipedia
* 'Minsky register machine' article at Wikipedia
* Explanation of the one-register Minsky machine 
Category: Computational models
Minskyfuck

Minskyfuck is an esolang made by User:Otesunki (talk) based loosely on Minsky machines. It has two registers called R1 and R2.
==Commands==
Command	Meaning
+ 	Increment R1.
++ 	Increment R2.
- 	If R1 is non-zero, decrement it and try to branch, otherwise, leave R1 unchanged.
-- 	If R2 is non-zero, decrement it and try to branch, otherwise, leave R2 unchanged.
< 	Take one ASCII character of input, and put it in R1.
<< 	Take one ASCII character of input, and put it in R2.
> 	Output the value in R1 as an ASCII character.
>> 	Output the value in R2 as an ASCII character.
? 	If currently branching, jump to matching :
: 	If not branching, halt.
( 	Marker for ), does nothing.
) 	If currently branching, jump to matching (
All other characters are comments.
==Code examples==
=== Hello World ===
 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 --+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-
 -+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-->+--+--+--+--+--+--+-
 -+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-->+--+--+--+-
 -+--+--+-->>+--+--+-->-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++
 -++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-
 ++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++>-++-++-++-++-
 ++-++-++-++-++-++-++-++>+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 --+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-
 -+--+--+--+--+--+--+--+--+--+-->+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-
 -+--+--+--+--+--+--+--+-->+--+--+-->-++-++-++-++-++-++>-++-++-++-++-++-++-++-++
 >-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++
 -++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-
 ++-++-++-++-++-++-++-++-++-++-++-++-++-++-++>
=== Truth Machine ===
 <++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-
 ++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-++-?--+--+--+
 --+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-
 -+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+>:--+--+--+--+--+--+--+
 --+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-
 -+--+--+--+--+--+--+--+--+--+--+--+--+--+--+(+>-)
== Interpreters ==
Javascript (JsFiddle), although it doesn't handle I/O correctly.
Category:Languages Category:Imperative paradigm Category: Unknown computational class Category:Usability unknown Category:Implemented
Minus

== Overview ==
Minus is a language created by Darren Smith. At its core there is only one instruction, similar to -= in C. This gives it a passing similarity to OISC (using Subleq). However, branching and I/O in Minus are implemented using some additional special variables.
== External resources ==
A more complete description, interpreters, a compiler and sample programs, plus a minimal self-interpreter can be found 
Category:Languages
Category:Turing complete 
Category:Implemented
MinusGreater

-> is a lang made by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff. its like Thue but in the order you set it to. also ::= is now -> . At the end, is the program state, however the first letter is not included. If it is L, the program loops to the start. escape characters (\n for newline, \i for input, \\, for backslash, and \> for -> can be used) also, \p after -> will print the string before the program ends
==programs==
===number program:===
 ********** -> T
 ********* -> 9
 ******** -> 8
 ******* -> 7
 ****** -> 6
 ***** -> 5
 **** -> 4
 *** -> 3
 ** -> 2
 * -> 1
 T| -> T0|
 1| -> |1
 2| -> |2
 3| -> |3
 4| -> |4
 5| -> |5
 6| -> |6
 7| -> |7
 8| -> |8
 9| -> |9
 0| -> |0
 T -> *
 || -> 
 L|\i|
===hello world===
 \pHello, World!
===truth-machine===
 1 -> 1\p1
 L\i
Category:String-rewriting paradigm Category:Languages Category:Unimplemented
Mirror-machine

A Mirror-machine is an extremely simple program type invented by User:ReplayShells to check decision, addition, subtraction, loops, input and outputs.
Process:
*Input vars a,b (b is unsigned.)
*Increment a
*Decrement b
*If a is not 0:
**Print a
**Set a to 0
*If b is not 1:
**Print b
*While b is not 0
**Print b
**Decrement b
*Input a,b
*Print a - b
*Print </code>ABC</code>
*Terminate program
The program, when expressed in pseudocode, adheres to the following principles:
 a ← input integer, where a ∈ ℤ
 b ← input integer, where b ∈ ℤ ∧ b ≥ 0
 
 a ← a + 1
 b ← b - 1
 
 if a ≠ 0 then
 print a
 a ← 0
 end if
 
 if b ≠ 1 then
 print b
 end if
 
 while b ≠ 0 do
 print b
 b ← b - 1
 end while
 
 a ← input integer, where a ∈ ℤ
 b ← input integer, where b ∈ ℤ ∧ b ≥ 0
 
 print a - b
 
 print "ABC"
 terminate program
==Implementations==
===C===
#include <stdio.h>
int main(void)
{
	int a;
	unsigned b;
	scanf("%d %u", &a, &b);
	++a;
	--b;
	if(a != 0)
	{
		printf("%d\n", a);
		a = 0;
	}
	if(b != 1)
		printf("%u\n", b);
	while(b != 0)
	{
		printf("%u\n", b);
		--b;
	}
	scanf("%d %u", &a, &b);
	printf("%d\n", a - b);
	printf("ABC\n");
	return 0;
}
===Phile===
 OPEN "stdin.stream";
 OPEN "stdout.stream";
 OPEN "a";
 OPEN "b";
 /// Input variables a, b.
 OVERWRITE "a" READ "stdin.stream";
 OVERWRITE "b" READ "stdin.stream";
 /// Increment a.
 OVERWRITE "a" READ "a" + 1;
 /// Decrement b.
 OVERWRITE "b" READ "b" - 1;
 /// Test of a.
 READ "a" = 0? 11;
 OVERWRITE "stdout.stream" READ "a" + "\n";
 OVERWRITE "a" 0;
 /// Line 11:
 /// Test of b.
 READ "b" = 1? 13;
 OVERWRITE "stdout.stream" READ "b" + "\n";
 /// Line 13:
 /// While loop.
 READ "b" = 0? 17;
 OVERWRITE "stdout.stream" READ "b" + "\n";
 OVERWRITE "b" READ "b" - 1;
 READ "b" ! 0? 13;
 /// Line 17:
 /// Input a, b.
 OVERWRITE "a" READ "stdin.stream";
 OVERWRITE "b" READ "stdin.stream";
 /// Print a - b.
 OVERWRITE "stdout.stream" READ "a" - READ "b";
 OVERWRITE "stdout.stream" "\n";
 /// Print "ABC".
 OVERWRITE "stdout.stream" "ABC" + "\n";
 /// Terminate program.
 CLOSE "stdin.stream";
 CLOSE "stdout.stream";
 CLOSE "a";
 CLOSE "b";
=== Python ===
a, b = int(input()), int(input())
a += 1
b -= 1
if a != 0:
 print(a)
 a = 0
if b != 1:
 print(b)
while b != 0:
 print(b)
 b -= 1
a, b = int(input()), int(input())
print(a-b)
print("ABC")
=== Rec ===
R/R\
[1:^1:P0 1;0^]
[0:\^0:P0^]
[0:^0:P\]
R1;R0;
[0:^\1:\1;]
[^]P
65p 66p 67p
Category:Program forms
Miscmisc2

miscmisc2 is a low-level esolang made by User:Transoptimal with the goal of making a language that both isn't too inconvenient to use, and has a small set of instructions.
== Memory ==
The memory is an array of integers that starts at index 0 and extends infinitely in the positive direction.
The value stored in the first memory cell is called the pointer, or P for short.
Input and output handling is implementation-specific. A reasonable default choice might be using a queue for input and a stack or text string for output.
== Execution ==
To prepare a program to be executed:
# Write the number 0 to every memory cell.
# Write the program's source code to the memory, starting at index 0.
The execution cycle consists of these steps:
# If P is less than 1, or all the cells with an index greater than or equal to P contain the number 0, halt execution.
# The instruction stored in the cell at P (that is, the instruction pointed to by the pointer) is executed.
# If step 2 did not change P, P is incremented by 4.
== Instructions ==
The instructions are written as their corresponding Unicode characters, with their character codes in parentheses, for convenience. (This is also how they were chosen.)
For explaining the instructions, the symbols A, B, and C will be used to represent the cells at index P plus 1, 2, and 3, respectively.
 ! (33) - Write the value of A, to the cell pointed to by B. Increment P by 3.
 & (38) - Write the value of the cell pointed to by A, to the cell pointed to by B. Increment P by 3.
 + (43) - Add the values of A and B, and write the result to C.
 - (45) - Subtract the value of B from the value of A, and write the result to C.
 ? (63) - If the value of A is positive, set P to the value of B. If the value of A is negative, set P to the value of C.
 . (46) - Read the next input value and write it to A. Increment P by 2.
 , (44) - Write the value of A to the output. Increment P by 2.
All other instructions are no-op.
== Examples ==
=== Hello world ===
 1 44 72 44 101 44 108 44 108 44 111 44 32 44 119 44 111 44 114 44 108 44 100 44 33
Outputs "Hello world!" in character codes.
Replacing numbers whose corresponding character is non-whitespace with that character, this is:
 1 , H , e , l , l , o , 32 , w , o , r , l , d , !
=== cat ===
 1 46 0 38 2 17 38 2 10 63 0 16 13 33 0 0 44 0 33 1 0
Assuming that the input implementation treats nonexistent inputs as the number 0, this outputs the entire input, then exits.
Replacing numbers that are instructions and not no-op with their corresponding characters, we get:
 1 . 0 & 2 17 & 2 10 ? 0 16 13 ! 0 0 , 0 ! 1 0
===Truth-Machine===
A truth-machine is implemented in the following:
 1 46 0 38 2 10 38 2 12 44 0 63 0 9 0
==Interpreter==
* Common Lisp implementation of the miscmisc2 programming language.
Category:Low-level Category:Languages Category:Implemented Category:Cell-based
Miser

Miser is an esolang created by User:None1.
==Syntax==
There is only one command:
 I want to borrow $x from you.
Where x is a number.
Which prints out:
 $x is too much.
Other strings print out:
 I can't understand that.
==Example Programs==
===Quine===
 I can't understand that.
==="It's too much to even have a negative number of currencies"===
 I want to borrow $-27518057625706208271578295705697150471962198729561205295728956129837 from you.
==Interpreter==
* Common Lisp implementation of the Miser programming language.
Category:Languages
Category:Joke languages
Category:Implemented
Category:Total
Category:Unusable for programming
Category:2023
Category:Output only
Mishmash

Mishmash is a Idea developed by User:Singingbanana. There are three commands: A, X and output, but it also contains 2 variables: one and two. On initialization, one is 1 and two is 2. Operator A makes one equal to two. Operator X takes 2 arguments(x & y) and adds x to one and y to 2. Output outputs one & two.
==Examples==
1+2 and 1 + 7:
X(2,7)
Add more!!!
==Implementations==
Python 2.7 & 3.n
def a():
 global one
 global two
 one = 1
 two = 2
 one = two
def x(y, c):
 global one
 global two
 one = one + y
 two = two + c
def output():
 print(one, two)
global one
global two
one = 1
two = 2
More to come when author learns other languages!
==Computational class==
It has bounded memory. We can move up and down, write 1 and 0, but can we erase? Is writing Zero the same as deleting?
But philosophical questions aside, the language currently does not include any form of loop or recursion, so sadly it cannot handle even a truth test. It is therefore a lower class than a finite state machine.
Category:2018
Category:Languages
Miw

Miw is Questa-based language by ChuckEsoteric08.
==Commands==
You need to input commands which initialize stack before program itself.
Command	Meaning
0-9 	Push that number to questa
> 	Move element on bottom to top
+ 	Pop a and b from bottom of questa. Push it sum on bottom
< 	Pop element from top of questa
! 	If element on top of questa is 0 back to start of program
? 	If element on bottom of questa is 0 back to start of program
* 	increment bottom of questa
- 	decrement bottom of questa
= 	pop element on bottom of questa
==Computational class==
It is turing-complete, because it can simulate minimized Brainpocalypse.
Brainpocalypse 	Miw
Start of program	Initial stack of 256 0s
} 	>*
- 	?-
Category:Languages Category:Turing complete
Moanfuck

Moanfuck is a joke brainfuck clone implemented by Razetime with Sinthorion's idea. It uses sounds that people make during s*x as commands. It belongs to the TrivialBrainfuckSubstitution family of languages, since it doesn't deviate from brainfuck in terms of it's commands.
It uses the following commands:
+ AH
- OH
> YES
< FUCK
, MORE
. YEAH
[ AHH
] OOH
# BABY (debug breakpoint)
All commands must be separated by spaces for parsing. Parsing is case-insensitive.
If any given command is not in the list, then the command with the closest edit distance is taken. Hence, you can run any porn script(Or piece of english literature) in moanfuck, and see its results.
==Interpreter(Javascript)==
Moanfuck implementation in js
It can be run on the JavaScript(V8) interpreter at Try it online!
==See Also==
* PenisScript
* Dick
* Brainfuck
Category:Brainfuck equivalents
Category:Brainfuck derivatives
Category:Thematic
Category:Cell-based
Category:Joke languages
Category:Turing complete
Category:Implemented
Category:Low-level
Category:2020
Category:Pseudonatural
Category:Turing tarpits
Category:Languages
Mobius

Mobius is an esoteric programming language created by user:David.werecat which reads images as program code, executes in two dimensions, and has only audio output. It stands alongside URSL, Macmac and VTL as languages that were all created on the same day, which was when the author had a streak of insanity and created 4 languages in one day.
== Instructions ==
The code is loaded as an image. Multiple formats are supported (maybe the next iteration will support layers/frames for three dimensional code). Since the JPEG format is supported, this is probably the first language that allows source code to be stored in a lossy format. The execution begins at pixel (0,0) moving east. If the side of the image is hit, the execution direction is reversed. All memory is on a Mobius strip of 64 bits. When a bit crosses the edge of the 64 bits, the reverse of the bit appears on the other side. Instructions are based on color conditions and are as follows:
Condition	Description
R=G=B 	Toggle the current bit
R>G R>B 	Turn 90 degrees clockwise
G>R G>B 	Shift strip left
B>R B>G 	Shift strip right
R=G R>B 	Beep at 500Hz
R=B R>G 	Skip next instruction if the current bit is 1
G=B G>R 	If the current bit is 0, beep at 600Hz; otherwise beep at 700Hz
== External resources ==
* Visual Basic .NET interpreter and NO sample programs
Category:Languages
Category:2012
Category:Implemented
Category:Two-dimensional languages
Category:Cell-based
Category:Output only
Category:Non-textual‏‎
Category:Unusable for programming‏‎
Category:Finite state automata
Mobius brainfuck

Mobius brainfuck is like brainfuck with finite unbounded cells. After one circle every number turns into its opposite. This allows to use only increment to decrease without wrap.
==Instructions==
 Caption text
Char	Equivalent C
+ 	arr[ptr]++;
> 	arr[ptr++]*=-1;ptr%=N;
[ 	while(arr[ptr]){
] 	}
IO can be added if necessary.
==Turing complete==
Should be TC for large enough N but I don't know how large need N be.
==Interpreter==
Written in JavaScript. Contains an optional output extension.
function mobius_brainfuck(program, N, useOutput=true) {
 let result = `const arr = Array(${+N}).fill(0); let ptr = 0;`;
 if(!useOutput)
 program = program.replace(/\./g, "");
 result += program.replace(/[^+>\[\].]/g, "")
 .replace(/]/g, "}")
 .replace(/\[/g, "while(arr[ptr]){")
 .replace(/\+/g, "arr[ptr]++;")
 .replace(/>/g, `arr[ptr++]*=-1;ptr%=${+N};`)
 .replace(/\./g, "console.log(arr[ptr]);");
 eval(result);
}
Category:Languages
Category:Brainfuck derivatives
Category:Turing complete
Category:Turing tarpits
Category:Cell-based
Category:Unimplemented
Category:2024
Moditape

An esolang where you can modify the inital state of the circular, 16 value tape before the program is run. Contains brainfuck-like syntax, minus the loops. Because there are no I/O functions, you can watch the tape update as the program runs. Modifying the tape before the program runs can act as input.
= Instructions =
The instructions are as follows:
Command	Description
[ 	Shift pointer left
] 	Shift pointer right
| 	Increment cell under pointer
_ 	Decrement cell under pointer
: 	Reverse the tape
# 	Exit the program
& 	Set the pointer to the cell value
? 	If cell is 0, skip next instruction
= Hello World =
H]e]l]l]o],] ]W]o]r]l]d]!
= Truth machine =
_?#|]|]|]|]|]|]|]|]|]|]|]|]|]|]|]|]
(To use, set the first cell to 1 or 0 before starting the program.)
= 99 Bottles Of Beer =
 |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
 ]b]o]t]t]l]e]s] ]o]f] b]e]e]r]!]
 [[[[[[[[[[[[[[[[
 ___________________________________________________________________________________________________
= Reference Interpreter (Written in C, yes the code is bad) =
https://paste.snwy.me/lghajYnP
To use the interpreter, pass in your file as so: 
 moditape file.mt
Once you are in, you will see the tape. Use the left and right arrow keys to move the pointer, and up and down to increment/decrement. 
The pointer will stay at the position you leave it when you run the program.
To run the program, press Enter.
Category:Cell-based Category:Brainfuck derivatives Category: No IO Category:Implemented Category:2021 Category:Languages Category:Total
ModulR

ModulR is a language where there're only unbounded registers(ModulR) to store data and the only operation is the modulo(ModulR)
All registers initilize with 0. x%0 = 1+x.
==Commands==
the special symbol is #, which indicates how many registers you should have.
A #s at the start of the program means A registers, other #s mark line comments.
 Caption text
Command	Meaning 	Notes
+ 	increment the register pointer, wraps 	
% 	Takes an argument(number of *s after it).
modulo register at pointer with the register at the argument and store at the pointer
division quotient stores at argument register.	x/0 = x, x%0 = x+1.
[...] 	loop while pointer != 0. 	
. 	output current register value as ASCII	if 0, input and store instead.
==Example==
===Cat eof returns 0===
 ##%*[+..+]
==Computational class==
Turing-complete. ItCategory:2024 Category:Turing completecCategory:Languagesan have any amount of registers, 2 registers can simulate a stack, 2 stacks can simulate a tape. That's it.
Modulo 2

Modulo 2 is a programming language created by Cole. It is not Turing-complete.
== Objective ==
The objective of Modulo 2 is to represent all possible Boolean functions (or collections thereof) using as simple of an alphabet and as intuitive a syntax as possible.
== Symbols ==
Modulo 2 uses the following symbols:
 p ˈ 0 | \
== Semantics ==
Variables are designated by p followed by an integer number of apostrophes (can be zero).
Polish notation is used for the | operator. |ab means a NAND b. Hence the constant 1 can be represented by |00.
\ is used to separate functions in the same program.