BusyBeaverWiki - User contributions [en]

PLUSMINUS

2026-10-29T20:30:56Z

JackM1945: /* Relation to BB(n) */ made it clearer

PLUSMINUS is an esoteric programming language developed by Discord user Jack in 2026. It is a “string-based copy-automaton” that has only 2 commands, similar to its inspiration XigXag, an esoteric language developed in 2001 by Chris Pressey. Despite its extreme simplicity, its Turing Completeness is actually unknown.

== Definition ==
Let |x|=length(x). For a non-empty finite string S under the binary alphabet {+,-}, on step i=(1,2,…)

* If the i-th symbol is +, copy the first i-1 symbols and append them to the end.

* If the i-th symbol is -, delete the first i-1 symbols.

i never resets and advances each time. '''''HALT''''' when i>|S|.

== Trace Example ==
{| class="wikitable"
|+
executes 4 instructions and halts at index i=5
!Program Evolution
!i
|-
| +-++- (starting S)
|N/A
|-
| +-++- (nothing exists leftward)
|1
|-
| -++-
|2
|-
| -++--+
|3
|-
| --+
|4
|-
|<nowiki>Halt (|S|=3, i=5>3).</nowiki>
|5
|}
Halting characteristics for these programs include the following:

* The singular + halts

* ++…++ (with at least 2 +’s) never halts
* The program consisting of only - always halts for any length.

== Known Halting Time Champions ==
Below are PLUSMINUS programs of initial strings of size 1–16 and their corresponding number of “steps” until halting:

+=1

-+=3

-++=4

-+++=7

++++-=15

+++-++=18

++++---=20

--++++++=32

++++-+--+=44

+++++-+-+-=196

+++++-+--+-=913

+++-++++++-+=5940

+-++++++--++-=728

++++-++++++---=608

-+-++++++---+++=2582

+++++-++++-+-++-=31441

== Relation to BB(n) ==
We can concisely define 2 functions that both include the definition of PLUSMINUS in their definition using just over 300 characters. This version uses 1 and 0 instead of + and - for simplicity. '''It is defined as follows:'''

Let length(x)=|x|.

For n ∈ ℕ>0, convert n to its binary form B. Assuming i=(1,2,…):

If its i-th symbol is 1, copy its first i-1 symbols and append them to the end. Otherwise, delete its first i-1 symbols.

i never resets and advances each time. Halt when i>|B|.

* p(n)=min(i) such that i>|B| (or 0 if the run never halts)

* P(n)=max(p(k)) for k=(1,…,n)

== Explanation ==
The list of champions above details executed steps, while p(n) returns the instruction index when halting is detected. It is a minor difference, but it should be noted since p(n)=(number of executed steps)+1. If the PLUSMINUS run starting from the binary representation of n never halts, define p(n)=0. Halting in PLUSMINUS has not been proven undecidable/decidable. Also, ordinary binary integers never start with 0, so P(n) actually excludes all programs that begin as such.

Essentially, P(n) takes the “running maximum” of p(n), so it is non-decreasing. Out of the first 1000 inputs, 49 were unresolved under a limit of 10000 executed instructions or 2 million bits of string storage. Said computation has established that P(1000)≥134. From the halting times section, the PLUSMINUS program “+++++-++++-+-++-“ corresponds to “1111101111010110” which is “64470” in decimal. It takes 31441 “steps” to halt. Therefore p(64470)=31442 (remembering the “+1” as per p(n)’s definition) and hence P(64470)≥31442.

PLUSMINUS

2026-10-29T20:21:00Z

JackM1945: /* Explanation */ more errors fixed

PLUSMINUS is an esoteric programming language developed by Discord user Jack in 2026. It is a “string-based copy-automaton” that has only 2 commands, similar to its inspiration XigXag, an esoteric language developed in 2001 by Chris Pressey. Despite its extreme simplicity, its Turing Completeness is actually unknown.

== Definition ==
Let |x|=length(x). For a non-empty finite string S under the binary alphabet {+,-}, on step i=(1,2,…)

* If the i-th symbol is +, copy the first i-1 symbols and append them to the end.

* If the i-th symbol is -, delete the first i-1 symbols.

i never resets and advances each time. '''''HALT''''' when i>|S|.

