BusyBeaverWiki - User contributions [en]

Tiny Tag

2025-12-04T17:57:46Z

JackM4828: created an article based off of tiny tag which was talked about in the discord forum for bb

On December 2nd, 2025, Discord User Jack created a variant of Cyclic Tag that operates under a singular binary string known. It is known as "Tiny Tag" and is similar to Self-Bitwise Cyclic Tag (SBCT). Its strength is not known.

== Definitive Statements ==
''b'' is an initial binary string,

''x'' is the leftmost bit of b,

''i=(1,2,…,k)'' is an instruction counter (initially 1),

''p₁,p₂,…,pₖ'' are the runs of b (also known as: the “rules”).

('''''NOTE:''''' The “runs of b” are the maximal consecutive sequence of the same bit. Ex. b=10011101 has rules/runs 1,00,111,0,1)

== Instructions ==

While b is not empty (b≠∅), and the current rule is pᵢ:

'''(1)''' If x=0, delete x and append nothing. If x=1, delete x and append rule pᵢ’s string to the end of b,

'''(2)''' Advance to rule (i mod k)+1,

'''(3)''' Repeat.

== Example ==

b=010111 (therefore, p=0,1,0,111), results in the following:

010111 (Initial b)

10111

01111

1111

111111

111110

111101

111010

11010111

10101110

01011101

1011101

011101111

11101111

11011111

10111110

0111110111

111110111

111101111

111011110

11011110111

…

…

...

Reaches ∅ in <big>'''<u>334 total steps</u>'''</big> (rule applications)!

== Relation to BB(n) ==

From here, we can define a Busy Beaver function as the '''“longest finite number of steps required for a binary string of length n to reach empty.”''' Call this function f(n).

here is a list of known values followed by their initial string b:

f(1)=1 (0)

f(2)=5 (10)

f(3)=9 (101)

f(4)=13 (1001)

f(5)=15 (10101)

f(6)=334 (010111)

f(7)=404 (1010111

f(8)=670 (11100101)

f(9)=12584 (001101110)

f(10)=2180995 (0100011110)

Values for n>10 are not currently known. However, an extremely weak lower bound of f(48)>>971038 (with an initial b of 010111...010111 (with 8 total 010111's)) was given on the date the definition of Tiny Tag was originally published.

== Number of "Programs" ==

This is trivial. there are 2ⁿ total binary strings of length n.

Cyclic Tag

2025-11-29T16:06:31Z

JackM4828: Fixed pronunciation

== Cyclic Tag ==
Cyclic Tag is a Turing-complete computational model<sup>[[wikipedia:Tag_system#Cyclic_tag_systems|[1]]]</sup> where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DYE-K) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

=== Introduction to Δ and P ===
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Known Values ==
{| class="wikitable"
|+ Small CTBB values
|CTBB
|Value / Lower bound
|Discoverer
|Date
|Source
|-
|2
|CTBB(2) = 5
|Jack
|16 Nov 2025
|[https://discord.com/channels/960643023006490684/960643023530762341/1440163057463726233 Link]
|-
|3
|CTBB(3) <u>></u> 38
|aparker
|18 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1440193579006951517 Link]
|-
|4
|CTBB(4) ≥ 672
|Moja
|26 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1443246244142252043 Link]
|-
|5
|CTBB(5) ≥ 2^2^2^2^182
|Moja
|26 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1443298934217900063 Link]
|-
|6
|CTBB(6) <u>></u> 2↑↑↑131
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442847677883875479 Link]
|-
|7
|CTBB(7) <u>></u> 4↑↑↑↑(4↑↑↑3)
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442950825545564281 1], [https://discord.com/channels/960643023006490684/1438694294042181742/1442819117735346217 2]
|}

== Collection of Champions ==
<div class="toccolours mw-collapsible mw-collapsed">'''Champions'''<div class="mw-collapsible-content">

<div class="toccolours mw-collapsible mw-collapsed">'''CCTB(1)'''<div class="mw-collapsible-content">
The following was given by Jack:
We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.
</div></div>

<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(2)'''<div class="mw-collapsible-content">
The domain was solved by Jack.

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

All 432 pairs were brute-forced.
</div></div>
<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(3) Champion'''<div class="mw-collapsible-content">
Pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(4) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

CTBB(4)>=672, by the following pair:

Δ: ()()()()

P:

()() -> (()())()

()() -> ()()(())

() -> (())

(((()))) -> D

</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(5) Champion'''<div class="mw-collapsible-content">

Pair found by Moja

Δ: "(())(()())"

P:

"(()())" -> "(()())(())"

"(()())" -> "(()())(())"

"()(())" -> "(())((()))"

"((()))" -> "((()))()()"

"()" -> "D

</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(6) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(7) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()()))

P:

((()())) -> ((()()))((()))

((())) -> ((()))(()()())

((())) -> ((()))(()()())

(()()()) -> (()()())(()())

(()()) -> (()())(())(())

(()) -> (())()()()()()

() -> D
</div></div>
</div></div>

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

=== Let’s Dive Deeper… ===
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

[[Category:functions]]

Cyclic Tag

2025-11-27T07:09:57Z

JackM4828: Updated a bound

== Cyclic Tag ==
Cyclic Tag is a Turing-complete computational model<sup>[[wikipedia:Tag_system#Cyclic_tag_systems|[1]]]</sup> where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

=== Introduction to Δ and P ===
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Known Values ==
{| class="wikitable"
|+ Small CTBB values
|CTBB
|Value / Lower bound
|Discoverer
|Date
|Source
|-
| 2
|CTBB(2) = 5
|Jack
|16 Nov 2025
|[https://discord.com/channels/960643023006490684/960643023530762341/1440163057463726233 Link]
|-
|3
|CTBB(3) <u>></u> 38
|aparker
|18 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1440193579006951517 Link]
|-
|4
|CTBB(4) ≥ 672
|Moja
|26 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1443246244142252043 Link]
|-
|5
|CTBB(5) ≥ 2^2^2^2^182
|Moja
|26 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1443298934217900063 Link]
|-
|6
|CTBB(6) <u>></u> 2↑↑↑131
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442847677883875479 Link]
|-
|7
|CTBB(7) <u>></u> 4↑↑↑↑(4↑↑↑3)
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442950825545564281 1], [https://discord.com/channels/960643023006490684/1438694294042181742/1442819117735346217 2]
|}

== Collection of Champions ==
<div class="toccolours mw-collapsible mw-collapsed">'''Champions'''<div class="mw-collapsible-content">

<div class="toccolours mw-collapsible mw-collapsed">'''CCTB(1)'''<div class="mw-collapsible-content">
The following was given by Jack:
We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.
</div></div>

<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(2)'''<div class="mw-collapsible-content">
The domain was solved by Jack.

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

All 432 pairs were brute-forced.
</div></div>
<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(3) Champion'''<div class="mw-collapsible-content">
Pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(4) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

CTBB(4)>=672, by the following pair:

Δ: ()()()()

P:

()() -> (()())()

()() -> ()()(())

() -> (())

(((()))) -> D

</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(5) Champion'''<div class="mw-collapsible-content">

Pair found by Moja

Δ: "(())(()())"

P:

"(()())" -> "(()())(())"

"(()())" -> "(()())(())"

"()(())" -> "(())((()))"

"((()))" -> "((()))()()"

"()" -> "D

</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(6) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(7) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()()))

P:

((()())) -> ((()()))((()))

((())) -> ((()))(()()())

((())) -> ((()))(()()())

(()()()) -> (()()())(()())

(()()) -> (()())(())(())

(()) -> (())()()()()()

() -> D
</div></div>
</div></div>

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

=== Let’s Dive Deeper… ===
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

[[Category:functions]]

Cyclic Tag

2025-11-26T19:39:37Z

JackM4828: Changed equality of a result

== Cyclic Tag ==
Cyclic Tag is a Turing-complete computational model<sup>[[wikipedia:Tag_system#Cyclic_tag_systems|[1]]]</sup> where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

=== Introduction to Δ and P ===
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Known Values ==
{| class="wikitable"
|+ Small CTBB values
|CTBB
|Value / Lower bound
|Discoverer
|Date
|Source
|-
| 2
|CTBB(2)=5
|Jack
|16 Nov 2025
|[https://discord.com/channels/960643023006490684/960643023530762341/1440163057463726233 Link]
|-
|3
|CTBB(3)<u>></u>38
|aparker
|18 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1440193579006951517 Link]
|-
|4
|CTBB(4)≥672
|Moja
|26 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1443246244142252043 Link]
|-
|5
|CTBB(5)≥2^2^2^2^181
|Moja
|26 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1443298934217900063]
|-
|6
|CTBB(6)<u>></u>2↑↑↑131
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442847677883875479 Link]
|-
|7
|CTBB(7)<u>></u>4↑↑↑↑(4↑↑↑3)
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442950825545564281 1], [https://discord.com/channels/960643023006490684/1438694294042181742/1442819117735346217 2]
|}
== Collection of Champions ==
<div class="toccolours mw-collapsible mw-collapsed">'''Champions'''<div class="mw-collapsible-content">

<div class="toccolours mw-collapsible mw-collapsed">'''CCTB(1)'''<div class="mw-collapsible-content">
The following was given by Jack:
We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.
</div></div>

<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(2)'''<div class="mw-collapsible-content">
The domain was solved by Jack.

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

All 432 pairs were brute-forced.
</div></div>
<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(3) Champion'''<div class="mw-collapsible-content">
Pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(4) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

CTBB(4)>=672, by the following pair:

Δ: ()()()()

P:

()() -> (()())()

()() -> ()()(())

() -> (())

(((()))) -> D

</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(5) Champion'''<div class="mw-collapsible-content">

Pair found by Moja

Δ: "(())(()())"

P:

"(()())" -> "(()())(())"

"(()())" -> "(()())(())"

"()(())" -> "(())((()))"

"((()))" -> "((()))()()"

"()" -> "D

</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(6) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(7) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()()))

P:

((()())) -> ((()()))((()))

((())) -> ((()))(()()())

((())) -> ((()))(()()())

(()()()) -> (()()())(()())

(()()) -> (()())(())(())

(()) -> (())()()()()()

() -> D
</div></div>
</div></div>

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

=== Let’s Dive Deeper… ===
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-26T19:29:16Z

JackM4828: Added a new bound

== Cyclic Tag ==
Cyclic Tag is a Turing-complete computational model<sup>[[wikipedia:Tag_system#Cyclic_tag_systems|[1]]]</sup> where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

=== Introduction to Δ and P ===
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Known Values ==
{| class="wikitable"
|+ Small CTBB values
|CTBB
|Value / Lower bound
|Discoverer
|Date
|Source
|-
| 2
|CTBB(2)=5
|Jack
|16 Nov 2025
|[https://discord.com/channels/960643023006490684/960643023530762341/1440163057463726233 Link]
|-
|3
|CTBB(3)<u>></u>38
|aparker
|18 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1440193579006951517 Link]
|-
|4
|CTBB(4)≥672
|Moja
|26 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1443246244142252043 Link]
|-
|5
|CTBB(5)>2^2^2^2^181
|Moja
|26 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1443298934217900063]
|-
|6
|CTBB(6)<u>></u>2↑↑↑131
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442847677883875479 Link]
|-
|7
|CTBB(7)<u>></u>4↑↑↑↑(4↑↑↑3)
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442950825545564281 1], [https://discord.com/channels/960643023006490684/1438694294042181742/1442819117735346217 2]
|}
== Collection of Champions ==
<div class="toccolours mw-collapsible mw-collapsed">'''Champions'''<div class="mw-collapsible-content">

<div class="toccolours mw-collapsible mw-collapsed">'''CCTB(1)'''<div class="mw-collapsible-content">
The following was given by Jack:
We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.
</div></div>

<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(2)'''<div class="mw-collapsible-content">
The domain was solved by Jack.

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

All 432 pairs were brute-forced.
</div></div>
<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(3) Champion'''<div class="mw-collapsible-content">
Pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(4) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

CTBB(4)>=672, by the following pair:

Δ: ()()()()

P:

()() -> (()())()

()() -> ()()(())

() -> (())

(((()))) -> D

</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(5) Champion'''<div class="mw-collapsible-content">

Pair found by Moja

Δ: "(())(()())"

P:

"(()())" -> "(()())(())"

"(()())" -> "(()())(())"

"()(())" -> "(())((()))"

"((()))" -> "((()))()()"

"()" -> "D

</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(6) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(7) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()()))

P:

((()())) -> ((()()))((()))

((())) -> ((()))(()()())

((())) -> ((()))(()()())

(()()()) -> (()()())(()())

(()()) -> (()())(())(())

(()) -> (())()()()()()

() -> D
</div></div>
</div></div>

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

=== Let’s Dive Deeper… ===
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-26T16:57:47Z

JackM4828: Added link to bound

