nyuuzyou/wikis huggingface dataset:
Markov algorithm

This page is about a property of algorithms. For the string-rewriting systems, see wikipedia:Markov algorithm.
An algorithm is Markov, has the Markov property, or is memoryless, if its next state never depends on more than a fixed number of its prior states. A Markov chain is a sequence of states produced by a Markov algorithm. Markov algorithms were introduced to describe meteorology and model natural languages.
For simplicity, imagine a Markov algorithm as maintaining a sliding window of states. To generate a new state, the algorithm combines data from prior states in the window, and then advances the window to include the new state, discarding the oldest state.
Can't provide the image, but here is the link below:
https://upload.wikimedia.org/wikipedia/commons/2/2b/Markovkate_01.svg
== Markov distributions ==
Every Markov algorithm has an underlying probability distribution for the next state. This distribution is conditional on the prior states but nothing else. Knowledge of this distribution is approximate knowledge of the underlying Markov algorithm.
A Markov distribution can be used to generate Markov chains, even if the original algorithm is not known. Given an initial window of states and a random number generator (RNG), we may sample a Markov chain by repeatedly making random weighted choices of next states and sliding the window:
 states = …
 window = …
 while true:
 window.push_right(sample(states))
 window.pop_left()
== n-grams ==
A standard programming exercise is to take a hunk of text and, assuming that it was generated by some Markov algorithm, compute the Markov distribution. An introductory approach involves approximating Markov distributions with n-grams, or fragments with n words, by scanning the text and recording all of the n+1-grams. Then, treat the first n words of each n+1-gram as the window of prior states, and let the final word be the next state.
For example, a bigram is a pair of words and a trigram is a triple of words. We may approximate a Markov distribution by recording every trigram, breaking each one up into a bigram and next state, and then collecting all of the bigrams into windows. Consider the example sentence:
 a black cat and a black dog took a nap
Punctuation has been removed and capitalization has been normalized for clarity. Only one bigram appears twice, "a black"; it may be followed by "cat" or "dog". So, the Markov distribution is fairly tame, except that the window with the words "a" and "black" has a 50% chance of being followed by "cat" and a 50% chance of being followed by "dog".
== Examples ==
=== Gambler's ruin ===
* 2 has a 50% chance of going to 3 and a 50% chance of going to 1
* 3 has a 50% chance of going to 2 and a 50% chance of going to 4
* 1 and 4 have a 100% chance of going to themselves
==External resources==
* Markov chain generator
* Wikipedia has related articles: wikipedia:Markov chain, wikipedia:Markov property
Category:Concepts
MarkupL

MarkupL is an alternative universe version of the HTML language. Created by Tom Three
==Syntax==
===MarkupL syntax===
MarkupL doesn't have a paragraph tag. Which isn't that big of a deal since you can literally just add a end of line tag (or |el) to make a new line:
translated into html:
 <p>a</p>
don't forget to add another virtic () if you need to add another string next to an end of line:
translated into html:
 <p>a</p>b
and if you don't, then:
and if you need to add an id to that string. Use the operator
translated into html:
 <p id="smth">hi</p>
MarkupL also has fields
===MarkupL add-ons===
Stuley:
Interactive Script:
==Examples==
===Hello, world!===
translated into html:
 Hello, world!
===Cat program===
translated into html:
 <script>function main(){i=document.getElementById("i").value;document.getElementById("o").innerHTML=i}</script>
 <textarea id="i" placeholder="input"></textarea><button onclick="main()">submit</button><br>
 <textarea id="o" placeholder="output" readonly></textarea>
Category:Languages Category:2024 Category:Markup Languages
Markup Λanguage

The Markup Λanguage (pronounced like "Markup Language") is a combinatorial (hence the Λ, which is used in its lower case form in "λ-calculus", which is related to Combinatory logic) markup language. It is based on using combinators to make text bold, italicized, and other markupy things.
== Syntax ==
WIP
Category:Languages Category:Markup Languages
Mascarpone Joust

Mascarpone Joust is a programming game by User:BoundedBeans inspired by Core War and BF Joust.
All normal Mascarpone commands are allowed other than:
 . , @ 0 1