== Trace Example ==
{| class="wikitable"
|+
executes 4 instructions and halts at index i=5
!Program Evolution
!i
|-
| +-++- (starting S)
|N/A
|-
| +-++- (nothing exists leftward)
|1
|-
| -++-
|2
|-
| -++--+
|3
|-
| --+
|4
|-
|<nowiki>Halt (|S|=3, i=5>3).</nowiki>
|5
|}
Halting characteristics for these programs include the following:

* The singular + halts

* ++…++ (with at least 2 +’s) never halts
* The program consisting of only - always halts for any length.

== Known Halting Time Champions ==
Below are PLUSMINUS programs of initial strings of size 1–16 and their corresponding number of “steps” until halting:

+=1

-+=3

-++=4

-+++=7

++++-=15

+++-++=18

++++---=20

--++++++=32

++++-+--+=44

+++++-+-+-=196

+++++-+--+-=913

+++-++++++-+=5940

+-++++++--++-=728

++++-++++++---=608

-+-++++++---+++=2582

+++++-++++-+-++-=31441

== Relation to BB(n) ==
We can concisely define 2 functions that both include the definition of PLUSMINUS in their definition using just over 300 characters. This version uses 1 and 0 instead of + and - for simplicity. '''It is defined as follows:'''

Let length(x)=|x|.

For n ∈ ℕ>0, convert n to its binary form B. Assuming i=(1,2,…):

If its i-th symbol is 1, copy its first i-1 symbols and append them to the end. If else, delete its first i-1 symbols.

i never resets and advances each time. Halt when i>|B|.

* p(n)=min(i) such that i>|B| (or 0 if the run never halts)

* P(n)=max(p(k)) for k=(1,…,n)

== Explanation ==
The list of champions above details executed steps, while p(n) returns the instruction index when halting is detected. It is a minor difference, but it should be noted since p(n)=(number of executed steps)+1. If the PLUSMINUS run starting from the binary representation of n never halts, define p(n)=0. Halting in PLUSMINUS has not been proven undecidable/decidable. Also, ordinary binary integers never start with 0, so P(n) actually excludes all programs that begin as such.

Essentially, P(n) takes the “running maximum” of p(n), so it is non-decreasing. Out of the first 1000 inputs, 49 were unresolved under a limit of 10000 executed instructions or 2 million bits of string storage. Said computation has established that P(1000)≥134. From the halting times section, the PLUSMINUS program “+++++-++++-+-++-“ corresponds to “1111101111010110” which is “64470” in decimal. It takes 31441 “steps” to halt. Therefore p(64470)=31442 (remembering the “+1” as per p(n)’s definition) and hence P(64470)≥31442.

PLUSMINUS

2026-10-29T20:20:09Z

JackM1945: Fixed grammar stuff

PLUSMINUS is an esoteric programming language developed by Discord user Jack in 2026. It is a “string-based copy-automaton” that has only 2 commands, similar to its inspiration XigXag, an esoteric language developed in 2001 by Chris Pressey. Despite its extreme simplicity, its Turing Completeness is actually unknown.

== Definition ==
Let |x|=length(x). For a non-empty finite string S under the binary alphabet {+,-}, on step i=(1,2,…)

* If the i-th symbol is +, copy the first i-1 symbols and append them to the end.

* If the i-th symbol is -, delete the first i-1 symbols.

i never resets and advances each time. '''''HALT''''' when i>|S|.

== Trace Example ==
{| class="wikitable"
|+
executes 4 instructions and halts at index i=5
!Program Evolution
!i
|-
| +-++- (starting S)
|N/A
|-
| +-++- (nothing exists leftward)
|1
|-
| -++-
|2
|-
| -++--+
|3
|-
| --+
|4
|-
|<nowiki>Halt (|S|=3, i=5>3).</nowiki>
|5
|}
Halting characteristics for these programs include the following:

* The singular + halts

* ++…++ (with at least 2 +’s) never halts
* The program consisting of only - always halts for any length.

== Known Halting Time Champions ==
Below are PLUSMINUS programs of initial strings of size 1–16 and their corresponding number of “steps” until halting:

+=1

-+=3

-++=4

-+++=7

++++-=15

+++-++=18

++++---=20

--++++++=32

++++-+--+=44

+++++-+-+-=196

+++++-+--+-=913

+++-++++++-+=5940

+-++++++--++-=728

++++-++++++---=608

-+-++++++---+++=2582

+++++-++++-+-++-=31441

== Relation to BB(n) ==
We can concisely define 2 functions that both include the definition of PLUSMINUS in their definition using just over 300 characters. This version uses 1 and 0 instead of + and - for simplicity. '''It is defined as follows:'''