== Cyclic Tag ==
Cyclic Tag is a Turing-complete computational model<sup>[[wikipedia:Tag_system#Cyclic_tag_systems|[1]]]</sup> where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

=== Introduction to Δ and P ===
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Known Values ==
{| class="wikitable"
|+ Small CTBB values
|CTBB
|Value / Lower bound
|Discoverer
|Date
|Source
|-
| 2
|CTBB(2)=5
|Jack
|16 Nov 2025
|[https://discord.com/channels/960643023006490684/960643023530762341/1440163057463726233 Link]
|-
|3
|CTBB(3)<u>></u>38
|aparker
|18 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1440193579006951517 Link]
|-
|4
|CTBB(4)≥672
|Moja
|26 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1443246244142252043]
|-
|5
|CTBB(5)≥3787206717615
|Moja & Racheline
|23 Nov 2025
|
|-
|6
|CTBB(6)<u>></u>2↑↑↑131
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442847677883875479 Link]
|-
|7
|CTBB(7)<u>></u>4↑↑↑↑(4↑↑↑3)
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442950825545564281 1], [https://discord.com/channels/960643023006490684/1438694294042181742/1442819117735346217 2]
|}
== Collection of Champions ==
<div class="toccolours mw-collapsible mw-collapsed">'''Champions'''<div class="mw-collapsible-content">

<div class="toccolours mw-collapsible mw-collapsed">'''CCTB(1)'''<div class="mw-collapsible-content">
The following was given by Jack:
We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.
</div></div>

<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(2)'''<div class="mw-collapsible-content">
The domain was solved by Jack.

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

All 432 pairs were brute-forced.
</div></div>
<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(3) Champion'''<div class="mw-collapsible-content">
Pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(4) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

CTBB(4)>=672, by the following pair:

Δ: ()()()()

P:

()() -> (()())()

()() -> ()()(())

() -> (())

(((()))) -> D

</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(5) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: (())(()())

P:

(()()) -> (()())(())

(()()) -> (()())(())

(()) -> (())()()()

(()) -> (())()()()

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(6) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(7) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()()))

P:

((()())) -> ((()()))((()))

((())) -> ((()))(()()())

((())) -> ((()))(()()())

(()()()) -> (()()())(()())

(()()) -> (()())(())(())

(()) -> (())()()()()()

() -> D
</div></div>
</div></div>

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

=== Let’s Dive Deeper… ===
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-26T14:53:19Z

JackM4828: Improved Bound

== Cyclic Tag ==
Cyclic Tag is a Turing-complete computational model<sup>[[wikipedia:Tag_system#Cyclic_tag_systems|[1]]]</sup> where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

=== Introduction to Δ and P ===
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Known Values ==
{| class="wikitable"
|+ Small CTBB values
|CTBB
|Value / Lower bound
|Discoverer
|Date
|Source
|-
| 2
|CTBB(2)=5
|Jack
|16 Nov 2025
|[https://discord.com/channels/960643023006490684/960643023530762341/1440163057463726233 Link]
|-
|3
|CTBB(3)<u>></u>38
|aparker
|18 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1440193579006951517 Link]
|-
|4
|CTBB(4)≥672
|Moja
|26 Nov 2025
|
|-
|5
|CTBB(5)≥3787206717615
|Moja & Racheline
|23 Nov 2025
|
|-
|6
|CTBB(6)<u>></u>2↑↑↑131
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442847677883875479 Link]
|-
|7
|CTBB(7)<u>></u>4↑↑↑↑(4↑↑↑3)
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442950825545564281 1], [https://discord.com/channels/960643023006490684/1438694294042181742/1442819117735346217 2]
|}
== Collection of Champions ==
<div class="toccolours mw-collapsible mw-collapsed">'''Champions'''<div class="mw-collapsible-content">

<div class="toccolours mw-collapsible mw-collapsed">'''CCTB(1)'''<div class="mw-collapsible-content">
The following was given by Jack:
We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.
</div></div>

<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(2)'''<div class="mw-collapsible-content">
The domain was solved by Jack.

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

All 432 pairs were brute-forced.
</div></div>
<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(3) Champion'''<div class="mw-collapsible-content">
Pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(4) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

CTBB(4)>=672, by the following pair:

Δ: ()()()()

P:

()() -> (()())()

()() -> ()()(())

() -> (())

(((()))) -> D

</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(5) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: (())(()())

P:

(()()) -> (()())(())

(()()) -> (()())(())

(()) -> (())()()()

(()) -> (())()()()

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(6) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(7) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()()))

P:

((()())) -> ((()()))((()))

((())) -> ((()))(()()())

((())) -> ((()))(()()())

(()()()) -> (()()())(()())

(()()) -> (()())(())(())

(()) -> (())()()()()()

() -> D
</div></div>
</div></div>

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

=== Let’s Dive Deeper… ===
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-26T14:13:27Z

JackM4828: Fixed date.

== Cyclic Tag ==
Cyclic Tag is a Turing-complete computational model<sup>[[wikipedia:Tag_system#Cyclic_tag_systems|[1]]]</sup> where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

=== Introduction to Δ and P ===
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Known Values ==
{| class="wikitable"
|+ Small CTBB values
|CTBB
|Value / Lower bound
|Discoverer
|Date
|Source
|-
| 2
|CTBB(2)=5
|Jack
|16 Nov 2025
|[https://discord.com/channels/960643023006490684/960643023530762341/1440163057463726233 Link]
|-
|3
|CTBB(3)<u>></u>38
|aparker
|18 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1440193579006951517 Link]
|-
|4
|CTBB(4)<u>></u>420
|Moja
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442826989101650032 Link]
|-
|5
|CTBB(5)≥3787206717615
|Moja & Racheline
|23 Nov 2025
|
|-
|6
|CTBB(6)<u>></u>2↑↑↑131
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442847677883875479 Link]
|-
|7
|CTBB(7)<u>></u>4↑↑↑↑(4↑↑↑3)
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442950825545564281 1], [https://discord.com/channels/960643023006490684/1438694294042181742/1442819117735346217 2]
|}
== Collection of Champions ==
<div class="toccolours mw-collapsible mw-collapsed">'''Champions'''<div class="mw-collapsible-content">

<div class="toccolours mw-collapsible mw-collapsed">'''CCTB(1)'''<div class="mw-collapsible-content">
The following was given by Jack:
We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.
</div></div>

<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(2)'''<div class="mw-collapsible-content">
The domain was solved by Jack.

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

All 432 pairs were brute-forced.
</div></div>
<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(3) Champion'''<div class="mw-collapsible-content">
Pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(4) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

Δ: "()()()()"

P:

'()' -> '(())'

'()()' -> '(()())()'

'(((())))' -> '()()'

'()()()' -> 'D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(5) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: (())(()())

P:

(()()) -> (()())(())

(()()) -> (()())(())

(()) -> (())()()()

(()) -> (())()()()

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(6) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(7) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()()))

P:

((()())) -> ((()()))((()))

((())) -> ((()))(()()())

((())) -> ((()))(()()())

(()()()) -> (()()())(()())

(()()) -> (()())(())(())

(()) -> (())()()()()()

() -> D
</div></div>
</div></div>

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

=== Let’s Dive Deeper… ===
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-26T14:07:55Z

JackM4828: Fixed bound for n=5

== Cyclic Tag ==
Cyclic Tag is a Turing-complete computational model<sup>[[wikipedia:Tag_system#Cyclic_tag_systems|[1]]]</sup> where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

=== Introduction to Δ and P ===
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Known Values ==
{| class="wikitable"
|+ Small CTBB values
|CTBB
|Value / Lower bound
|Discoverer
|Date
|Source
|-
| 2
|CTBB(2)=5
|Jack
|16 Nov 2025
|[https://discord.com/channels/960643023006490684/960643023530762341/1440163057463726233 Link]
|-
|3
|CTBB(3)<u>></u>38
|aparker
|18 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1440193579006951517 Link]
|-
|4
|CTBB(4)<u>></u>420
|Moja
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442826989101650032 Link]
|-
|5
|CTBB(5)≥3787206717615
|Moja & Racheline
|24 Nov 2025
|
|-
|6
|CTBB(6)<u>></u>2↑↑↑131
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442847677883875479 Link]
|-
|7
|CTBB(7)<u>></u>4↑↑↑↑(4↑↑↑3)
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442950825545564281 1], [https://discord.com/channels/960643023006490684/1438694294042181742/1442819117735346217 2]
|}
== Collection of Champions ==
<div class="toccolours mw-collapsible mw-collapsed">'''Champions'''<div class="mw-collapsible-content">

<div class="toccolours mw-collapsible mw-collapsed">'''CCTB(1)'''<div class="mw-collapsible-content">
The following was given by Jack:
We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.
</div></div>

<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(2)'''<div class="mw-collapsible-content">
The domain was solved by Jack.

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

All 432 pairs were brute-forced.
</div></div>
<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(3) Champion'''<div class="mw-collapsible-content">
Pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(4) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

Δ: "()()()()"

P:

'()' -> '(())'

'()()' -> '(()())()'

'(((())))' -> '()()'

'()()()' -> 'D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(5) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: (())(()())

P:

(()()) -> (()())(())

(()()) -> (()())(())

(()) -> (())()()()

(()) -> (())()()()

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(6) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(7) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()()))

P:

((()())) -> ((()()))((()))

((())) -> ((()))(()()())

((())) -> ((()))(()()())

(()()()) -> (()()())(()())

(()()) -> (()())(())(())

(()) -> (())()()()()()

() -> D
</div></div>
</div></div>

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

=== Let’s Dive Deeper… ===
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-25T20:39:36Z

JackM4828: Fixed spelling error

== Cyclic Tag ==
Cyclic Tag is a Turing-complete computational model<sup>[[wikipedia:Tag_system#Cyclic_tag_systems|[1]]]</sup> where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

=== Introduction to Δ and P ===
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Known Values ==
{| class="wikitable"
|+ Small CTBB values
|CTBB
|Value / Lower bound
|Discoverer
|Date
|Source
|-
| 2
|CTBB(2)=5
|Jack
|16 Nov 2025
|[https://discord.com/channels/960643023006490684/960643023530762341/1440163057463726233 Link]
|-
|3
|CTBB(3)<u>></u>38
|aparker
|18 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1440193579006951517 Link]
|-
|4
|CTBB(4)<u>></u>420
|Moja
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442826989101650032 Link]
|-
|5
|CTBB(5)<u>></u><math>7\times10^{25}</math>
|Moja & Racheline
|24 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442451330915635311 Link]
|-
|6
|CTBB(6)<u>></u>2↑↑↑131
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442847677883875479 Link]
|-
|7
|CTBB(7)<u>></u>4↑↑↑↑(4↑↑↑3)
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442950825545564281 1], [https://discord.com/channels/960643023006490684/1438694294042181742/1442819117735346217 2]
|}
== Collection of Champions ==
<div class="toccolours mw-collapsible mw-collapsed">'''Champions'''<div class="mw-collapsible-content">

<div class="toccolours mw-collapsible mw-collapsed">'''CCTB(1)'''<div class="mw-collapsible-content">
The following was given by Jack:
We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.
</div></div>

<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(2)'''<div class="mw-collapsible-content">
The domain was solved by Jack.

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

All 432 pairs were brute-forced.
</div></div>
<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(3) Champion'''<div class="mw-collapsible-content">
Pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(4) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

Δ: "()()()()"

P:

'()' -> '(())'

'()()' -> '(()())()'

'(((())))' -> '()()'

'()()()' -> 'D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(5) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ()()((())())

P:

"((())()) -> ((())())()

((())()) -> ((())())()

()() -> ()()(())()

() -> (())

((((())))) -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(6) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(7) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()()))

P:

((()())) -> ((()()))((()))

((())) -> ((()))(()()())

((())) -> ((()))(()()())

(()()()) -> (()()())(()())

(()()) -> (()())(())(())

(()) -> (())()()()()()

() -> D
</div></div>
</div></div>

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

=== Let’s Dive Deeper… ===
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-25T20:38:48Z

JackM4828: Neatly edited a champion

== Cyclic Tag ==
Cyclic Tag is a Turing-complete computational model<sup>[[wikipedia:Tag_system#Cyclic_tag_systems|[1]]]</sup> where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

=== Introduction to Δ and P ===
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Known Values ==
{| class="wikitable"
|+ Small CTBB values
|CCTB
|Value / Lower bound
|Discoverer
|Date
|Source
|-
| 2
|CTBB(2)=5
|Jack
|16 Nov 2025
|[https://discord.com/channels/960643023006490684/960643023530762341/1440163057463726233 Link]
|-
|3
|CTBB(3)<u>></u>38
|aparker
|18 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1440193579006951517 Link]
|-
|4
|CTBB(4)<u>></u>420
|Moja
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442826989101650032 Link]
|-
|5
|CTBB(5)<u>></u><math>7\times10^{25}</math>
|Moja & Racheline
|24 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442451330915635311 Link]
|-
|6
|CTBB(6)<u>></u>2↑↑↑131
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442847677883875479 Link]
|-
|7
|CTBB(7)<u>></u>4↑↑↑↑(4↑↑↑3)
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442950825545564281 1], [https://discord.com/channels/960643023006490684/1438694294042181742/1442819117735346217 2]
|}
== Collection of Champions ==
<div class="toccolours mw-collapsible mw-collapsed">'''Champions'''<div class="mw-collapsible-content">