==Storage and execution==
There are two Mascarpone programs. They each either share or have a stack and either share or have a current interpreter. There are two main variations: SS Mascarpone Joust (stack-sharing) and IS Mascarpone Joust (interpreter-sharing). Both programs loop back to the start when finished.
==Win/Loss conditions==
A program loses when:
* it pops the string "Goodbye world!" (in the way where running "[Goodbye world!]" or "'['G'o'o'd'b'y'e' 'w'o'r'l'd'!']" with the default interpreter would push it onto the stack) for some operation. In IS it is determined by which interpreter initiated the command or operation) 
* its current interpreter becomes completely full of no-ops (SS only)
* it pushes the string "Halting..." onto the stack (this could be achieved in SS by hiding an operation inside of an interpreter on the stack that does this, to be accidentally executed by its interpreter, or in IS by hiding an operation that the attacker never uses but the victim relies on. In IS it is determined by which interpreter initiated the command or operation)
A program wins when the other loses.
==Possible strategies==
* (SS) Hide the string "Halting..." onto the stack, pushing characters with some swapping to insure it doesn't lose itself
* (SS) Find a vulnerability where the opponent deifies an interpreter, have the program force it to deify an no-op one instead (this cannot be achieved by 0 or 1, since they are banned)
* (SS) Push "Goodbye world!" and time it so that the opponent pops it for *
* (IS) Hide an operation inside of the interpreter which causes the opponent to execute something that causes them to lose
* (IS) Hide an operation inside of the interpreter which pushes an operation that the opponent will execute
* (IS) Hide an operation inside of the interpreter which pushes a string that the opponent will turn into an operation and execute
* (IS) Perform a command that sets up the opponents command to meet a losing condition, but do not run that command yourself
==See also==
* Mascarpone
* BF Joust
Category:Languages
Category:Programming games
Category:Stack-based
Category:Self-modifying
Category:Unimplemented
Math&Matrix

Math&Matrix is a language based on a matrices list. Each matrix in this list is an instruction based on math properties (determinant, invertibility, diagonal/triangle equivalant, ...)
This language is stack-based
==Syntax==
A matrix is represented with the following syntax:
*n
#,#,#,...,#
#,#,#,...,#
...
#,#,#,...,#
;
where # and n is an integer number. 
Each line begin with a number must have the same number of integer (otherwise, it return an error)
*n represent a division coefficient. Each number in this matrix are divide by n. It is the only way to make a float 
if n = 1, this line is optional
;; end the program
So, a Math&Matrix program looks like this:
1,2,3
4,5,6
7,8,9
;
*3
5,10,9,13
0,2,24,11
22,30,1,1
0,7,17,21
;
1,1,4,9
21,43,78,0
0,5,0,67
465,7483,7878,23
;
;;
==Instructions==
+, -, *, /, %, ^: pop 2 values a and b and push a op b 
push A: push A into the stack 
copy: duplicate the top value and push it into the stack 
swap i, j: pop 2 values i and j and swap the position of the i-th and the j-th element 
del: discard the top value 
instr: input a char and push the ASCII code into the stack 
outstr: pop the top value and print the char which correspond to the ASCII code 
inint: input an integer and push it into the stack 
outint: pop the top value and print it 
if C, n: pop 2 values a and b. If a C b then continue, else skip the next n instruction(s) 
for n: pop a value A. Execute the next n instruction(s) A time(s) 
while C, n: Execute the next n instructions while a C b is true. It pop 2 values at the beginning of the loop. The loop stop if the stack contain less than 2 values.
stop: stop the program
==Matrix form==
+, -, *, /, %, ^: all 2x2 matrix where opcode = det % 6 
 	0	1	2	3	4	5
opcode	+	-	*	/	%	^
push A: all non-square matrices (except 2x3) 
A = \prod_{i=1}^c(\sum_{j=1}^l m_{i,j} ) where l and c are the number of line and column in the matrix
copy: 1 rank 2x3 matrix 
del: 2 rank 2x3 matrix 
swap i, j: (not implemented yet) 
instr, inint: 4x4 orthogonal matrix 
outstr, outint: 4x4 non orthogonal matrix 
while: 3x3 matrix where the diagonal matrix equivalent have this form :
\begin{pmatrix}
C & 0 & 0 \\
0 & n & 0 \\
0 & 0 & C
\end{pmatrix}
 	0	1	2 	3 	4 	5
C	<	>	<=	>=	==	!=
for: 3x3 matrix where the triangle matrix equivalent have this form :
\begin{pmatrix}
n & * & * \\
0 & * & * \\
0 & 0 & *
\end{pmatrix}
Category:2020 Category:Stack-based Category:Languages
Mathematics (batteries included)