Let the length of x be denoted by |x|.

For n ∈ ℕ>0, convert n to its binary form B. Assuming i=(1,2,…):

If its i-th symbol is 1, copy its first i-1 symbols and append them to the end. If else, delete its first i-1 symbols.

i never resets and advances each time. Halt when i>|B|.

* p(n)=min(i) such that i>|B| (or 0 if the run never halts)

* P(n)=max(p(k)) for k=(1,…,n)

== Explanation ==
The list of champions above details executed steps, while p(n) returns the instruction index when halting is detected. It is a minor difference, but it should be noted since p(n)=(number of executed steps)+1. If the PLUSMINUS run starting from the binary representation of n never halts, define p(n)=0. Halting in PLUSMINUS has not been proven undecidable/decidable. Also, ordinary binary integers never start with 0, so P(n) actually excludes all programs that begin as such.

Essentially, P(n) takes the “running maximum” of p(n), so it is non-decreasing. Out of the first 1000 inputs, 49 were unresolved under a limit of 10000 executed instructions or 2 million bits of string storage. Said computation has established that P(1000)≥134. From the halting times section, the PLUSMINUS program “+++++-++++-+-++-“ corresponds to “1111101111010110” which is “64470” in decimal. It takes 31441 “steps” to halt. Therefore p(64470)=31442 (remembering the “+1” as per p(n)’s definition) and hence P(64470)≥31442.

PLUSMINUS

2026-10-29T20:10:26Z

JackM1945: /* Relation to BB(n) */

PLUSMINUS is an esoteric programming language developed by Discord user Jack in 2026. It is a “string-based copy-automaton” that has only 2 commands, similar to its inspiration XigXag, an esoteric language developed in 2001 by Chris Pressey. Despite its extreme simplicity, its Turing Completeness is actually unknown.

== Definition ==
For a non-empty finite string S under the binary alphabet {+,-}, on step i=(1,2,…)

* If the i-th symbol is +, copy the first i-1 symbols and append them to the end.

* If the i-th symbol is -, delete the first i-1 symbols.

i never resets and advances each time. '''''HALT''''' when i>length(S).

== Trace Example ==
{| class="wikitable"
|++-++- takes 5 steps to halt
!Program Evolution
!i
|-
| +-++- (starting S)
|N/A
|-
| +-++- (nothing exists leftward)
|1
|-
| -++-
|2
|-
| -++--+
|3
|-
| --+
|4
|-
|HALT (length(S)>3, 5>3)
|5
|}
Halting characteristics for these programs include the following:

* The singular + halts

* ++…++ (with at least 2 +’s) never halts
* The program consisting of only - always halts for any length.

== Known Halting Time Champions ==
Below are PLUSMINUS programs and their corresponding number of “steps” until halting:

+=1

-+=3

-++=4

-+++=7

++++-=15

+++-++=18

++++---=20

--++++++=32

++++-+--+=44

+++++-+-+-=196

+++++-+--+-=913

+++-++++++-+=5940

+-++++++--++-=728

++++-++++++---=608

-+-++++++---+++=2582

+++++-++++-+-++-=31441

== Relation to BB(n) ==
We can concisely define 2 functions that both include the definition of PLUSMINUS in their definition using just over 300 characters. This version uses 1 and 0 instead of + and - for simplicities sake. '''It is defined as follows:'''

Let the length of x be denoted by |x|.

For n ∈ ℕ>0, convert n to its binary form B. Assuming i=(1,2,…):

If its i-th symbol is 1, copy its first i-1 symbols and append them to the end. If else, delete its first i-1 symbols.

i never resets and advances each time. Halt when i>|B|.

* p(n)=min(i) such that i>|B| (or 0 if the process never halts for said n)

* P(n)=max(p(k)) for k=(1,…,n)

== Explanation ==
The list of champions above details executed steps, while p(n) returns the instruction index when halting is detected. It is a minor difference, but should be noted since p(n)=(number of executed steps)+1. If the PLUSMINUS run starting from the binary representation of n never halts, define p(n)=0. Halting in PLUSMINUS has not been proven undecidable/decidable. Also, ordinary binary integers never start with 0, so P(n) actually excludes all programs that begin as such.