<div class="toccolours mw-collapsible mw-collapsed">'''CCTB(1)'''<div class="mw-collapsible-content">
The following was given by Jack:
We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.
</div></div>

<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(2)'''<div class="mw-collapsible-content">
The domain was solved by Jack.

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

All 432 pairs were brute-forced.
</div></div>
<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(3) Champion'''<div class="mw-collapsible-content">
Pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(4) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

Δ: "()()()()"

P:

'()' -> '(())'

'()()' -> '(()())()'

'(((())))' -> '()()'

'()()()' -> 'D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(5) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ()()((())())

P:

"((())()) -> ((())())()

((())()) -> ((())())()

()() -> ()()(())()

() -> (())

((((())))) -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(6) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(7) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()()))

P:

((()())) -> ((()()))((()))

((())) -> ((()))(()()())

((())) -> ((()))(()()())

(()()()) -> (()()())(()())

(()()) -> (()())(())(())

(()) -> (())()()()()()

() -> D
</div></div>
</div></div>

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

=== Let’s Dive Deeper… ===
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-25T19:55:42Z

JackM4828: Fixed typo. Should be a deletion symbol as stated in original definition.

== Cyclic Tag ==
Cyclic Tag is a Turing-complete computational model<sup>[[wikipedia:Tag_system#Cyclic_tag_systems|[1]]]</sup> where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

=== Introduction to Δ and P ===
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Known Values ==
{| class="wikitable"
|+ Small CTBB values
|CCTB
|Value / Lower bound
|Discoverer
|Date
|Source
|-
| 2
|CTBB(2)=5
|Jack
|16 Nov 2025
|[https://discord.com/channels/960643023006490684/960643023530762341/1440163057463726233 Link]
|-
|3
|CTBB(3)<u>></u>38
|aparker
|18 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1440193579006951517 Link]
|-
|4
|CTBB(4)<u>></u>420
|Moja
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442826989101650032 Link]
|-
|5
|CTBB(5)<u>></u><math>7\times10^{25}</math>
|Moja & Racheline
|24 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442451330915635311 Link]
|-
|6
|CTBB(6)<u>></u>2↑↑↑131
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442847677883875479 Link]
|-
|7
|CTBB(7)<u>></u>4↑↑↑↑(4↑↑↑3)
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442950825545564281 1], [https://discord.com/channels/960643023006490684/1438694294042181742/1442819117735346217 2]
|}
== Collection of Champions ==
<div class="toccolours mw-collapsible mw-collapsed">'''Champions'''<div class="mw-collapsible-content">

<div class="toccolours mw-collapsible mw-collapsed">'''CCTB(1)'''<div class="mw-collapsible-content">
The following was given by Jack:
We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.
</div></div>

<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(2)'''<div class="mw-collapsible-content">
The domain was solved by Jack.

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

All 432 pairs were brute-forced.
</div></div>
<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(3) Champion'''<div class="mw-collapsible-content">
Pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(4) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

Δ: "()()()()"

P:

'()' -> '(())'

'()()' -> '(()())()'

'(((())))' -> '()()'

'()()()' -> 'D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(5) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ()()((())())

P:

"((())()) -> ((())())()

((())()) -> ((())())()

()() -> ()()(())()

() -> (())

((((())))) -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(6) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(7) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

start: ((()))((()()))

((()())) -> ((()()))((()))

((())) -> ((()))(()()())

((())) -> ((()))(()()())

(()()()) -> (()()())(()())

(()()) -> (()())(())(())

(()) -> (())()()()()()

() -> D
</div></div>
</div></div>

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

=== Let’s Dive Deeper… ===
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-25T18:44:49Z

JackM4828: Deletion symbol missing . I added it in. :-)

== Cyclic Tag ==
Cyclic Tag is a Turing-complete computational model<sup>[[wikipedia:Tag_system#Cyclic_tag_systems|[1]]]</sup> where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

=== Introduction to Δ and P ===
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Known Values ==
{| class="wikitable"
|+ Small CTBB values
|CCTB
|Value / Lower bound
|Discoverer
|Date
|Source
|-
| 2
|CTBB(2)=5
|Jack
|16 Nov 2025
|[https://discord.com/channels/960643023006490684/960643023530762341/1440163057463726233 Link]
|-
|3
|CTBB(3)<u>></u>38
|aparker
|18 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1440193579006951517 Link]
|-
|4
|CTBB(4)<u>></u>420
|Moja
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442826989101650032 Link]
|-
|5
|CTBB(5)<u>></u><math>7\times10^{25}</math>
|Moja & Racheline
|24 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442451330915635311 Link]
|-
|6
|CTBB(6)<u>></u>2↑↑↑131
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442847677883875479 Link]
|-
|7
|CTBB(7)<u>></u>6↑↑↑14919
|Moja
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442745206620557373 Link]
|}
== Collection of Champions ==
<div class="toccolours mw-collapsible mw-collapsed">'''Collection of Champions'''<div class="mw-collapsible-content">

<div class="toccolours mw-collapsible mw-collapsed">'''CCTB(1)'''<div class="mw-collapsible-content">
The following was given by Jack:
We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.
</div></div>

<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(2)'''<div class="mw-collapsible-content">
The domain was solved by Jack.

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

All 432 pairs were brute-forced.
</div></div>
<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(3) Champion'''<div class="mw-collapsible-content">
Pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(4) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

Δ: "()()()()"

P:

'()' -> '(())'

'()()' -> '(()())()'

'(((())))' -> '()()'

'()()()' -> <nowiki>''</nowiki>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(5) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ()()((())())

P:

"((())()) -> ((())())()

((())()) -> ((())())()

()() -> ()()(())()

() -> (())

((((())))) -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(6) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(7) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

Δ: "(()())(()()())"

P:

'(()()())' -> '(()()())(()())'

'(()()())' -> '(()()())(()())'

'(()())' -> '(()())((()))'

'((()))' -> '((()))(())()'

'(())()' -> '(())()()()()'

'(())()' -> '(())()()()()'

'()' -> D
</div></div>
</div></div>

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

=== Let’s Dive Deeper… ===
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-25T18:40:49Z

JackM4828: Fixed a few typos

== Cyclic Tag ==
Cyclic Tag is a Turing-complete computational model<sup>[[wikipedia:Tag_system#Cyclic_tag_systems|[1]]]</sup> where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

=== Introduction to Δ and P ===
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Known Values ==
{| class="wikitable"
|+ Small CTBB values
|CCTB
|Value / Lower bound
|Discoverer
|Date
|Source
|-
| 2
|CTBB(2)=5
|Jack
|16 Nov 2025
|[https://discord.com/channels/960643023006490684/960643023530762341/1440163057463726233 Link]
|-
|3
|CTBB(3)<u>></u>38
|aparker
|18 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1440193579006951517 Link]
|-
|4
|CTBB(4)<u>></u>420
|Moja
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442826989101650032 Link]
|-
|5
|CTBB(5)<u>></u><math>7\times10^{25}</math>
|Moja & Racheline
|24 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442451330915635311 Link]
|-
|6
|CTBB(6)<u>></u>2↑↑↑131
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442847677883875479 Link]
|-
|7
|CTBB(7)<u>></u>6↑↑↑14919
|Moja
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442745206620557373 Link]
|}
== Collection of Champions ==
<div class="toccolours mw-collapsible mw-collapsed">'''Collection of Champions'''<div class="mw-collapsible-content">

<div class="toccolours mw-collapsible mw-collapsed">'''CCTB(1)'''<div class="mw-collapsible-content">
The following was given by Jack:
We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.
</div></div>

<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(2)'''<div class="mw-collapsible-content">
The domain was solved by Jack.

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

All 432 pairs were brute-forced.
</div></div>
<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(3) Champion'''<div class="mw-collapsible-content">
Pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(4) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

Δ: "()()()()"

P:

'()' -> '(())'

'()()' -> '(()())()'

'(((())))' -> '()()'

'()()()' -> <nowiki>''</nowiki>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(5) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ()()((())())

P:

"((())()) -> ((())())()

((())()) -> ((())())()

()() -> ()()(())()

() -> (())

((((())))) -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(6) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(7) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

Δ: "(()())(()()())"

P:

'(()()())' -> '(()()())(()())'

'(()()())' -> '(()()())(()())'

'(()())' -> '(()())((()))'

'((()))' -> '((()))(())()'

'(())()' -> '(())()()()()'

'(())()' -> '(())()()()()'

'()' -> <nowiki>''</nowiki>
</div></div>
</div></div>

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

=== Let’s Dive Deeper… ===
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-25T18:39:21Z

JackM4828: Fixed typo.

== Cyclic Tag ==
Cyclic Tag is a Turing-complete computational model<sup>[[wikipedia:Tag_system#Cyclic_tag_systems|[1]]]</sup> where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

=== Introduction to Δ and P ===
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Known Values ==
{| class="wikitable"
|+ Small CTBB values
|CCTB
|Value / Lower bound
|Discoverer
|Date
|Source
|-
| 2
|CTBB(2)=5
|Jack
|16 Nov 2025
|[https://discord.com/channels/960643023006490684/960643023530762341/1440163057463726233 Link]
|-
|3
|CTBB(3)<u>></u>38
|aparker
|18 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1440193579006951517 Link]
|-
|4
|CTBB(4)<u>></u>420
|Moja
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442826989101650032 Link]
|-
|5
|CTBB(5)<u>></u><math>7\times10^{25}</math>
|Moja & Racheline
|24 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442451330915635311 Link]
|-
|6
|CTBB(6)<u>></u>2↑↑↑131
|Moja & Racheline
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442847677883875479 Link]
|-
|7
|CTBB(7)<u>></u>6↑↑↑14919
|Moja
|25 Nov 2025
|[https://discord.com/channels/960643023006490684/1438694294042181742/1442745206620557373 Link]
|}
== Collection of Champions ==
<div class="toccolours mw-collapsible mw-collapsed">'''Collection of Champions'''<div class="mw-collapsible-content">

<div class="toccolours mw-collapsible mw-collapsed">'''CCTB(1)'''<div class="mw-collapsible-content">
The following was given by Jack:
We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.
</div></div>

<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(2)'''<div class="mw-collapsible-content">
The domain was solved by Jack.

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

All 432 pairs were brute-forced.
</div></div>
<div class="toccolours mw-collapsible mw-collapsed">'''CTBB(3) Champion'''<div class="mw-collapsible-content">
Pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(4) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

D="()()()()"

P:

'()' -> '(())'

'()()' -> '(()())()'

'(((())))' -> '()()'

'()()()' -> <nowiki>''</nowiki>
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(5) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ=()()((())())

P:

"((())()) -> ((())())()

((())()) -> ((())())()

()() -> ()()(())()

() -> (())

((((())))) -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(6) Champion'''<div class="mw-collapsible-content">

Pair found by Moja and Racheline:

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D
</div></div><div class="toccolours mw-collapsible mw-collapsed">'''CTBB(7) Champion'''<div class="mw-collapsible-content">

Pair found by Moja:

D="(()())(()()())"

P:

'(()()())' -> '(()()())(()())'

'(()()())' -> '(()()())(()())'

'(()())' -> '(()())((()))'

'((()))' -> '((()))(())()'

'(())()' -> '(())()()()()'

'(())()' -> '(())()()()()'

'()' -> <nowiki>''</nowiki>
</div></div>
</div></div>

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

=== Let’s Dive Deeper… ===
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-25T18:27:33Z

JackM4828: FIXED TYPO

== What is Cyclic Tag? ==
Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

== Introduction to Δ and P ==
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== CTBB(1) ==

We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.

== Known Values ==
{| class="wikitable"
|+
!n
!CTBB output
!Author(s)
!Date Discovered
|-
|1
|1 (EXACT)
|Jack
|November 16th, 2025
|-
|2
|5 (EXACT)
|Jack
|November 16th, 2025
|-
|3
|≥38
|aparker314159
|November 17th?, 2025
|-
|4
|≥420
|Moja
|November 25th, 2025
|-
|5
|≥7.075×10⁷⁵
|Moja and Racheline
|November 24th, 2025
|-
|6
|≥2↑↑↑131
|Moja and Racheline
|November 24th, 2025
|-
|7
|≥6↑↑↑14919
|Moja
|November 25th, 2025
|}
Here are the corresponding pairs [Δ,P] for n>2:

'''CTBB(2):'''

Δ: (()) (Initial String)

P:

()()→D

()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