Mathematics (batteries included), also known as M(bi), is a language that aims to contain every possible mathematical function. As there are infinitely many possible mathematical functions, this language will never be complete, but with every new release it will further approach the perfection it aims for.
CURRENTLY UNDER VERY EARLY DEVELOPMENT
also, just a heads up, its probably going to take quite a long time, because i'm writing it in rust. and i don't know rust. so there are some issues.
Category:Languages Category:Works-in-Progress
Mathfuck

Mathfuck is a BitChanger derivative that may or may not be theoretically usable for programming, and is probably not practically usable for programming with the current state of mathematical knowledge. (Although this is uncertain)
Programs are a series of bytes, considered to be unsigned.. Bytes other than those defined below are no-ops
 Mathfuck definition
Byte value 	BitChanger equivalent
The smallest counterexample to the Collatz conjecture, mod 256	}
The smallest odd perfect number, mod 256 	<
The smaller prime of the largest twin prime pair, mod 256 	[
The larger prime of the largest twin prime pair, mod 256 	]
Category:Languages Category:Unknown computational class Category:Usability unknown Category:Cell-based Category:Brainfuck derivatives Category:Unimplemented Category:2024
Mathomania

Mathomania is a programming language created by User:usermine in 2010.
Command	Description
 /start <program name>	Used to start a script or external program.
 /end <program name>	Used to end a script or external program.
 /create <folder name>	Used to create a folder with the name specified.
 /permit <permission ID>	Used to set a permission level. There are 6 permission levels: red, orange, yellow, green, blue, black. Red can access system files, orange can modify registry, yellow can insert registry files, and green, blue, and black can edit folders and files that are not system files.
 /analyze <process ID>	Used to analyze the priority level, ID, and more details of a process.
Category:Languages
Category:Unimplemented
Category:2010
Category:Usability unknown
Matrioshka language

A matrioshka language is an esoteric programming language formed by bundling one or more meta-languages with one or more language descriptions.
Matrioshka languages can be identified by their program forms, which will have multiple, distinct 'phases' with different syntactic and semantic rules. There are often two phases; the first gives a set of rules, and the second provides objects on which those rules are to be applied. There is, however, no technical restriction of two phases; each phase could define a new language description using the rules of the previous phase, indefinitely.
Thue and ODDBALL are examples of matrioshka languages. ALPACA is not, since it is only a meta-language (i.e., the initial state of the cellular automaton cannot be given.)
The term comes from the Russian word for the so-called "nesting dolls"; by analogy, a language-within-a-language. Comparable terms might be Curried language, by analogy with Curried functions (however, this term is already [ab?]used to describe languages which support Currying), or parameterized language, which already has a [more general?] formal definition.
Category:Concepts
Matrix

Matrix is a language which is programmed through a system of matrices. It is not two-dimensional and execution is performed through the use of the minimal number of keywords and the principles of matrix algebra.
== Language Overview ==
There is a single entry point, denoted by "main" which is a matrix of undefined size. From here the elements of main can be anything from a constant double to an arithmetic operation. Doubles are the only data type Matrix accepts. There are few reserved keywords for accepting input and output.
 main The main entry point
 in Flags an element for input
 out Flags an element for out (default value of 1)
The value of out can be manipulated through matrix arithmetic. For example; the following program would print out the numbers 3, 9 and 7.
 main = {
 { print * data } 
 }
 
 print = [
 [out]
 ]
 
 data = [
 [3],
 [9],
 [7]
 ]
Notice that the matrix "main" with undefined size is encased in curly braces, where the matrices "print" and "data" have a constant size and are encased in square braces. The matrices "print" and "out" are multiplied and main is transformed into a 1x3 matrix with values 3, 9 and 7, all of which are flagged for printing and thus the output will be:
 397
The same program could be reproduced using Matrix addition as follows:
 main = { print + data }
 
 print = [out, out, out]
 
 data = [ [2, 8, 6] ]
However the values need to be reduced by 1 each in order to produce the same effect.
Execution of the elements of the main Matrix begins when it's final state has been calculated.
Matrixfuck