Essentially, P(n) takes the “running maximum” of p(n), so it is no longer decreasing at points. Out of the first 1000 inputs, 49 were unresolved under a limit of 10000 executed instructions or 2 million bits of string storage. Said computation has established that P(1000)≥134. From the halting times section, the PLUSMINUS program “+++++-++++-+-++-“ corresponds to “1111101111010110” which is “64470” in decimal. It takes 31441 “steps” to halt. Therefore p(64470)=31442 (remembering the “+1” as per p(n)’s definition) and hence P(64470)≥31442.

PLUSMINUS

2026-10-29T20:08:39Z

JackM1945: Fixed typos

PLUSMINUS is an esoteric programming language developed by Discord user Jack in 2026. It is a “string-based copy-automaton” that has only 2 commands, similar to its inspiration XigXag, an esoteric language developed in 2001 by Chris Pressey. Despite its extreme simplicity, its Turing Completeness is actually unknown.

== Definition ==
For a non-empty finite string S under the binary alphabet {+,-}, on step i=(1,2,…)

* If the i-th symbol is +, copy the first i-1 symbols and append them to the end.

* If the i-th symbol is -, delete the first i-1 symbols.

i never resets and advances each time. '''''HALT''''' when i>length(S).

== Trace Example ==
{| class="wikitable"
|++-++- takes 5 steps to halt
!Program Evolution
!i
|-
| +-++- (starting S)
|N/A
|-
| +-++- (nothing exists leftward)
|1
|-
| -++-
|2
|-
| -++--+
|3
|-
| --+
|4
|-
|HALT (length(S)>3, 5>3)
|5
|}
Halting characteristics for these programs include the following:

* The singular + halts

* ++…++ (with at least 2 +’s) never halts
* The program consisting of only - always halts for any length.

== Known Halting Time Champions ==
Below are PLUSMINUS programs and their corresponding number of “steps” until halting:

+=1

-+=3

-++=4

-+++=7

++++-=15

+++-++=18

++++---=20

--++++++=32

++++-+--+=44

+++++-+-+-=196

+++++-+--+-=913

+++-++++++-+=5940

+-++++++--++-=728

++++-++++++---=608

-+-++++++---+++=2582

+++++-++++-+-++-=31441

== Relation to BB(n) ==
We can concisely define 2 functions that both include the definition of PLUSMINUS in their definition using just over 300 characters. This version uses 1 and 0 instead of + and - for simplicities sake. '''It is defined as follows:'''

Let the length of x be denoted by |x|.

For n ∈ ℕ>0, convert n to its binary form B. Assuming i=(1,2,…):

If its i-th symbol is 1, copy its first i-1 symbols and append them to the end. If else, delete its first i-1 symbols.

i never resets and advances each time. Halt when i>|B|.

* p(n)=min(i) such that i>|B| (or 0 if the process never halts for said n)

* P(n)=max(p(k)) for k=(1,…,n)

== Explanation ==
The list of champions above details executed steps, while p(n) returns the instruction index when halting is detected. It is a minor difference, but should be noted since p(n)=(number of executed steps)+1. If p(n) never halts for specific n, the output is 0. Halting in PLUSMINUS has not been proven undecidable/decidable. Also, ordinary binary integers never start with 0, so P(n) actually excludes all programs that begin as such.

Essentially, P(n) takes the “running maximum” of p(n), so it is no longer decreasing at points. Out of the first 1000 inputs, 49 were unresolved under a limit of 10000 executed instructions or 2 million bits of string storage. Said computation has established that P(1000)≥134. From the halting times section, the PLUSMINUS program “+++++-++++-+-++-“ corresponds to “1111101111010110” which is “64470” in decimal. It takes 31441 “steps” to halt. Therefore p(64470)=31442 (remembering the “+1” as per p(n)’s definition) and hence P(64470)≥31442.

PLUSMINUS

2026-10-29T20:06:08Z

JackM1945:

PLUSMINUS is an esoteric programming language developed by Discord user Jack in 2026. It is a “string-based copy-automaton” that has only 2 commands, similar to its inspiration XigXag, an esoteric language developed in 2001 by Chris Pressey. Despite its extreme simplicity, its Turing Completeness is actually unknown.

== Definition ==
For a non-empty finite string S under the binary alphabet {+,-}, on step i=(1,2,…)

* If the i-th symbol is +, copy the first i-1 symbols and append them to the end.

* If the i-th symbol is -, delete the first i-1 symbols.

i never resets and advances each time. '''''HALT''''' when i>length(S).