'''CTBB(3):'''

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>

'''CTBB(4):'''

Δ: (())(())

P:

(()) -> (())()()

(()) -> (())()()

(()) -> (())()()

() -> D

'''CTBB(5):'''

Δ=()()((())())

P:

"((())()) -> ((())())()

((())()) -> ((())())()

()() -> ()()(())()

() -> (())

((((())))) -> D

'''CTBB(6):'''

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D

'''CTBB(7):'''

Δ: (()())(()()())

P:

(()()()) -> (()()())(()())

(()()()) -> (()()())(()())

(()()) -> (()())((()))

((())) -> ((()))(())()

(())() -> (())()()()()

(())() -> (())()()()()

() -> D

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

== Let’s Dive Deeper… ==
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-25T18:27:01Z

JackM4828: ADDED BOUNDS

== What is Cyclic Tag? ==
Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

== Introduction to Δ and P ==
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== CTBB(1) ==

We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.

== Known Values ==
{| class="wikitable"
|+
!n
!CTBB output
!Author(s)
!Date Discovered
|-
|1
|1 (EXACT)
|Jack
|November 16th, 2025
|-
|2
|5 (EXACT)
|Jack
|November 16th, 2025
|-
|3
|≥38
|aparker314159
|November 17th?, 2025
|-
|4
|≥420
|Moja
|November 25th, 2025
|-
|5
|≥7.075×10⁷⁵
|Moja and Racheline
|November 24th, 2025
|-
|6
|≥2↑↑↑131
|Moja and Racheline
|November 24th, 2025
|-
|7
|≥6↑↑↑14919
|Moja
|November 25th, 2025
|}
Here are the corresponding pairs [Δ,P] for n>2:

'''CTBB(2):'''

Δ: (()) (Initial String)

P:

()()→D

()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

'''CTBB(3):'''

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>
'''CTBB(4):'''

'''CTBB(4):'''

Δ: (())(())

P:

(()) -> (())()()

(()) -> (())()()

(()) -> (())()()

() -> D

'''CTBB(5):'''

Δ=()()((())())

P:

"((())()) -> ((())())()

((())()) -> ((())())()

()() -> ()()(())()

() -> (())

((((())))) -> D

'''CTBB(6):'''

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D

'''CTBB(7):'''

Δ: (()())(()()())

P:

(()()()) -> (()()())(()())

(()()()) -> (()()())(()())

(()()) -> (()())((()))

((())) -> ((()))(())()

(())() -> (())()()()()

(())() -> (())()()()()

() -> D

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

== Let’s Dive Deeper… ==
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-25T18:20:52Z

JackM4828: /* Known Values */

== What is Cyclic Tag? ==
Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

== Introduction to Δ and P ==
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== CTBB(1) ==

We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.

== Known Values ==
{| class="wikitable"
|+
!n
!CTBB output
!Author(s)
!Date Discovered
|-
|1
|1 (EXACT)
|Jack
|November 16th, 2025
|-
|2
|5 (EXACT)
|Jack
|November 16th, 2025
|-
|3
|≥38
|aparker314159
|November 17th?, 2025
|-
|4
|≥420
|Moja
|November 25th, 2025
|-
|5
|≥7.075×10⁷⁵
|Moja and Racheline
|November 24th, 2025
|-
|6
|≥2↑↑↑131
|Moja and Racheline
|November 24th, 2025
|-
|7
|UNKNOWN
|UNKNOWN
|N/A
|}
Here are the corresponding pairs [Δ,P] for n>2:

'''CTBB(2):'''

Δ: (()) (Initial String)

P:

()()→D

()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

'''CTBB(3):'''

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>

'''CTBB(4):'''

Δ: (())(())

P:

(()) -> (())()()

(()) -> (())()()

(()) -> (())()()

() -> D

'''CTBB(5):'''

Δ=()()((())())

P:

"((())()) -> ((())())()

((())()) -> ((())())()

()() -> ()()(())()

() -> (())

((((())))) -> D

'''CTBB(6):'''

Δ: ((()))((()))

P:

((())) -> ((()))(()())

(()()) -> (()())(())

(()) -> (())(()()())

(()()()) -> (()()())()()

()()() -> D

() -> D

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

== Let’s Dive Deeper… ==
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-25T04:53:59Z

JackM4828: Replaced a word

== What is Cyclic Tag? ==
Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

== Introduction to Δ and P ==
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== CTBB(1) ==

We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.

== Known Values ==
On November 16th, 2025, Jack (the creator of CTBB(n)) found the champion for CTBB(2):

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

This gives '''<u>CTBB(2)=5</u>'''. All 432 total pairs [Δ,Ρ] were brute-forced.

<u>The current lower bound on CTBB(3) is 38</u>, given by the following pair found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>

On the 23rd of November, 2025, Discord user Moja found a “breakthrough pair”:

'''CTBB(6)>8^20053''', by the following pair:

Δ: (()())(()())

P:

(()()) -> (()())(())()

(()()) -> (()())(())()

(()()) -> (()())(())()

(()) -> (())()()()()

(()) -> (())()()()()

() -> D

On November 24th, 2025, Discord user Moja found yet another bound for CTBB(6) that “smashed” the previous one. This also implied that their previously discussed bound for CTBB(7) was nowhere close to its actual value.

'''CTBB(6)>3↑↑(3^36865)''' (where the double-arrow represents tetration), using the following pair:

Δ: (()())(()())

P:

(()()) -> (()())((()))

((())) -> ((()))(())()

(()()) -> (()())((()))

((())) -> ((()))(())()

(())() -> (())()()()()

() -> D
== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

== Let’s Dive Deeper… ==
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-25T04:26:36Z

JackM4828: Fixed indentation error.

== What is Cyclic Tag? ==
Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

== Introduction to Δ and P ==
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== CTBB(1) ==

We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.

== Known Values ==
On November 16th, 2025, Jack (the creator of CTBB(n)) found the champion for CTBB(2):

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

This gives '''<u>CTBB(2)=5</u>'''. All 432 total pairs [Δ,Ρ] were brute-forced.

<u>The current lower bound on CTBB(3) is 38</u>, given by the following machine found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>

On the 23rd of November, 2025, Discord user Moja found a “breakthrough pair”:

'''CTBB(6)>8^20053''', by the following pair:

Δ: (()())(()())

P:

(()()) -> (()())(())()

(()()) -> (()())(())()

(()()) -> (()())(())()

(()) -> (())()()()()

(()) -> (())()()()()

() -> D

On November 24th, 2025, Discord user Moja found yet another bound for CTBB(6) that “smashed” the previous one. This also implied that their previously discussed bound for CTBB(7) was nowhere close to its actual value.

'''CTBB(6)>3↑↑(3^36865)''' (where the double-arrow represents tetration), using the following program:

Δ: (()())(()())

P:

(()()) -> (()())((()))

((())) -> ((()))(())()

(()()) -> (()())((()))

((())) -> ((()))(())()

(())() -> (())()()()()

() -> D
== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

== Let’s Dive Deeper… ==
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-25T04:25:22Z

JackM4828: Added a bound for CTBB(6).

== What is Cyclic Tag? ==
Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

== Introduction to Δ and P ==
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== CTBB(1) ==

We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.

== Known Values ==
On November 16th, 2025, Jack (the creator of CTBB(n)) found the champion for CTBB(2):

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

This gives '''<u>CTBB(2)=5</u>'''. All 432 total pairs [Δ,Ρ] were brute-forced.

<u>The current lower bound on CTBB(3) is 38</u>, given by the following machine found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>

On the 23rd of November, 2025, Discord user Moja found a “breakthrough pair”:

'''CTBB(6)>8^20053''', by the following pair:

Δ: (()())(()())

P:

(()()) -> (()())(())()

(()()) -> (()())(())()

(()()) -> (()())(())()

(()) -> (())()()()()

(()) -> (())()()()()

() -> D

On November 24th, 2025, Discord user Moja found yet another bound for CTBB(6) that “smashed” the previous one. This also implied that their previously discussed bound for CTBB(7) was nowhere close to its actual value.

'''CTBB(6)>3↑↑(3^36865)''' (where the double-arrow represents tetration), using the following program:

Δ: (()())(()())

P:

(()()) -> (()())((()))

((())) -> ((()))(())()

(()()) -> (()())((()))

((())) -> ((()))(())()

(())() -> (())()()()()

() -> D

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

== Let’s Dive Deeper… ==
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Tree Rewriting System

2025-11-24T23:42:47Z

JackM4828: Fixed bound

== What is a Tree-Rewriting System? ==
A Tree-Rewriting System (TRS for short) is a computational model that defines a transformation between hierarchical structures (trees, often representing terms or code) by repeatedly applying a set of specified rewrite rules.

== Definition ==
We define an alphabet Σ={a,b,(f,f’,f’’,…)}. We can define terms built from these symbols as follows:

- a is a leaf node (constant),

- b is a leaf node (constant),

- f() is a unary function (has 1 child),

- f’() is a binary function (has 2 children),

- f’’() is a ternary function (has 3 children),

…

and so on…

…

In general, f’’…’’() (with n total apostrophes) is an (n+1)-ary function (has n+1 children)

'''''NOTE:''''' each function symbol specifies its arity.

== Examples of Valid Trees and Their Graphs ==
'''a''' (single root node labelled a),

'''f(a)''' (an unlabelled root with a child a),