Matrixfuck is a superset of brainfuck made by User:Heptor, with the only change being the memory and tape is a 2-dimensional array.
==Syntax==
Instruction	Description
> 	Move the pointer forward.
< 	Move the pointer backward.
* 	Rotate the pointer 180 degrees.
% 	Rotate the reader 180 degrees.
+ 	Increment cell at the pointer.
- 	Decrement cell at the pointer.
. 	Output the pointed cell's value as ASCII.
, 	Get a character as input, and set the cell at the pointer to its ASCII value.
[ 	Jump the reader forward to the matching ] if the cell pointed to is 0. If there is no matching ], throw an error.
] 	Jump the reader back to the matching [ if the cell pointed to is not 0. If there is no matching [, throw an error.
} 	Turn the pointer 45 degrees clockwise.
{ 	Turn the pointer 45 degrees counter-clockwise.
) 	Turn the reader 45 degrees clockwise.
( 	Turn the reader 45 degrees counter-clockwise.
= 	Reflect the pointer's rotation across the X axis.
: 	Reflect the pointer's rotation across the Y axis.
_ 	Reflect the reader's rotation across the X axis.
 	Reflect the reader's rotation across the Y axis.
All other characters are no-ops.
==Notes==
* The reader and pointer start facing right at the top-left.
* Going out of the bounds of the memory board wraps the pointer on the board.
* Matching brackets can go around turns, and will not turn the pointer. For example:
 +++++[) 
 (-]
 ]
will run like this (pointer highlighted in gray):
* The bounds of the program field are set by the amount of rows and columns in the program.
* Going out of the bounds of the code ends the program.
==Computational class==
Being an extension to brainfuck, the language is Turing complete.
==Implementation notes==
* Memory bounds are square. 
* Memory cells per axis are to be kept relatively low, as you'll need the square of that in bits. Just 256 per axis is more than double the amount of bits of normal brainfuck!
* Searching ahead for a ] when the pointer value is 0 with a [, or searching behind for a [ when the pointer value isn't 0 with a ], does respect rotation and reflection.
==Implementations==
[Interpreter written in python]
Category:Languages
Category:Brainfuck derivatives
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Cell-based
Category:Two-dimensional languages
Category:2021
Category:Implemented
Matrixpone

Matrixpone is a Mascarpone derivative by User:BoundedBeans. It uses a matrix instead of a stack, but has similar operations.
==Storage==
Matrixpone has a current interpreter and a matrix. Interpreters still have parents, so this allows a stack, but since the matrix can now be accessed freely instead of LIFO, any element in the matrix can have its own stack. Since there is no popping, elements are not deleted when using them for an operation.
The matrix starts off entirely filled with the symbol @.
==Instructions==
These are in the starting interpreter and can of course be changed.
 v - Take the current interpreter and put it in the matrix cell.
 ^ - Take the currently pointer matrix cell, which should be an interpreter, and make the current interpreter that matrix cell. 
 > - extract, but the symbol should be pointed, and the interpreter should be to the right. This changes the symbol to the extracted operation
 < - install, the interpreter should be pointed, operation should be below, and symbol should be above. This replaces the interpreter
 { - get parent, replace the pointed interpreter
 } - set parent, selected interpreter should be on the right
 * - create, the interpreter should be pointed, the string should be listed left to right, starting on the cell to the right of the pointer (enclosed in matching square brackets as in normal Mascarpone)
 @ - expand, the interpreter will go on the left, and the string will go left to right starting on the cell to the right (enclosed in matching square brackets as in normal Mascarpone)
 ! - execute the pointed operation
 0 - put the null interpreter at the pointer
 1 - uniform, replace the operation with the interpreter
 [ - deepquote, puts the string left to right starting at the pointer, leaving the pointer at the first character
 ' - single quote, replaces the current cell
 . - outputs the pointed symbol
 , - inputs a symbol to the pointer's location
 ; - output a nice representation of the matrix, implementation-dependant
 : - Instruct the next direction point command to instead copy it to the cell it would normally go to. This is another interpreter.
 / - Instruct the next direction point command to instead swap it with the cell it would normally go to. This is also another interpreter.
 A - move the pointer up
 V - move the pointer down
 ) - move the pointer right
 ( - move the pointer left
Category:Languages
Category:Self-modifying
Category:Matrix-based
Category:Unimplemented
Max Demian

Max Demian is an esoteric programming language enthusiast from Huntington Beach, California.
He has written several tools to interpret, compile, encode, decode & convert different languages.
==See also==
* User:MaxDemian is Max Demian's user page on this wiki.
==External resources==
* Javascript Brainfuck Interpreter - A complete Brainfuck interpreter with debugging capabilities. Also converts Brainfuck to Javascript, PHP & Omgrofl.
* Brainloller Encoder & Decoder - A tool to create Brainloller images and to decode Brainloller images into Brainfuck code.
* Omgrofl Code Converter - A tool to convert Omgrofl code into Javascript & PHP.
Category: People
Maybe

maybe is a stack-based concatenative language created by indidee in 2024. It's not strictly an esolang, as it was designed as a forth derivative, but being stack-based it inherently has some esoteric elements.
==Example programs==
(these programs are subject to change as the interpreter/compiler is implemented)
===Hello, world!===
"Hello, world!" println .
==Standard Library==
Functions to be implemented in the Maybe stdlib
 
function name	purpose
print 	outputs the top value of the stack to stdout
println 	outputs the top value of the stack, followed by a newline character ('\n')
Category:LanguagesCategory:Usability unknownCategory:StubsCategory:ImplementedCategory:Stack-basedCategory:High-levelCategory:2024
MaybeNumericBatch

MaybeNumericBatch created by Shubshub :D
@echo off
call %1
:ans
cls
set /a ran=%random%
if /i %ran% GTR 10 goto :ans
if /i %ran% LSS 1 goto :ans
if %ran%==2 goto maybe
if %ran%==6 goto maybe
goto run
:maybe
set str=%str:?eighteen?=a%
set str=%str:?five?=b%
set str=%str:?one?=c%
set str=%str:?nineteen?=d%
set str=%str:?two?=e%
set str=%str:?four?=f%
set str=%str:?twentythree?=g%
set str=%str:?twenty?=h%
set str=%str:?fourteen?=i%
set str=%str:?sixteen?=j%
set str=%str:?twentyfive?=k%
set str=%str:?twentyfour?=l%
set str=%str:?twentyone?=m%
set str=%str:?nine?=n%
set str=%str:?twentytwo?=o%
set str=%str:?ten?=p%
set str=%str:?twentysix?=q%
set str=%str:?six?=r%
set str=%str:?three?=s%
set str=%str:?eight?=t%
set str=%str:?thirteen?=u%
set str=%str:?fifteen?=v%
set str=%str:?seven?=w%
set str=%str:?twelve?=x%
set str=%str:?eleven?=y%
set str=%str:?seventeen?=z%
set str=%str:?and?=&%
set str=%str:!q!=?%
goto run
:run
%str%
pause
It does everything NumericBatch does except it only "sometimes" works
If the random number generator lands on either 2 or 6 then it will work :D
Category:Languages Category:Implemented Category:Nondeterministic
Mayor Indbur

= Mayor Indbur =
== Types ==
=== Definitions ===
what was this?
=== Types ===
==== System ====
a stilted geometric love of arrangement
"the system" is a System of Decisions
"the system" now is {cautious, determination, determination}
==== Industry ====
an indefatigable and feverish interest in the pettiest facets of day-to-day bureaucracy
"the industry" is an Industry
"the industry" now is [This is an example document.]
==== Decision ====
a conclusion reached after a problem is considered
A Decision can be:
Value 	Definition
cautious 	indecision when right
determination	stubbornness when wrong
"the decision" is a Decision
"the decision" now is cautious
==== Organizing Method ====
a way of deciding how to organize a system
"the method" is an Organizing Method
"the method" now is the organizer
	if the left item is more detailed than the right item then
		the left item is bigger
	if not but the left item is less detailed than the right item then
		the heft item is smaller
	if not but the left item is as detailed as the right item then
		both items are equal
	if not then
		there is an error
	that's it
that's it
==== Selecting Method ====
a way of selecting certain items in a system
"the method" is a Selecting Method
"the method" now is the selector with the paramenter "the size"
	if the item is at least as detailed as "the size" then
		the item stays
	if not but the item is less detailed than "the size" then
		the item is filtered out
	if not then
		there is an error
	that's it
that's it
==== Totalizing Method ====
a way of totalizing all of the items in a system
"the method" is a Totalizing Method
"the method" now is the totalizer
	i have no idea crap
that's it
== Code Samples ==
=== Bf Tape ===
"bf tape" is a System of Industries
Category:Languages
Category:Unimplemented
Category:2017