== Trace Example ==
{| class="wikitable"
|++-++- takes 5 steps to halt
!Program Evolution
!i
|-
| +-++- (starting S)
|N/A
|-
| +-++- (nothing exists leftward)
|1
|-
| -++-
|2
|-
| -++--+
|3
|-
| --+
|4
|-
|HALT (length(S)>3, 5>3)
|5
|}
Halting characteristics for these programs include the following:

* The singular + halts

* ++…++ (with at least 2 +’s) never halts
* The program consisting of only - always halts for any length.

== Known Halting Time Champions ==
Below are PLUSMINUS programs and their corresponding number of “steps” until halting:

+=1

-+=3

-++=4

-+++=7

++++-=15

+++-++=18

++++---=20

--++++++=32

++++-+--+=44

+++++-+-+-=196

+++++-+--+-=913

+++-++++++-+=5940

+-++++++--++-=728

++++-++++++---=608

-+-++++++---+++=2582

+++++-++++-+-++-=31441

== Relation to BB(n) ==
We can concisely define 2 functions that both include the definition of PLUSMINUS in their definition using just over 300 characters. This version uses 1 and 0 instead of + and - for simplicities sake. '''It is defined as follows:'''

Let the length of x be denoted by |x|.

For n ∈ ℕ, convert n to its binary form B. Assuming i=(1,2,…):

If its i-th symbol is 1, copy its first i-1 symbols and append them to the end. If else, delete its first i-1 symbols.

i never resets and advances each time. Halt when i>|B|.

* p(n)=min(i) such that i>|B| (or 0 if the process never halts)

* P(n)=max(p(k)) for k=(1,…,n)

== Explanation ==
The list of champions above details executed steps, while p(n) returns the instruction index when halting is detected. It is a minor difference, but should be noted since p(n)=(number of executed steps)+1. If p(n) never halts for specific n, the output is 0. Halting in PLUSMINUS has not been proven undecidable/decidable. Also, ordinary binary integers never start with 0, so P(n) actually excludes all programs that begin as such.

Essentially, P(n) takes the “running maximum” of p(n), so it is no longer decreasing at points. Out of the first 1000 inputs, 49 were unresolved under a limit of 10000 executed instructions or 2 million bits of string storage. Said computation has established that P(1000)≥134. From the halting times section, the PLUSMINUS program “+++++-++++-+-++-“ corresponds to “1111101111010110” which is “64470” in decimal. It takes 31441 “steps” to halt. Therefore p(64470)=31442 (remembering the “+1” as per p(n)’s definition) and hence P(64470)≥31442.

PLUSMINUS

2026-10-29T18:40:39Z

JackM1945:

PLUSMINUS is an esoteric programming language developed by Discord user Jack in 2026. It is a “string-based copy-automaton” that has only 2 commands, similar to its inspiration XigXag, an esoteric language developed in 2001 by Chris Pressey. Despite its extreme simplicity, its Turing Completeness is actually unknown.

== Definition ==
For a non-empty finite string S under the binary alphabet {+,-}, on step i=(1,2,…)

* If the i-th symbol is +, copy the first i-1 symbols and append them to the end.

* If the i-th symbol is -, delete the first i-1 symbols.

i never resets and advances each time. '''''HALT''''' when i>length(S).

== Trace Example ==
{| class="wikitable"
|++-++- takes 5 steps to halt
!Program Evolution
!i
|-
| +-++- (starting S)
|N/A
|-
| +-++- (nothing exists leftward)
|1
|-
| -++-
|2
|-
| -++--+
|3
|-
| --+
|4
|-
|HALT (length(S)>3, 5>3)
|5
|}
Halting characteristics for these programs include the following:

* The singular + halts

* ++…++ (with at least 2 +’s) never halts
* The program consisting of only - always halts for any length.

== Known Halting Time Champions ==
Below are PLUSMINUS programs and their corresponding number of “steps” until halting:

+=1

-+=3

-++=4

-+++=7

++++-=15

+++-++=18

++++---=20

--++++++=32

++++-+--+=44

+++++-+-+-=196

+++++-+--+-=913

+++-++++++-+=5940

+-++++++--++-=728

++++-++++++---=608

-+-++++++---+++=2582

+++++-++++-+-++-=31441

== Relation to BB(n) ==
We can concisely define 2 Busy Beaver functions that both include the definition of PLUSMINUS in their definition using just over 300 characters. This version uses 1 and 0 instead of + and - for simplicities sake. '''It is defined as follows:'''

Let the length of x be denoted by |x|.

For n ∈ ℕ, convert n to its binary form B. Assuming i=(1,2,…):