'''f’’(a,f(a),b)''' (an unlabelled root with three children. The middle child (unlabelled) has a child labelled a,

'''f’(a,b)''' (an unlabelled root with two children labelled a and b),

'''b''' (single root note labelled b),

'''f’’’(f’(a,b),b,b,a)''' (an unlabelled root with four children, the first child has two children a and b. The other three children of the root are labelled b,b, and a.
[[File:Examples of Graphs .jpg|thumb]]

== Rulesets in Tree-Rewriting Systems ==
We consider τ to be an initial valid tree.

A deterministic tree-rewriting systems ruleset R consists of pairs of trees (L→R) where the leftmost instance of L (in τ) is replaced with R. We allow duplicate rules in the same ruleset, and rules are followed in cyclic order (initially rule 1).

If a rule does not apply, simply skip it and move to the immediate next one in R. Skipping a single rule counts as one step.

== When Does Halting Occur? ==
We can say that halting occurs in one of the two following scenarios:

τ has been reduced to a single constant,

or,

There does not exist a rule in R that can further transform τ.

== The Tree-Rewriting System In Action ==

=== Example 1: ===
τ: f’(a,f(b))

R: a->b, b->f(a), f’(a,b)->b

f’(a,f(b))

f’(b,f(b)) (as per rule 1)

f’(f(a),f(b)) (as per rule 2)

Skip rule 3

f’(f(b),f(b)) (as per rule 1)

f’(f(f(a)),f(b)) (as per rule 2)

Skip rule 3

f’(f(f(b)),f(b)) (as per rule 1)

f’(f(f(f(a))),f(b)) (as per rule 2)

Skip rule 3

…

This example does not halt.

=== Example 2: ===
τ: f’(f(a),f(b))

R: a->f’(a,b), f(b)->b, f(a)->f(b)

f’(f(a),f(b))

f’(f(f’(a,b),f(b)) (as per rule 1)

f’(f(f’(a,b),b)) (as per rule 2)

Skip rule 3

f’(f(f’(f’(a,b),b),b)) (as per rule 1)

Skip rule 2

Skip rule 3

f’(f(f’(f’(f’(a,b),b),b),b)) (as per rule 1)

Skip rule 2

Skip rule 3

f’(f(f’(f’(f’(f’(a,b),b),b),b),b)) (as per rule 1)

…

This example also does not halt.

== Functions ==
From here, we can define a multitude of functions analogous to the classic Busy Beaver. We say that a “size-n tree” consists of n total nodes. Examples include: f(a) (contains two nodes), a (or b) (contains one node), … etc …

=== BBrw(n) ===
“The maximum number of steps before halting, taken over all initial trees τ of size ≤n and all rulesets of size ≤n, with each rule part (L→R) also having size ≤n.” (We assume that each rule part can have different lengths (but must be ≤n))

=== BBlt(n) ===
“The largest tree size reached before BBrw(n) halts”

=== BBln(n) ===
“BBrw(n) but with n total distinct leaf nodes allowed in its alphabet Σ”

== Bounds For Small n ==
'''BBrw(1)=0''' because we can only start with a single constant a or b. It is already reduced to a single node.

Tree Rewriting System

2025-11-24T20:18:24Z

JackM4828: TYPO FIXED

== What is a Tree-Rewriting System? ==
A Tree-Rewriting System (TRS for short) is a computational model that defines a transformation between hierarchical structures (trees, often representing terms or code) by repeatedly applying a set of specified rewrite rules.

== Definition ==
We define an alphabet Σ={a,b,(f,f’,f’’,…)}. We can define terms built from these symbols as follows:

- a is a leaf node (constant),

- b is a leaf node (constant),

- f() is a unary function (has 1 child),

- f’() is a binary function (has 2 children),

- f’’() is a ternary function (has 3 children),

…

and so on…

…

In general, f’’…’’() (with n total apostrophes) is an (n+1)-ary function (has n+1 children)

'''''NOTE:''''' each function symbol specifies its arity.

== Examples of Valid Trees and Their Graphs ==
'''a''' (single root node labelled a),

'''f(a)''' (an unlabelled root with a child a),

'''f’’(a,f(a),b)''' (an unlabelled root with three children. The middle child (unlabelled) has a child labelled a,

'''f’(a,b)''' (an unlabelled root with two children labelled a and b),

'''b''' (single root note labelled b),

'''f’’’(f’(a,b),b,b,a)''' (an unlabelled root with four children, the first child has two children a and b. The other three children of the root are labelled b,b, and a.
[[File:Examples of Graphs .jpg|thumb]]

== Rulesets in Tree-Rewriting Systems ==
We consider τ to be an initial valid tree.

A deterministic tree-rewriting systems ruleset R consists of pairs of trees (L→R) where the leftmost instance of L (in τ) is replaced with R. We allow duplicate rules in the same ruleset, and rules are followed in cyclic order (initially rule 1).

If a rule does not apply, simply skip it and move to the immediate next one in R. Skipping a single rule counts as one step.

== When Does Halting Occur? ==
We can say that halting occurs in one of the two following scenarios:

τ has been reduced to a single constant,

or,

There does not exist a rule in R that can further transform τ.

== The Tree-Rewriting System In Action ==

=== Example 1: ===
τ: f’(a,f(b))

R: a->b, b->f(a), f’(a,b)->b

f’(a,f(b))

f’(b,f(b)) (as per rule 1)

f’(f(a),f(b)) (as per rule 2)

Skip rule 3

f’(f(b),f(b)) (as per rule 1)

f’(f(f(a)),f(b)) (as per rule 2)

Skip rule 3

f’(f(f(b)),f(b)) (as per rule 1)

f’(f(f(f(a))),f(b)) (as per rule 2)

Skip rule 3

…

This example does not halt.

=== Example 2: ===
τ: f’(f(a),f(b))

R: a->f’(a,b), f(b)->b, f(a)->f(b)

f’(f(a),f(b))

f’(f(f’(a,b),f(b)) (as per rule 1)

f’(f(f’(a,b),b)) (as per rule 2)

Skip rule 3

f’(f(f’(f’(a,b),b),b)) (as per rule 1)

Skip rule 2

Skip rule 3

f’(f(f’(f’(f’(a,b),b),b),b)) (as per rule 1)

Skip rule 2

Skip rule 3

f’(f(f’(f’(f’(f’(a,b),b),b),b),b)) (as per rule 1)

…

This example also does not halt.

== Functions ==
From here, we can define a multitude of functions analogous to the classic Busy Beaver. We say that a “size-n tree” consists of n total nodes. Examples include: f(a) (contains two nodes), a (or b) (contains one node), … etc …

=== BBrw(n) ===
“The maximum number of steps before halting, taken over all initial trees τ of size ≤n and all rulesets of size ≤n, with each rule part (L→R) also having size ≤n.” (We assume that each rule part can have different lengths (but must be ≤n))

=== BBlt(n) ===
“The largest tree size reached before BBrw(n) halts”

=== BBln(n) ===
“BBrw(n) but with n total distinct leaf nodes allowed in its alphabet Σ”

== Bounds For Small n ==
'''BBrw(1)=1''' because we can only consider τ=a or b, with a single rule being a->a (infinite loop), b->b (loop), a->b (halt after one step), and b->a (halt after one step). Max(1,1)=1 (non-halters are discarded).

Tree Rewriting System

2025-11-23T22:11:28Z

JackM4828: Removed ambiguous text

== What is a Tree-Rewriting System? ==
A Tree-Rewriting System (TRS for short) is a computational model that defines a transformation between hierarchical structures (trees, often representing terms or code) by repeatedly applying a set of specified rewrite rules.

== Definition ==
We define an alphabet Σ={a,b,(f,f’,f’’,…)}. We can define terms built from these symbols as follows:

- a is a leaf node (constant),

- b is a leaf node (constant),

- f() is a unary function (has 1 child),

- f’() is a binary function (has 2 children),

- f’’() is a ternary function (has 3 children),

…

and so on…

…

In general, f’’…’’() (with n total apostrophes) is an (n+1)-ary function (has n+1 children)

'''''NOTE:''''' each function symbol specifies its arity.

== Examples of Valid Trees and Their Graphs ==
'''a''' (single root note labelled a),

'''f(a)''' (an unlabelled root with a child a),

'''f’’(a,f(a),b)''' (an unlabelled root with three children. The middle child (unlabelled) has a child labelled a,

'''f’(a,b)''' (an unlabelled root with two children labelled a and b),

'''b''' (single root note labelled b),

'''f’’’(f’(a,b),b,b,a)''' (an unlabelled root with four children, the first child has two children a and b. The other three children of the root are labelled b,b, and a.
[[File:Examples of Graphs .jpg|thumb]]

== Rulesets in Tree-Rewriting Systems ==
We consider τ to be an initial valid tree.

A deterministic tree-rewriting systems ruleset R consists of pairs of trees (L→R) where the leftmost instance of L (in τ) is replaced with R. We allow duplicate rules in the same ruleset, and rules are followed in cyclic order (initially rule 1).

If a rule does not apply, simply skip it and move to the immediate next one in R. Skipping a single rule counts as one step.

== When Does Halting Occur? ==
We can say that halting occurs in one of the two following scenarios:

τ has been reduced to a single constant,

or,

There does not exist a rule in R that can further transform τ.

== The Tree-Rewriting System In Action ==

=== Example 1: ===
τ: f’(a,f(b))

R: a->b, b->f(a), f’(a,b)->b

f’(a,f(b))

f’(b,f(b)) (as per rule 1)

f’(f(a),f(b)) (as per rule 2)

Skip rule 3

f’(f(b),f(b)) (as per rule 1)

f’(f(f(a)),f(b)) (as per rule 2)

Skip rule 3

f’(f(f(b)),f(b)) (as per rule 1)

f’(f(f(f(a))),f(b)) (as per rule 2)

Skip rule 3

…

This example does not halt.

=== Example 2: ===
τ: f’(f(a),f(b))

R: a->f’(a,b), f(b)->b, f(a)->f(b)

f’(f(a),f(b))

f’(f(f’(a,b),f(b)) (as per rule 1)

f’(f(f’(a,b),b)) (as per rule 2)

Skip rule 3

f’(f(f’(f’(a,b),b),b)) (as per rule 1)

Skip rule 2

Skip rule 3

f’(f(f’(f’(f’(a,b),b),b),b)) (as per rule 1)

Skip rule 2

Skip rule 3

f’(f(f’(f’(f’(f’(a,b),b),b),b),b)) (as per rule 1)

…

This example also does not halt.

== Functions ==
From here, we can define a multitude of functions analogous to the classic Busy Beaver. We say that a “size-n tree” consists of n total nodes. Examples include: f(a) (contains two nodes), a (or b) (contains one node), … etc …

=== BBrw(n) ===
“The maximum number of steps before halting, taken over all initial trees τ of size ≤n and all rulesets of size ≤n, with each rule part (L→R) also having size ≤n.” (We assume that each rule part can have different lengths (but must be ≤n))

=== BBlt(n) ===
“The largest tree size reached before BBrw(n) halts”

=== BBln(n) ===
“BBrw(n) but with n total distinct leaf nodes allowed in its alphabet Σ”

== Bounds For Small n ==
'''BBrw(1)=1''' because we can only consider τ=a or b, with a single rule being a->a (infinite loop), b->b (loop), a->b (halt after one step), and b->a (halt after one step). Max(1,1)=1 (non-halters are discarded).

Tree Rewriting System

2025-11-23T22:08:29Z

JackM4828: Typo fixed.

== What is a Tree-Rewriting System? ==
A Tree-Rewriting System (TRS for short) is a computational model that defines a transformation between hierarchical structures (trees, often representing terms or code) by repeatedly applying a set of specified rewrite rules.

== Definition ==
We define an alphabet Σ={a,b,(f,f’,f’’,…)}. We can define terms built from these symbols as follows:

- a is a leaf node (constant),

- b is a leaf node (constant),

- f() is a unary function (has 1 child),

- f’() is a binary function (has 2 children),

- f’’() is a ternary function (has 3 children),

…

and so on…

…

In general, f’’…’’() (with n total apostrophes) is an (n+1)-ary function (has n+1 children)

'''''NOTE:''''' each function symbol specifies its arity.

== Examples of Valid Trees and Their Graphs ==
'''a''' (single root note labelled a),

'''f(a)''' (an unlabelled root with a child a),

'''f’’(a,f(a),b)''' (an unlabelled root with three children. The middle child (unlabelled) has a child labelled a,

'''f’(a,b)''' (an unlabelled root with two children labelled a and b),

'''b''' (single root note labelled b),

'''f’’’(f’(a,b),b,b,a)''' (an unlabelled root with four children, the first child has two children a and b. The other three children of the root are labelled b,b, and a.
[[File:Examples of Graphs .jpg|thumb]]

== Rulesets in Tree-Rewriting Systems ==
We consider τ to be an initial valid tree.

A deterministic tree-rewriting systems ruleset R consists of pairs of trees (L→R) where the leftmost instance of L (in τ) is replaced with R. We allow duplicate rules in the same ruleset, and rules are followed in cyclic order (initially rule 1).

If a rule does not apply, simply skip it and move to the immediate next one in R. Skipping a single rule counts as one step.

== When Does Halting Occur? ==
We can say that halting occurs in one of the two following scenarios:

τ has been reduced to a single constant,

or,

There does not exist a rule in R that can further transform τ.

== The Tree-Rewriting System In Action ==

=== Example 1: ===
τ: f’(a,f(b))

R: a->b, b->f(a), f’(a,b)->b

f’(a,f(b))

f’(b,f(b)) (as per rule 1)

f’(f(a),f(b)) (as per rule 2)

Skip rule 3

f’(f(b),f(b)) (as per rule 1)

f’(f(f(a)),f(b)) (as per rule 2)

Skip rule 3

f’(f(f(b)),f(b)) (as per rule 1)

f’(f(f(f(a))),f(b)) (as per rule 2)

Skip rule 3

…

This example does not halt.

=== Example 2: ===
τ: f’(f(a),f(b))

R: a->f’(a,b), f(b)->b, f(a)->f(b)

f’(f(a),f(b))

f’(f(f’(a,b),f(b)) (as per rule 1)

f’(f(f’(a,b),b)) (as per rule 2)

Skip rule 3

f’(f(f’(f’(a,b),b),b)) (as per rule 1)

Skip rule 2

Skip rule 3

f’(f(f’(f’(f’(a,b),b),b),b)) (as per rule 1)

Skip rule 2

Skip rule 3

f’(f(f’(f’(f’(f’(a,b),b),b),b),b)) (as per rule 1)

…

This example also does not halt.

== Functions ==
From here, we can define a multitude of functions analogous to the classic Busy Beaver. We say that a “size-n tree” consists of n total nodes. Examples include: f(a) (contains two nodes), a (or b) (contains one node), … etc …

=== BBrw(n) ===
“The maximum number of steps before halting, taken over all initial trees τ of size ≤n and all rulesets of size ≤n, with each rule part (L→R) also having size ≤n.” (We assume that each rule part can have different lengths (but must be ≤n))

=== BBlt(n) ===
“The largest tree size reached before BBrw(n) halts”

=== BBmt(n) ===
“The max total nodes across all rewritten trees in BBrw(n)”.

=== BBln(n) ===
“BBrw(n) but with n total distinct leaf nodes allowed in its alphabet Σ”

== Bounds For Small n ==
'''BBrw(1)=1''' because we can only consider τ=a or b, with a single rule being a->a (infinite loop), b->b (loop), a->b (halt after one step), and b->a (halt after one step). Max(1,1)=1 (non-halters are discarded).

Tree Rewriting System

2025-11-23T22:06:52Z

JackM4828: Created a page that deals with a tree rewriting system

== What is a Tree-Rewriting System? ==
A Tree-Rewriting System (TRS for short) is a computational model that defines a transformation between hierarchical structures (trees, often representing terms or code) by repeatedly applying a set of specified rewrite rules.

== Definition ==
We define an alphabet Σ={a,b,(f,f’,f’’,…)}. We can define terms built from these symbols as follows:

- a is a leaf node (constant),

- b is a leaf node (constant),

- f() is a unary function (has 1 child),

- f’() is a binary function (has 2 children),

- f’’() is a ternary function (has 3 children),

…

and so on…

…

In general, f’’…’’() (with n total apostrophes) is an (n+1)-ary function (has n+1 children)

'''''NOTE:''''' each function symbol specifies its arity.

== Examples of Valid Trees and Their Graphs ==
'''a''' (single root note labelled a),

'''f(a)''' (an unlabelled root with a child a),

'''f’’(a,f(a),b)''' (an unlabelled root with three children. The middle child (unlabelled) has a child labelled a,

'''f’(a,b)''' (an unlabelled root with two children labelled a and b),

'''b''' (single root note labelled b),

'''f’’’(f’(a,b),b,b,a)''' (an unlabelled root with four children, the first child has two children a and b. The other three children of the root are labelled b,b, and a.
[[File:Examples of Graphs .jpg|thumb]]

== Rulesets in Tree-Rewriting Systems ==
We consider τ to be an initial valid tree.

A deterministic tree-rewriting systems ruleset R consists of pairs of trees (L→R) where the leftmost instance of L (in τ) is replaced with R. We allow duplicate rules in the same ruleset, and rules are followed in cyclic order (initially rule 1).

If a rule does not apply, simply skip it and move to the immediate next one in R. Skipping a single rule counts as one step.

== When Does Halting Occur? ==
We can say that halting occurs in one of the two following scenarios:

τ has been reduced to a single constant,

or,

There does not exist a rule in R that can further transform τ.

== The Tree-Rewriting System In Action ==

=== Example 1: ===
τ: f’(a,f(b))

R: a->b, b->f(a), f’(a,b)->b

f’(a,f(b))

f’(b,f(b)) (as per rule 1)

f’(f(a),f(b)) (as per rule 2)

Skip rule 3

f’(f(b),f(b)) (as per rule 1)

f’(f(f(a)),f(b)) (as per rule 2)

Skip rule 3

f’(f(f(b)),f(b)) (as per rule 1)

f’(f(f(f(a))),f(b)) (as per rule 2)

Skip rule 3

…

This example does not halt.

=== Example 2: ===
τ: f’(f(a),f(b))

R: a->f’(a,b), f(b)->b, f(a)->f(b)

f’(f(a),f(b))

f’(f(f’(a,b),f(b)) (as per rule 1)

f’(f(f’(a,b),b)) (as per rule 2)

Skip rule 3

f’(f(f’(f’(a,b),b),b)) (as per rule 1)

Skip rule 2

Skip rule 3

f’(f(f’(f’(f’(a,b),b),b),b)) (as per rule 1)

Skip rule 2

Skip rule 3

f’(f(f’(f’(f’(f’(a,b),b),b),b),b)) (as per rule 1)

…

This example also does not terminate.

== Functions ==
From here, we can define a multitude of functions analogous to the classic Busy Beaver. We say that a “size-n tree” consists of n total nodes. Examples include: f(a) (contains two nodes), a (or b) (contains one node), … etc …

=== BBrw(n) ===
“The maximum number of steps before halting, taken over all initial trees τ of size ≤n and all rulesets of size ≤n, with each rule part (L→R) also having size ≤n.”

=== BBlt(n) ===
“The largest tree size reached before BBrw(n) halts”

=== BBmt(n) ===
“The max total nodes across all rewritten trees in BBrw(n)”.

=== BBln(n) ===
“BBrw(n) but with n total distinct leaf nodes allowed in its alphabet Σ”

== Bounds For Small n ==
'''BBrw(1)=1''' because we can only consider τ=a or b, with a single rule being a->a (infinite loop), b->b (loop), a->b (halt after one step), and b->a (halt after one step). Max(1,1)=1 (non-halters are discarded).

File:Examples of Graphs .jpg

2025-11-23T22:03:51Z

JackM4828:

Here are some examples of graphs and their written notational definition.

Cyclic Tag

2025-11-23T18:08:31Z

JackM4828: Minor text fix

== What is Cyclic Tag? ==
Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

== Introduction to Δ and P ==
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== CTBB(1) ==

We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.

== Known Values ==
On November 16th, 2025, Jack (the creator of CTBB(n)) found the champion for CTBB(2):

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

This gives '''<u>CTBB(2)=5</u>'''. All 432 total pairs [Δ,Ρ] were brute-forced.

<u>The current lower bound on CTBB(3) is 38</u>, given by the following machine found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>

On the 23rd of November, 2025, Discord user Moja found a “breakthrough pair”:

'''CTBB(6)>8^20053''', by the following pair:

Δ: (()())(()())

P:

(()()) -> (()())(())()

(()()) -> (()())(())()

(()()) -> (()())(())()

(()) -> (())()()()()

(()) -> (())()()()()

() -> D

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

== Let’s Dive Deeper… ==
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-23T17:52:38Z

JackM4828: Added a known result

== What is Cyclic Tag? ==
Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order. There are various halting conditions that one may choose. They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n. There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

=== Rooted Ordered Trees and Dyck Strings ===
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

== Introduction to Δ and P ==
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

=== Solving a Given Δ and P: ===
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

=== Halting Conditions ===
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

This example doesn't halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is therefore defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

==== Notes ====
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== CTBB(1) ==

We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.

== Known Values ==
On November 16th, 2025, Jack (the creator of CTBB(n)) found the champion for CTBB(2):

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

This gives '''<u>CTBB(2)=5</u>'''. All 432 total pairs [Δ,Ρ] were brute-forced.

<u>The current lower bound on CTBB(3) is 38</u>, given by the following machine found by aparker314159:

<pre>
Δ: [][[]]
Rule 0: [[]] => [[[]]]
Rule 1: [][][] => D
Rule 2: [] => [][]
</pre>

On the 23rd of November, 2025, Discord user Moja found a “breakthrough pair”:

'''CTBB(6)>8^20053''', by the following pair:

Δ="(()())(()())"

P:

(()()) -> (()())(())()

(()()) -> (()())(())()

(()()) -> (()())(())()

(()) -> (())()()()()

(()) -> (())()()()()

() -> D

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

CTBB(10) has 23713 possible Δ.

== Let’s Dive Deeper… ==
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

=== Values of the Pair Function ===
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems in General ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found [https://dl.acm.org/doi/pdf/10.1145/321203.321206 here].

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

User:JackM4828/Unary Cyclic Tag

2025-11-20T01:17:55Z

JackM4828: Replaced a word.

== What is Cyclic Tag? ==

Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

== Cyclic Tag Difference ==

Traditional Cyclic Tag rules are binary mappings. Unary Cylic Tag rules are unary “payloads”, meaning that the rule is tied to the value read. Also, in Unary Cyclic Tag, Unary Cyclic Tag has one rule per cycle whilst Cyclic Tag has two implicit rules per cycle.

== Introduction ==

A “Unary Rule Cyclic Tag System” is defined under a quadruple [B,Ω,P,i] as follows:

'''(1)''' B is our alphabet. In this case, it is the set of all arbitrary, finite, non-empty binary strings,

'''(2)''' Ω ∈ B is an initial string,

'''(3)''' P are production rules X₁,X₂,…,Xₖ where Xₘ ∈ B (with duplicate rules allowed),

'''(4)''' i ∈ (1,2,…,k) is an instruction pointer (initially set to 1),

Lastly, a pair denoted [Ω,P] is considered a “program”. To “solve” a program, we must follow these instructions:

== Instructions ==

* Identify the leftmost bit in Ω (let it be F),

* Let Xᵢ be the current rule,

* Delete F. If F was 1 (before deletion), append Xᵢ to the end. If F was 0, append nothing,

* Go to: next rule (i ← (i mod k)+1),

== Halting Condition ==

A program halts iff Ω = ∅.

== Function ==

Let |L| be the length of L. Let Ubb(n) (Unary Busy Beaver) be defined as the max number of rule applications required until eventual-halting occurs for a program of “size n” (a size n program consists of: |P| = n rules, (|Xₘ|,|Ω|) ≤ n bits).

'''NOTE:''' each rule Xₘ can be of different lengths (keeping in mind |Xₘ|≤n).

== Current Champion/Very Weak Lower Bounds ==
Ubb(1)=2 (via: Ω=1, P=[0])

Ubb(2)≥8 (via: Ω=10, P=[1,00])

Ubb(3)≥32 (via: Ω=111, P=[000,101,10])

…

Ubb(10)>>130000 (where “>>” represents “way greater than”)

User:JackM4828/Unary Cyclic Tag

2025-11-20T01:17:09Z

JackM4828: Fixed up variables. Made them “line-up” for ease of understanding

== What is Cyclic Tag? ==

Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

== Cyclic Tag Difference ==

Traditional Cyclic Tag rules are binary mappings. Unary Cylic Tag rules are unary “payloads”, meaning that the rule is tied to the value read. Also, in Unary Cyclic Tag, Unary Cyclic Tag has one rule per cycle whilst Cyclic Tag has two implicit rules per cycle.

== Introduction ==

A “Unary Rule Cyclic Tag System” is defined under a quadruple [B,Ω,P,i] as follows:

'''(1)''' B is our alphabet. In this case, it is the set of all arbitrary, finite, non-empty binary strings,

'''(2)''' Ω ∈ B is an initial string,

'''(3)''' P are production rules X₁,X₂,…,Xₖ where Xₘ ∈ B (with duplicate rules allowed),

'''(4)''' i ∈ (1,2,…,k) is an instruction pointer (initially set to 1),

Lastly, a pair denoted [Ω,P] is considered a “program”. To “solve” a program, we must follow these instructions:

== Instructions ==

* Identify the leftmost bit in Ω (let it be F),

* Let Xᵢ be the current rule,

* Delete F. If F was 1 (before deletion), append Xᵢ to the end. If F was 0, append nothing,

* Go to: next rule (i ← (i mod k)+1),

== Halting Condition ==

A program halts iff Ω = ∅.

== Function ==

Let |L| be the length of L. Let Ubb(n) (Unary Busy Beaver) be defined as the max number of rule applications required until finite-halting occurs for a program of “size n” (a size n program consists of: |P| = n rules, (|Xₘ|,|Ω|) ≤ n bits).

'''NOTE:''' each rule Xₘ can be of different lengths (keeping in mind |Xₘ|≤n).

== Current Champion/Very Weak Lower Bounds ==
Ubb(1)=2 (via: Ω=1, P=[0])

Ubb(2)≥8 (via: Ω=10, P=[1,00])

Ubb(3)≥32 (via: Ω=111, P=[000,101,10])

…

Ubb(10)>>130000 (where “>>” represents “way greater than”)

User:JackM4828/Unary Cyclic Tag

2025-11-19T22:32:48Z

JackM4828: Typo fixed

== What is Cyclic Tag? ==

Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

== Cyclic Tag Difference ==

Traditional Cyclic Tag rules are binary mappings. Unary Cylic Tag rules are unary “payloads”, meaning that the rule is tied to the value read. Also, in Unary Cyclic Tag, Unary Cyclic Tag has one rule per cycle whilst Cyclic Tag has two implicit rules per cycle.

== Introduction ==

A “Unary Rule Cyclic Tag System” is defined under a quadruple [B,Ω,P,i] as follows:

'''(1)''' B is our alphabet. In this case, it is the set of all arbitrary, finite, non-empty binary strings,

'''(2)''' Ω ∈ B is an initial string,

'''(3)''' P are production rules X₁,X₂,…,Xₖ where Xₘ ∈ B (with duplicate rules allowed),

'''(4)''' i ∈ (1,2,…,k) is an instruction pointer (initially set to 1),

Lastly, a pair denoted [Ω,P] is considered a “program”. To “solve” a program, we must follow these instructions:

== Instructions ==

* Identify the leftmost bit in Ω (let it be F),

* Let Rᵢ be the current rule,

* Delete F. If F was 1 (before deletion), append Rᵢ to the end. If F was 0, append nothing,

* Go to: next rule (i ← (i mod k)+1),

== Halting Condition ==

A program halts iff Ω = ∅.

== Function ==

Let |L| be the length of L. Let Ubb(n) (Unary Busy Beaver) be defined as the max number of rule applications required until finite-halting occurs for a program of “size n” (a size n program consists of: |P| = n rules, (|Xₘ|,|Ω|) ≤ n bits).

'''NOTE:''' each rule Xₘ can be of different lengths (keeping in mind |Xₘ|≤n).

== Current Champion/Very Weak Lower Bounds ==
Ubb(1)=2 (via: Ω=1, P=[0])

Ubb(2)≥8 (via: Ω=10, P=[1,00])

Ubb(3)≥32 (via: Ω=111, P=[000,101,10])

…

Ubb(10)>>130000 (where “>>” represents “way greater than”)

User:JackM4828/Unary Cyclic Tag

2025-11-19T21:59:26Z

JackM4828: Fixed another typo :/

== What is Cyclic Tag? ==

Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

== Cyclic Tag Difference ==

Traditional Cyclic Tag rules are binary mappings. Unary Cylic Tag rules are unary “payloads”, meaning that the rule is tied to the value read. Also, in Unary Cyclic Tag, Unary Cyclic Tag has one rule per cycle whilst Cyclic Tag has two implicit rules per cycle.

== Introduction ==

A “Unary Rule Cyclic Tag System” is defined under a quadruple [B,Ω,P,i] as follows:

'''(1)''' B is our alphabet. In this case, it is the set of all arbitrary, finite, non-empty binary strings,

'''(2)''' Ω ∈ B is an initial string,

'''(3)''' P are production rules X₁,X₂,…,Xₖ where Xₘ ∈ B (with duplicate rules allowed),

'''(4)''' i ∈ (1,2,…,k) is an instruction pointer (initially set to 1),

Lastly, a pair denoted [Ω,P] is considered a “program”. To “solve” a program, we must follow these instructions:

== Instructions ==

* Identify the leftmost bit in Ω (let it be F),

* Let Rᵢ be the current rule,

* Delete F. If F was 1 (before deletion), append Rᵢ to the end. If F was 0, append nothing,

* Go to: next rule (i ← (i mod k)+1),

== Halting Condition ==

A program halts iff Ω = ∅.

== Function ==

Let |L| be the length of L. Let Ubb(n) (Unary Busy Beaver) be defined as the max number of rule applications required until finite-halting occurs for a program of “size n” (a size n program consists of: |P| = n rules, (|Xₘ|,|Ω|) ≤ n bits).

'''NOTE:''' each rule Xₘ can be of different lengths (keeping in mind |Xₘ|≤n).

== Current Champion/Very Weak Lower Bounds ==
Ubb(1)=2 (via: Δ=1, P=[0])

Ubb(2)≥8 (via: Δ=10, P=[1,00])

Ubb(3)≥32 (via: Δ=111, P=[000,101,10])

…

Ubb(10)>>130000 (where “>>” represents “way greater than”)

User:JackM4828/Unary Cyclic Tag

2025-11-19T21:57:26Z

JackM4828: Typo fixed

== What is Cyclic Tag? ==

Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

== Cyclic Tag Difference ==

Traditional Cyclic Tag rules are binary mappings. Unary Cylic Tag rules are unary “payloads”, meaning that the rule is tied to the value read. Also, in Unary Cyclic Tag, Unary Cyclic Tag has one rule per cycle whilst Cyclic Tag has two implicit rules per cycle.

== Introduction ==

A “Unary Rule Cyclic Tag System” is defined under a quadruple [B,Ω,P,i] as follows:

'''(1)''' B is our alphabet. In this case, it is the set of all arbitrary, finite, non-empty binary strings,

'''(2)''' Ω ∈ B is an initial string,

'''(3)''' P are production rules X₁,X₂,…,Xₖ where Xₘ ∈ B (with duplicate rules allowed),

'''(4)''' i ∈ (1,2,…,k) is an instruction pointer (initially set to 1),

Lastly, a pair denoted [Ω,P] is considered a “program”. To “solve” a program, we must follow these instructions:

== Instructions ==

* Identify the leftmost bit in Ω (let it be F),

* Let Rᵢ be the current rule,

* Delete F. If F was 1 (before deletion), append Rᵢ to the end. If F was 0, append nothing,

* Go to: next rule (i ← (i mod k)+1),

== Halting Condition ==

A program halts iff Ω = ∅.

== Function ==

Let |L| be the length of L. Let Ubb(n) (Unary Busy Beaver) be defined as the max number of rule applications required until finite-halting occurs for a program of “size n” (a size n program consists of: |P| = n rules, (|Xₘ|,|Δ|) ≤ n bits).

'''NOTE:''' each rule Xₘ can be of different lengths (keeping in mind |Xₘ|≤n).

== Current Champion/Very Weak Lower Bounds ==
Ubb(1)=2 (via: Δ=1, P=[0])

Ubb(2)≥8 (via: Δ=10, P=[1,00])

Ubb(3)≥32 (via: Δ=111, P=[000,101,10])

…

Ubb(10)>>130000 (where “>>” represents “way greater than”)

User:JackM4828/Unary Cyclic Tag

2025-11-19T20:44:49Z

JackM4828:

== What is Cyclic Tag? ==

Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

== Cyclic Tag Difference ==

Traditional Cyclic Tag rules are binary mappings. Unary Cylic Tag rules are unary “payloads”, meaning that the rule is tied to the value read. Also, in Unary Cyclic Tag, Unary Cyclic Tag has one rule per cycle whilst Cyclic Tag has two implicit rules per cycle.

== Introduction ==

A “Unary Rule Cyclic Tag System” is defined under a quadruple [B,Ω,P,i] as follows:

'''(1)''' B is our alphabet. In this case, it is the set of all arbitrary, finite, non-empty binary strings,

'''(2)''' Ω ∈ B is an initial string,

'''(3)''' P are production rules X₁,X₂,…,Xₖ where Xₘ ∈ B (with duplicate rules allowed),

'''(4)''' i ∈ (1,2,…,k) is an instruction pointer (initially set to 1),

Lastly, a pair denoted [Δ,P] is considered a “program”. To “solve” a program, we must follow these instructions:

== Instructions ==

* Identify the leftmost bit in Ω (let it be F),

* Let Rᵢ be the current rule,

* Delete F. If F was 1 (before deletion), append Rᵢ to the end. If F was 0, append nothing,

* Go to: next rule (i ← (i mod k)+1),

== Halting Condition ==

A program halts iff Ω = ∅.

== Function ==

Let |L| be the length of L. Let Ubb(n) (Unary Busy Beaver) be defined as the max number of rule applications required until finite-halting occurs for a program of “size n” (a size n program consists of: |P| = n rules, (|Xₘ|,|Δ|) ≤ n bits).

'''NOTE:''' each rule Xₘ can be of different lengths (keeping in mind |Xₘ|≤n).

== Current Champion/Very Weak Lower Bounds ==
Ubb(1)=2 (via: Δ=1, P=[0])

Ubb(2)≥8 (via: Δ=10, P=[1,00])

Ubb(3)≥32 (via: Δ=111, P=[000,101,10])

…

Ubb(10)>>130000 (where “>>” represents “way greater than”)

User:JackM4828/Unary Cyclic Tag

2025-11-19T20:33:39Z

JackM4828: Added a list, sectioned a part.

== What is Cyclic Tag? ==

Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

== Cyclic Tag Difference ==

Traditional Cyclic Tag rules are binary mappings. Unary Cylic Tag rules are unary “payloads”, meaning that the rule is tied to the value read. Also, in Unary Cyclic Tag, Unary Cyclic Tag has one rule per cycle whilst Cyclic Tag has two implicit rules per cycle.

== Introduction ==

A “Unary Rule Cyclic Tag System” is defined under a quadruple [B,Ω,P,i] as follows:

'''(1)''' B is our alphabet. In this case, it is the set of all arbitrary, finite, non-empty binary strings,

'''(2)''' Ω ∈ B is an initial string,

'''(3)''' P are production rules X₁,X₂,…,Xₖ where Xₘ ∈ B (with duplicate rules allowed),

'''(4)''' i ∈ (1,2,…,k) is an instruction pointer (initially set to 1),

Lastly, a pair denoted [Δ,P] is considered a “program”. To “solve” a program, we must follow these instructions:

== Instructions ==

* Identify the leftmost bit in Ω (let it be F),

* Let Rᵢ be the current rule,

* Delete F. If F was 1 (before deletion), append Rᵢ to the end. If F was 0, append nothing,

* Go to: next rule (i ← (i mod k)+1),

== Halting Condition ==

A program halts iff Ω = ∅.

== Function ==

Let |L| be the length of L. Let Ubb(n) (Unary Busy Beaver) be defined as the max finite number of rule applications required until halting occurs for a program of “size n” (a size n program consists of: |P| = n rules, (|Xₘ|,|Δ|) ≤ n bits).

'''NOTE:''' each rule Xₘ can be of different lengths (keeping in mind |Xₘ|≤n).

== Current Champion/Very Weak Lower Bounds ==
Ubb(1)=2 (via: Δ=1, P=[0])

Ubb(2)≥8 (via: Δ=10, P=[1,00])

Ubb(3)≥32 (via: Δ=111, P=[000,101,10])

…

Ubb(10)>>130000 (where “>>” represents “way greater than”)

User:JackM4828/Unary Cyclic Tag

2025-11-19T20:32:12Z

JackM4828: Boldened a title

== What is Cyclic Tag? ==

Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

== Cyclic Tag Difference ==

Traditional Cyclic Tag rules are binary mappings. Unary Cylic Tag rules are unary “payloads”, meaning that the rule is tied to the value read. Also, in Unary Cyclic Tag, Unary Cyclic Tag has one rule per cycle whilst Cyclic Tag has two implicit rules per cycle.

== Introduction ==

A “Unary Rule Cyclic Tag System” is defined under a 4-tuple [B,Ω,P,i] as follows:

'''(1)''' B is our alphabet. In this case, it is the set of all arbitrary, finite, non-empty binary strings,

'''(2)''' Ω ∈ B is an initial string,

'''(3)''' P are production rules X₁,X₂,…,Xₖ where Xₘ ∈ B (with duplicate rules allowed),

'''(4)''' i ∈ (1,2,…,k) is an instruction pointer (initially set to 1),

Lastly, a pair denoted [Δ,P] is considered a “program”. To “solve” a program, we must follow these instructions:

== Instructions ==

* Identify the leftmost bit in Ω (let it be F),

* Let Rᵢ be the current rule,

* Delete F. If F was 1 (before deletion), append Rᵢ to the end. If F was 0, append nothing,

* Go to: next rule (i ← (i mod k)+1),

== Halting Condition ==

A program halts iff Ω = ∅.

== Function ==

Let |L| be the length of L. Let Ubb(n) (Unary Busy Beaver) be defined as the max finite number of rule applications required until halting occurs for a program of “size n” (a size n program consists of: |P| = n rules, (|Xₘ|,|Δ|) ≤ n bits).

'''NOTE:''' each rule Xₘ can be of different lengths (keeping in mind |Xₘ|≤n).

== Current Champion/Very Weak Lower Bounds ==
Ubb(1)=2 (via: Δ=1, P=[0])
Ubb(2)≥8 (via: Δ=10, P=[1,00])
Ubb(3)≥32 (via: Δ=111, P=[000,101,10])
…
Ubb(10)>>130000 (where “>>” represents “way greater than”)

User:JackM4828/Unary Cyclic Tag

2025-11-19T20:30:22Z

JackM4828: Created an article based off of a variant of cyclic tag.

== What is Cyclic Tag? ==

Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

== Cyclic Tag Difference ==

Traditional Cyclic Tag rules are binary mappings. Unary Cylic Tag rules are unary “payloads”, meaning that the rule is tied to the value read. Also, in Unary Cyclic Tag, Unary Cyclic Tag has one rule per cycle whilst Cyclic Tag has two implicit rules per cycle.

== Introduction ==

A “Unary Rule Cyclic Tag System” is defined under a 4-tuple [B,Ω,P,i] as follows:

'''(1)''' B is our alphabet. In this case, it is the set of all arbitrary, finite, non-empty binary strings,

'''(2)''' Ω ∈ B is an initial string,

'''(3)''' P are production rules X₁,X₂,…,Xₖ where Xₘ ∈ B (with duplicate rules allowed),

'''(4)''' i ∈ (1,2,…,k) is an instruction pointer (initially set to 1),

Lastly, a pair denoted [Δ,P] is considered a “program”. To “solve” a program, we must follow these instructions:

== Instructions ==

-Identify the leftmost bit in Ω (let it be F),

-Let Rᵢ be the current rule,

-Delete F. If F was 1 (before deletion), append Rᵢ to the end. If F was 0, append nothing,

-Go to: next rule (i ← (i mod k)+1),

== Halting Condition ==

A program halts iff Ω = ∅.

== Function ==

Let |L| be the length of L. Let Ubb(n) (Unary Busy Beaver) be defined as the max finite number of rule applications required until halting occurs for a program of “size n” (a size n program consists of: |P| = n rules, (|Xₘ|,|Δ|) ≤ n bits).

'''NOTE:''' each rule Xₘ can be of different lengths (keeping in mind |Xₘ|≤n).

**Current Champion/Very Weak Lower Bounds**

Ubb(1)=2 (via: Δ=1, P=[0])
Ubb(2)≥8 (via: Δ=10, P=[1,00])
Ubb(3)≥32 (via: Δ=111, P=[000,101,10])
…
Ubb(10)>>130000 (where “>>” represents “way greater than”)

Cyclic Tag

2025-11-18T04:33:24Z

JackM4828: Added an extra value in the list: 1st,…,n-th is now 1st,2nd,…,n-th (for more clarity).

== What is Cyclic Tag? ==
Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

There are various halting conditions that one may choose, They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n.

There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

== Rooted Ordered Trees and Dyck Strings ==
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

== Examples of Valid Dyck Strings ==

* (())()()()(())

* ()()()

* (((()))()())

* (())

* ((()))(())()

…etc…

All parentheses are “balanced”.

== Introduction to Δ and P ==
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

== “Solving” a Given Δ and P ==
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

== Halting Conditions ==
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

…etc…

…

This example DOES NOT halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is THEREFORE defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

== Final Ideas ==
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Calculating Values (CTBB(1)) ==

We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.

== CTBB(1) and Beyond ==
On November 16th, 2025, Jack (the creator of CTBB(n)) found the champion for CTBB(2):

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

This gives CTBB(2)=5. All 432 total pairs [Δ,Ρ] were brute-forced.

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

speeding forward…

…

CTBB(10) has 23713 possible Δ,

== Let’s Dive Deeper… ==
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,2nd,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

== Values of the Pair Function ==
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems (In General) ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found by clicking this link [https://dl.acm.org/doi/pdf/10.1145/321203.321206 HERE]

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-17T18:14:46Z

JackM4828: I made something that should’ve been a title, a title.

== What is Cyclic Tag? ==
Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

There are various halting conditions that one may choose, They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n.

There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

== Rooted Ordered Trees and Dyck Strings ==
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

== Examples of Valid Dyck Strings ==

* (())()()()(())

* ()()()

* (((()))()())

* (())

* ((()))(())()

…etc…

All parentheses are “balanced”.

== Introduction to Δ and P ==
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

== “Solving” a Given Δ and P ==
We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

== Halting Conditions ==
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

…etc…

…

This example DOES NOT halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is THEREFORE defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

== Final Ideas ==
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Calculating Values (CTBB(1)) ==

We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.

== CTBB(1) and Beyond ==
On November 16th, 2025, Jack (the creator of CTBB(n)) found the champion for CTBB(2):

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

This gives CTBB(2)=5. All 432 total pairs [Δ,Ρ] were brute-forced.

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

speeding forward…

…

CTBB(10) has 23713 possible Δ,

== Let’s Dive Deeper… ==
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

== Values of the Pair Function ==
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems (In General) ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found by clicking this link [https://dl.acm.org/doi/pdf/10.1145/321203.321206 HERE]

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-17T04:24:53Z

JackM4828: I fixed a nonsensical statement that doesn’t make sense. I have fixed it.

== What is Cyclic Tag? ==
Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

There are various halting conditions that one may choose, They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n.

There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

== Rooted Ordered Trees and Dyck Strings ==
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

== Examples of Valid Dyck Strings ==

* (())()()()(())

* ()()()

* (((()))()())

* (())

* ((()))(())()

…etc…

All parentheses are “balanced”.

== Introduction to Δ and P ==
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

“Solving” a Given Δ and P

We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

== Halting Conditions ==
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

…etc…

…

This example DOES NOT halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is THEREFORE defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

== Final Ideas ==
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Calculating Values (CTBB(1)) ==

We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.

== CTBB(1) and Beyond ==
On November 16th, 2025, Jack (the creator of CTBB(n)) found the champion for CTBB(2):

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

This gives CTBB(2)=5. All 432 total pairs [Δ,Ρ] were brute-forced.

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

speeding forward…

…

CTBB(10) has 23713 possible Δ,

== Let’s Dive Deeper… ==
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

== Values of the Pair Function ==
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems (In General) ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found by clicking this link [https://dl.acm.org/doi/pdf/10.1145/321203.321206 HERE]

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-17T01:49:29Z

JackM4828: I have added a new potential champion. CTBB(2)=5.

== What is Cyclic Tag? ==
Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

There are various halting conditions that one may choose, They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n.

There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

== Rooted Ordered Trees and Dyck Strings ==
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

== Examples of Valid Dyck Strings ==

* (())()()()(())

* ()()()

* (((()))()())

* (())

* ((()))(())()

…etc…

All parentheses are “balanced”.

== Introduction to Δ and P ==
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

“Solving” a Given Δ and P

We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

== Halting Conditions ==
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

…etc…

…

This example DOES NOT halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is THEREFORE defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs in S that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

== Final Ideas ==
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Calculating Values (CTBB(1)) ==

We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.

== CTBB(1) and Beyond ==
On November 16th, 2025, Jack (the creator of CTBB(n)) found the champion for CTBB(2):

Δ: (()) (Initial String)

P: R₁=()()→D, R₂=()→()()

(()) (Δ)

Skip rule 1 (skipping counts as a step)

(()()) (apply rule 2)

() (apply rule 1)

()() (apply rule 2)

∅ (apply rule 1)

This gives CTBB(2)=5. All 432 total pairs [Δ,Ρ] were brute-forced.

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

speeding forward…

…

CTBB(10) has 23713 possible Δ,

== Let’s Dive Deeper… ==
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

== Values of the Pair Function ==
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems (In General) ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found by clicking this link [https://dl.acm.org/doi/pdf/10.1145/321203.321206 HERE]

It is worth mentioning that this variant of cyclic tag does not involve appending, only rewriting.

Cyclic Tag

2025-11-15T22:12:15Z

JackM4828: I have forgotten to make a blurb a title heading.

== What is Cyclic Tag? ==
Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

There are various halting conditions that one may choose, They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n.

There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

== Rooted Ordered Trees and Dyck Strings ==
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

== Examples of Valid Dyck Strings ==

* (())()()()(())

* ()()()

* (((()))()())

* (())

* ((()))(())()

…etc…

All parentheses are “balanced”.

== Introduction to Δ and P ==
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

“Solving” a Given Δ and P

We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

== Halting Conditions ==
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

…etc…

…

This example DOES NOT halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is THEREFORE defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs in S that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

== Final Ideas ==
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

== Calculating Values (CTBB(1)) ==

We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

speeding forward…

…

CTBB(10) has 23713 possible Δ,

== Let’s Dive Deeper… ==
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

== Values of the Pair Function ==
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems (In General) ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found by clicking this link [https://dl.acm.org/doi/pdf/10.1145/321203.321206 HERE]

It is worth mentioning that this variant of cyclic tag does not involving appending, only rewriting.

Cyclic Tag

2025-11-15T22:05:34Z

JackM4828: I have created a page dealing with Cyclic Tag. A very minimally Turing-complete system. Thanks.

== What is Cyclic Tag? ==
Cyclic Tag is a Turing-complete computational model where a binary string evolves under a set of rules applied in cyclic order.

There are various halting conditions that one may choose, They are explicitly stated further below.

== Rooted Ordered Tree Variant ==
This variant of Cyclic Tag operates upon a Dyck String instead of a binary string. A Dyck String is a string of parentheses “(“ and “)” of length 2n, that consists of an equal number of symbols such that for all prefixes, “(“ occurs at least as many times as the other “)”. In shorter terms, a Dyck String is a balanced parenthetical string of length 2n.

There does not exist a Dyck String (in this format) with an odd length (hence the 2n).

== Rooted Ordered Trees and Dyck Strings ==
Dyck Strings (pronounced as: DEEK) encode finite rooted ordered trees through a well-known bijection that maps the structure of a tree to a balanced sequence of parentheses. The most common method involves a depth-first traversal of the tree. A rooted ordered tree is a tree with these key features:

* One vertex is distinguished as the root,

* All edges are directed away from the root (conceptually, though not always drawn with arrows),

* For each node, the children are arranged in a left-to-right order.

== Examples of Valid Dyck Strings ==

* (())()()()(())

* ()()()

* (((()))()())

* (())

* ((()))(())()

…etc…

All parentheses are “balanced”.

== Introduction to Δ and P ==
Define an ordered pair [Δ,Ρ] where Δ is an initial finite non-empty Dyck String & P are production rules P=(R₁,R₂,…,Rₖ), each in the form “X→Y” where X and Y are finite non-empty Dyck Strings. Y has the ability to be the symbol D. When Y is instead D, this means: in Δ, delete X.

“Solving” a Given Δ and P

We follow these steps:

'''(1)''' Begin with R₁,

'''(2)''' Scan Δ from left to right,

'''(3)''' Find the leftmost instance of X in Δ (according to said R)

'''(4)''' Rewrite X as Y and leave the rest of Δ unchanged (or delete X if Y is the symbol D)

'''(5)''' Move to the next R in cyclic order (1, 2,…,n,1,2,…)

'''(6)''' If a rule doesn’t apply, simply skip it and move to the immediate next one in P,

'''(7)''' Repeat from (2) on the altered Δ each time.

'''''NOTE:''''' Duplicate rules in the same P are allowed.

== Halting Conditions ==
Some given pairs [Δ,P] never halt. However, some do! Here are two halting conditions we can define:

'''Halt if:'''

Δ becomes “∅” (empty), or if there does not exist a rule in P that can transform Δ any further, meaning that Δ is what we can call “stuck”.

== Example Run-Through ==
(Initial Dyck String) Δ: ()()(())

(Production Rules) P: R₁=()→(()), R₂=(())()→D

()()(()) initial String Δ,

(())()(()) as per R₁, (()) replaces (),

(()) as per R₂, (())() is deleted,

((())) as per R₁, (()) replaces (),

'''SKIP R₂, IT DOES NOT APPLY,'''

…

…etc…

…

This example DOES NOT halt as ((…()…)) will keep expanding indefinitely.

== Correlation to BB(n) ==
From here, we can define a function analogous to the Busy Beaver function by taking the maximal finite halting times for all pairs. Here’s how we can do it:

Let |x| denote the length of x.

A pair [Δ,P] of “size n” consists of n rules, where for each Rᵢ ∈ P, |X|≤2n and |Y|≤2n ('''NOTE''': the lengths of X and Y for each Rᵢ do NOT have to be the same, but they must be ≤2n). We also assume that |Δ|≤2n. We say that skipping a rule counts as a step, and a “step” is defined as a singular rule application.

== Function ==
The “Cyclic Tree Busy Beaver” function CTBB(n) is THEREFORE defined as follows:

'''(1)''' Run all pairs [Δ,P] of size n,

'''(2)''' Let S be the set of all pairs S=(P₁,P₂,…,Pₘ) that halted, and filter out (discard) all pairs in S that do not,

'''(3)''' Let S’ be the set of all steps for every pair in S to halt,

'''(4)''' CTBB(n) outputs max(S’).

== Final Ideas ==
Because Tag Systems in this fashion are Turing-Complete, we can expect CTBB(n) to be on par with the classic BB(n).

We can also correctly say that CTBB(n)>*f(n) where f(n) is any computable function (where >* represents eventual domination).

We are only allowed:

* 1 rule

* For each rule part (X,Y) can only contain at most 2 symbols (because 2(1)=2)

* The initial string Δ also only contains at most 2 symbols

There is only one possible Dyck string with at most 2 symbols, it is: (). Here are all possible P (rulesets) and Δ given these constraints:

Δ: (), single rule: ()→()

Δ: (), single rule: ()→D

'''Remember''': Δ must be non-empty. It’s easy to tell that for each step, the first ruleset results in an infinite loop. The second one halts after 1 step (it immediately deletes () ).

S is the set of all halting pairs (only the second one) and S’ is the halting times for said pair(s) (only 1).

max(S’)=1.

== Total Number of Pairs ==
The number of pairs [Δ,Ρ] grows rather quick. For CTBB(n), there are C(1)+C(2)+…+C(n) total Δ’s (where C(n)=n-th Catalan Number). The first few values are:

CTBB(1) has 1 possible Δ,

CTBB(2) has 3 possible Δ,

CTBB(3) has 8 possible Δ,

…

speeding forward…

…

CTBB(10) has 23713 possible Δ,

== Let’s Dive Deeper… ==
Number of possible X: Sum of 1st,2nd,…,n-th Catalan Numbers

Number of possible Y: ((Sum of 1st,2nd,…,n-th Catalan Numbers)+1) (the “+1” represents the optional “D” symbol)

Each R in P is technically an ordered pair [x,y] so we multiply the counts together:

'''(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)'''

There are n rules, so we exponentiate this by n:

'''[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

We have our initial Dyck string Δ of length at most 2n (as mentioned earlier). This is also equal to the sum of the 1st,…,n-th Catalan numbers. This forms another pair [Δ,Ρ] by multiplying our Catalan sum with our formula from before:

'''Pair(n)=(Sum of 1st,2nd,…,n-th Catalan Numbers)×[(Sum of 1st,2nd,…,n-th Catalan Numbers)×((Sum of 1st,2nd,…,n-th Catalan Numbers)+1)]ⁿ'''

== Values of the Pair Function ==
Pair(1)=2 (as shown earlier)

Pair(2)=432

Pair(3)=2985984

Pair(4)≈1.44×10¹²

Pair(5)≈7.97×10¹⁷

== Turing-Completeness of Tag Systems (In General) ==
Cocke and Minsky's construction of a Universal Turing Machine within a tag system can be found by clicking this link [https://dl.acm.org/doi/pdf/10.1145/321203.321206 HERE]

It is worth mentioning that this variant of cyclic tag does not involving appending, only rewriting.