If its i-th symbol is 1, copy its first i-1 symbols and append them to the end. If else, delete its first i-1 symbols.

i never resets and advances each time. Halt when i>|B|.

* p(n)=min(i) such that i>|B| (or 0 if the process never halts)

* P(n)=max(p(k)) for k=(1,…,n)

== Explanation ==
The list of champions above details executed steps, while p(n) returns the instruction index when halting is detected. It is a minor difference, but should be noted since p(n)=(number of executed steps)+1. If p(n) never halts for specific n, the output is 0. Halting in PLUSMINUS has not been proven undecidable/decidable. Also, ordinary binary integers never start with 0, so P(n) actually excludes all programs that begin as such.

Essentially, P(n) takes the “running maximum” of p(n), so it is no longer decreasing at points. Out of the first 1000 inputs, 49 were unresolved under a limit of 10000 executed instructions or 2 million bits of string storage. Said computation has established that P(1000)≥134. From the halting times section, the PLUSMINUS program “+++++-++++-+-++-“ corresponds to “1111101111010110” which is “64470” in decimal. It takes 31441 “steps” to halt. Therefore p(64470)=31442 (remembering the “+1” as per p(n)’s definition) and hence P(64470)≥31442.

PLUSMINUS

2026-10-29T18:38:22Z

JackM1945: Error fixed

PLUSMINUS is an esoteric programming language developed by Discord user Jack in 2026. It is a “string-based copy-automaton” that has only 2 commands, similar to its inspiration XigXag, an esoteric language developed in 2001 by Chris Pressey. Despite its extreme simplicity, its Turing Completeness is actually unknown.

== Definition ==
For a non-empty finite string S under the binary alphabet {+,-}, on step i=(1,2,…)

* If the i-th symbol is +, copy the first i-1 symbols and append them to the end.

* If the i-th symbol is -, delete the first i-1 symbols.

i never resets and advances each time. '''''HALT''''' when i>length(S).

== Trace Example ==
{| class="wikitable"
|++-++- takes 5 steps to halt
!Program Evolution
!i
|-
| +-++- (starting S)
|N/A
|-
| +-++- (nothing exists leftward)
|1
|-
| -++-
|2
|-
| -++--+
|3
|-
| --+
|4
|-
|HALT (length(S)>3, 5>3)
|5
|}
Halting characteristics for these programs include the following:

* The singular + halts

* ++…++ (with at least 2 +’s) never halts
* The program consisting of only - always halts for any length.

== Known Halting Time Champions ==
Below are PLUSMINUS programs and their corresponding number of “steps” until halting:

+=1

-+=3

-++=4

-+++=7

++++-=15

+++-++=18

++++---=20

--++++++=32

++++-+--+=44

+++++-+-+-=196

+++++-+--+-=913

+++-++++++-+=5940

+-++++++--++-=728

++++-++++++---=608

-+-++++++---+++=2582

+++++-++++-+-++-=31441

== Relation to BB(n) ==
We can concisely define 2 Busy Beaver functions that both include the definition of PLUSMINUS in their definition using just over 300 characters. This version uses 1 and 0 instead of + and - for simplicities sake. '''It is defined as follows:'''

Let the length of x be denoted by |x|.

For n ∈ ℕ, convert n to its binary form B. Assuming i=(1,2,…):

If its i-th symbol is 1, copy its first i-1 symbols and append them to the end. If else, delete its first i-1 symbols.

i never resets and advances each time. Halt when i>|B|.

* p(n)=min(i) such that i>|B| (or 0 if the process never halts)

* P(n)=max(p(k)) for k=(1,…,n)

== Explanation ==
The list of champions above details executed steps, while p(n) returns the instruction index when halting is detected. It is a minor difference, but should be noted since p(n)=(number of executed steps)+1. If p(n) never halts for specific n, the output is 0. Halting in PLUSMINUS has not been proven undecidable/decidable. Also, ordinary binary integers never start with 0, so P(n) actually excludes all programs that begin as such. Step-by-step, p(53) is calculated as follows:

n=53. 53 in binary is “110101”. This is how 110101 evolves over time:
{| class="wikitable"
|+p(53)=9
!Program Evolution
!i
|-
|110101 (start)
|N/A
|-
|110101 (nothing is appended)
|1
|-
|1101011
|2
|-
|01011
|3
|-
|01001011
|4
|-
|01011
|5
|-
|0101101011
|6
|-
|0101101011
|7
|-
|010010
|8
|-
|<nowiki>Halt (i>|010010|)</nowiki>
|9
|}
Essentially, P(n) takes the “running maximum” of p(n), so it is no longer decreasing at points. Out of the first 1000 inputs, 49 were unresolved under a limit of 10000 executed instructions or 2 million bits of string storage. Said computation has established that P(1000)≥134. From the halting times section, the PLUSMINUS program “+++++-++++-+-++-“ corresponds to “1111101111010110” which is “64470” in decimal. It takes 31441 “steps” to halt. Therefore p(64470)=31442 (remembering the “+1” as per p(n)’s definition) and hence P(64470)≥31442.

PLUSMINUS

2026-10-29T18:35:57Z

JackM1945: /* Explanation */ typo

PLUSMINUS is an esoteric programming language developed by Discord user Jack in 2026. It is a “string-based copy-automaton” that has only 2 commands, similar to its inspiration XigXag, an esoteric language developed in 2001 by Chris Pressey. Despite its extreme simplicity, its Turing Completeness is actually unknown.

== Definition ==
For a non-empty finite string S under the binary alphabet {+,-}, on step i=(1,2,…)

* If the i-th symbol is +, copy the first i-1 symbols and append them to the end.

* If the i-th symbol is -, delete the first i-1 symbols.

i never resets and advances each time. '''''HALT''''' when i>length(S).

== Trace Example ==
{| class="wikitable"
|++-++- takes 5 steps to halt
!Program Evolution
!i
|-
| +-++- (starting S)
|N/A
|-
| +-++- (nothing exists leftward)
|1
|-
| -++-
|2
|-
| -++--+
|3
|-
| --+
|4
|-
|HALT (length(S)>3, 5>3)
|5
|}
Halting characteristics for these programs include the following:

* The singular + halts

* ++…++ (with at least 2 +’s) never halts
* The program consisting of only - always halts for any length.

== Known Halting Time Champions ==
Below are PLUSMINUS programs and their corresponding number of “steps” until halting:

+=1

-+=3

-++=4

-+++=7

++++-=15

+++-++=18

++++---=20

--++++++=32

++++-+--+=44

+++++-+-+-=196

+++++-+--+-=913

+++-++++++-+=5940

+-++++++--++-=728

++++-++++++---=608

-+-++++++---+++=2582

+++++-++++-+-++-=31441

== Relation to BB(n) ==
We can concisely define 2 Busy Beaver functions that both include the definition of PLUSMINUS in their definition using just over 300 characters. This version uses 1 and 0 instead of + and - for simplicities sake. '''It is defined as follows:'''

Let the length of x be denoted by |x|.

For n ∈ ℕ, convert n to its binary form B. Assuming i=(1,2,…):

If its i-th symbol is 1, copy its first i-1 symbols and append them to the end. If else, delete its first i-1 symbols.

i never resets and advances each time. Halt when i>|B|.

* p(n)=min(i) such that i>|B| (or 0 if the process never halts)

* P(n)=max(p(k)) for k=(1,…,n)

== Explanation ==
The list of champions above details executed steps, while p(n) returns the instruction index when halting is detected. It is a minor difference, but should be noted since p(n)=(number of executed steps)+1. If p(n) never halts for specific n, the output is 0. Halting in PLUSMINUS has not been proven undecidable/decidable. Also, ordinary binary integers never start with 0, so P(n) actually excludes all programs that begin as such. Step-by-step, p(53) is calculated as follows:

n=53. 53 in binary is “110101”. This is how 110101 evolves over time:
{| class="wikitable"
|+p(53)=9
!Program Evolution
!i
|-
|110101 (start)
|N/A
|-
|110101 (nothing is appended)
|1
|-
|1101011
|2
|-
|01011
|3
|-
|01001011
|4
|-
|01011
|5
|-
|0101101011
|6
|-
|0101101011
|7
|-
|010010
|8
|-
|<nowiki>Halt (|010010|>i)</nowiki>
|9
|}
Essentially, P(n) takes the “running maximum” of p(n), so it is no longer decreasing at points. Out of the first 1000 inputs, 49 were unresolved under a limit of 10000 executed instructions or 2 million bits of string storage. Said computation has established that P(1000)≥134. From the halting times section, the PLUSMINUS program “+++++-++++-+-++-“ corresponds to “1111101111010110” which is “64470” in decimal. It takes 31441 “steps” to halt. Therefore p(64470)=31442 (remembering the “+1” as per p(n)’s definition) and hence P(64470)≥31442.

If PLUSMINUS is Turing-Complete, we can expect a “sudden explosion” for P(n). This means that P(n) (for n=(1,…,100) may be relatively small, but P2(100) (P(P(100)) may be very large. However, It is unknown when this exactly occurs.

PLUSMINUS

2026-10-29T18:29:58Z

JackM1945: Made a PLUSMINUS page.

PLUSMINUS is an esoteric programming language developed by Discord user Jack in 2026. It is a “string-based copy-automaton” that has only 2 commands, similar to its inspiration XigXag, an esoteric language developed in 2001 by Chris Pressey. Despite its extreme simplicity, its Turing Completeness is actually unknown.

== Definition ==
For a non-empty finite string S under the binary alphabet {+,-}, on step i=(1,2,…)

* If the i-th symbol is +, copy the first i-1 symbols and append them to the end.

* If the i-th symbol is -, delete the first i-1 symbols.

i never resets and advances each time. '''''HALT''''' when i>length(S).

== Trace Example ==
{| class="wikitable"
|++-++- takes 5 steps to halt
!Program Evolution
!i
|-
| +-++- (starting S)
|N/A
|-
| +-++- (nothing exists leftward)
|1
|-
| -++-
|2
|-
| -++--+
|3
|-
| --+
|4
|-
|HALT (length(S)>3, 5>3)
|5
|}
Halting characteristics for these programs include the following:

* The singular + halts

* ++…++ (with at least 2 +’s) never halts
* The program consisting of only - always halts for any length.

== Known Halting Time Champions ==
Below are PLUSMINUS programs and their corresponding number of “steps” until halting:

+=1

-+=3

-++=4

-+++=7

++++-=15

+++-++=18

++++---=20

--++++++=32

++++-+--+=44

+++++-+-+-=196

+++++-+--+-=913

+++-++++++-+=5940

+-++++++--++-=728

++++-++++++---=608

-+-++++++---+++=2582

+++++-++++-+-++-=31441

== Relation to BB(n) ==
We can concisely define 2 Busy Beaver functions that both include the definition of PLUSMINUS in their definition using just over 300 characters. This version uses 1 and 0 instead of + and - for simplicities sake. '''It is defined as follows:'''

Let the length of x be denoted by |x|.

For n ∈ ℕ, convert n to its binary form B. Assuming i=(1,2,…):

If its i-th symbol is 1, copy its first i-1 symbols and append them to the end. If else, delete its first i-1 symbols.

i never resets and advances each time. Halt when i>|B|.

* p(n)=min(i) such that i>|B| (or 0 if the process never halts)

* P(n)=max(p(k)) for k=(1,…,n)

== Explanation ==
The list of champions above details executed steps, while p(n) returns the instruction index when halting is detected. It is a minor difference, but should be noted since p(n)=(number of executed steps)+1. If p(n) never halts for specific n, the output is 0. Halting in PLUSMINUS has not been proven undecidable/decidable. Also, ordinary binary integers never start with 0, so P(n) actually excludes all programs that begin as such. Step-by-step, p(53) is calculated as follows:

n=53. 53 in binary is “110101”. This is how 110101 evolves over time:
{| class="wikitable"
|+p(53)=9
!Program Evolution
!i
|-
|110101 (start)
|N/A
|-
|110101 (nothing is appended)
|1
|-
|1101011
|2
|-
|01011
|3
|-
|01001011
|4
|-
|01011
|5
|-
|0101101011
|6
|-
|0101101011
|7
|-
|010010
|8
|-
|<nowiki>Halt (|010010|>i)</nowiki>
|9
|}
Essentially, P(n) takes the “running maximum” of p(n), so it is no longer decreasing at points. Out of the first 1000 inputs, 49 were unresolved under a limit of 10000 executed instructions or 2 million bits of string storage. Said computation has established that P(1000)≥134. From the halting times section, the PLUSMINUS program “+++++-++++-+-++-“ corresponds to “1111101111010110” which is “64470” in decimal. It takes 31441 “steps” to halt. Therefore p(64470)=314412 (remembering the “+1” as per p(n)’s definition) and hence P(64470)≥31442.

If PLUSMINUS is Turing-Complete, we can expect a “sudden explosion” for P(n). This means that P(n) (for n=(1,…,100) may be relatively small, but P2(100) (P(P(100)) may be very large. However, It is unknown when this exactly occurs.