BusyBeaverWiki - User contributions [en]

User:MrSolis/Playground

2025-12-04T15:36:31Z

MrSolis:

{{Infobox
| title = Example: header with & without data
| headerstyle = background: lightgrey; color:inherit;

| header1 = Header1 with empty section
| label2 = label2 text | data2 =
| label3 = label3 text | data3 =
| label4 = label4 text | data4 =

| header5 = Header5 with data below
| label6 = label6 text | data6 = Some value
}}

Module:Infobox

2025-12-04T15:36:24Z

MrSolis: Created page with "local p = {} local args = {} local origArgs = {} local root local empty_row_categories = {} local category_in_empty_row_pattern = '%[%[%s*[Cc][Aa][Tt][Ee][Gg][Oo][Rr][Yy]%s*:[^]]*]]' local has_rows = false local lists = { plainlist_t = { patterns = { '^plainlist$', '%splainlist$', '^plainlist%s', '%splainlist%s' }, found = false, styles = 'Plainlist/styles.css' }, hlist_t = { patterns = { '^hlist$', '%shlist$', '^hlist%s', '%shlist%s'..."

local p = {}
local args = {}
local origArgs = {}
local root
local empty_row_categories = {}
local category_in_empty_row_pattern = '%[%[%s*[Cc][Aa][Tt][Ee][Gg][Oo][Rr][Yy]%s*:[^]]*]]'
local has_rows = false
local lists = {
plainlist_t = {
patterns = {
'^plainlist$',
'%splainlist$',
'^plainlist%s',
'%splainlist%s'
},
found = false,
styles = 'Plainlist/styles.css'
},
hlist_t = {
patterns = {
'^hlist$',
'%shlist$',
'^hlist%s',
'%shlist%s'
},
found = false,
styles = 'Hlist/styles.css'
}
}

local function has_list_class(args_to_check)
for _, list in pairs(lists) do
if not list.found then
for _, arg in pairs(args_to_check) do
for _, pattern in ipairs(list.patterns) do
if mw.ustring.find(arg or '', pattern) then
list.found = true
break
end
end
if list.found then break end
end
end
end
end

local function fixChildBoxes(sval, tt)
local function notempty( s ) return s and s:match( '%S' ) end

if notempty(sval) then
local marker = '<span class=special_infobox_marker>'
local s = sval
-- start moving templatestyles and categories inside of table rows
local slast = ''
while slast ~= s do
slast = s
s = mw.ustring.gsub(s, '(</[Tt][Rr]%s*>%s*)(%[%[%s*[Cc][Aa][Tt][Ee][Gg][Oo][Rr][Yy]%s*:[^]]*%]%])', '%2%1')
s = mw.ustring.gsub(s, '(</[Tt][Rr]%s*>%s*)(\127[^\127]*UNIQ%-%-templatestyles%-%x+%-QINU[^\127]*\127)', '%2%1')
end
-- end moving templatestyles and categories inside of table rows
s = mw.ustring.gsub(s, '(<%s*[Tt][Rr])', marker .. '%1')
s = mw.ustring.gsub(s, '(</[Tt][Rr]%s*>)', '%1' .. marker)
if s:match(marker) then
s = mw.ustring.gsub(s, marker .. '%s*' .. marker, '')
s = mw.ustring.gsub(s, '([\r\n]|-[^\r\n]*[\r\n])%s*' .. marker, '%1')
s = mw.ustring.gsub(s, marker .. '%s*([\r\n]|-)', '%1')
s = mw.ustring.gsub(s, '(</[Cc][Aa][Pp][Tt][Ii][Oo][Nn]%s*>%s*)' .. marker, '%1')
s = mw.ustring.gsub(s, '(<%s*[Tt][Aa][Bb][Ll][Ee][^<>]*>%s*)' .. marker, '%1')
s = mw.ustring.gsub(s, '^(%{|[^\r\n]*[\r\n]%s*)' .. marker, '%1')
s = mw.ustring.gsub(s, '([\r\n]%{|[^\r\n]*[\r\n]%s*)' .. marker, '%1')
s = mw.ustring.gsub(s, marker .. '(%s*</[Tt][Aa][Bb][Ll][Ee]%s*>)', '%1')
s = mw.ustring.gsub(s, marker .. '(%s*\n|%})', '%1')
end
if s:match(marker) then
local subcells = mw.text.split(s, marker)
s = ''
for k = 1, #subcells do
if k == 1 then
s = s .. subcells[k] .. '</' .. tt .. '></tr>'
elseif k == #subcells then
local rowstyle = ' style="display:none"'
if notempty(subcells[k]) then rowstyle = '' end
s = s .. '<tr' .. rowstyle ..'><' .. tt .. ' colspan=2>\n' ..
subcells[k]
elseif notempty(subcells[k]) then
if (k % 2) == 0 then
s = s .. subcells[k]
else
s = s .. '<tr><' .. tt .. ' colspan=2>\n' ..
subcells[k] .. '</' .. tt .. '></tr>'
end
end
end
end
-- the next two lines add a newline at the end of lists for the PHP parser
-- [[Special:Diff/849054481]]
-- remove when [[:phab:T191516]] is fixed or OBE
s = mw.ustring.gsub(s, '([\r\n][%*#;:][^\r\n]*)$', '%1\n')
s = mw.ustring.gsub(s, '^([%*#;:][^\r\n]*)$', '%1\n')
s = mw.ustring.gsub(s, '^([%*#;:])', '\n%1')
s = mw.ustring.gsub(s, '^(%{%|)', '\n%1')
return s
else
return sval
end
end

-- Cleans empty tables
local function cleanInfobox()
root = tostring(root)
if has_rows == false then
root = mw.ustring.gsub(root, '<table[^<>]*>%s*</table>', '')
end
end

-- Returns the union of the values of two tables, as a sequence.
local function union(t1, t2)

local vals = {}
for k, v in pairs(t1) do
vals[v] = true
end
for k, v in pairs(t2) do
vals[v] = true
end
local ret = {}
for k, v in pairs(vals) do
table.insert(ret, k)
end
return ret
end

-- Returns a table containing the numbers of the arguments that exist
-- for the specified prefix. For example, if the prefix was 'data', and
-- 'data1', 'data2', and 'data5' exist, it would return {1, 2, 5}.
local function getArgNums(prefix)
local nums = {}
for k, v in pairs(args) do
local num = tostring(k):match('^' .. prefix .. '([1-9]%d*)$')
if num then table.insert(nums, tonumber(num)) end
end
table.sort(nums)
return nums
end

-- Adds a row to the infobox, with either a header cell
-- or a label/data cell combination.
local function addRow(rowArgs)

if rowArgs.header and rowArgs.header ~= '_BLANK_' then
has_rows = true
has_list_class({ rowArgs.rowclass, rowArgs.class, args.headerclass })

root
:tag('tr')
:addClass(rowArgs.rowclass)
:cssText(rowArgs.rowstyle)
:tag('th')
:attr('colspan', '2')
:addClass('infobox-header')
:addClass(rowArgs.class)
:addClass(args.headerclass)
-- @deprecated next; target .infobox-<name> .infobox-header
:cssText(args.headerstyle)
:cssText(rowArgs.rowcellstyle)
:wikitext(fixChildBoxes(rowArgs.header, 'th'))
if rowArgs.data then
root:wikitext(
'[[Category:Pages using infobox templates with ignored data cells]]'
)
end
elseif rowArgs.data and rowArgs.data:gsub(category_in_empty_row_pattern, ''):match('^%S') then
has_rows = true
has_list_class({ rowArgs.rowclass, rowArgs.class })

local row = root:tag('tr')
row:addClass(rowArgs.rowclass)
row:cssText(rowArgs.rowstyle)
if rowArgs.label then
row
:tag('th')
:attr('scope', 'row')
:addClass('infobox-label')
-- @deprecated next; target .infobox-<name> .infobox-label
:cssText(args.labelstyle)
:cssText(rowArgs.rowcellstyle)
:wikitext(rowArgs.label)
:done()
end

local dataCell = row:tag('td')
dataCell
:attr('colspan', not rowArgs.label and '2' or nil)
:addClass(not rowArgs.label and 'infobox-full-data' or 'infobox-data')
:addClass(rowArgs.class)
-- @deprecated next; target .infobox-<name> .infobox(-full)-data
:cssText(rowArgs.datastyle)
:cssText(rowArgs.rowcellstyle)
:wikitext(fixChildBoxes(rowArgs.data, 'td'))
else
table.insert(empty_row_categories, rowArgs.data or '')
end
end

local function renderTitle()
if not args.title then return end

has_rows = true
has_list_class({args.titleclass})

root
:tag('caption')
:addClass('infobox-title')
:addClass(args.titleclass)
-- @deprecated next; target .infobox-<name> .infobox-title
:cssText(args.titlestyle)
:wikitext(args.title)

end

local function renderAboveRow()
if not args.above then return end

has_rows = true
has_list_class({ args.aboveclass })

root
:tag('tr')
:tag('th')
:attr('colspan', '2')
:addClass('infobox-above')
:addClass(args.aboveclass)
-- @deprecated next; target .infobox-<name> .infobox-above
:cssText(args.abovestyle)
:wikitext(fixChildBoxes(args.above,'th'))
end

local function renderBelowRow()
if not args.below then return end

has_rows = true
has_list_class({ args.belowclass })

root
:tag('tr')
:tag('td')
:attr('colspan', '2')
:addClass('infobox-below')
:addClass(args.belowclass)
-- @deprecated next; target .infobox-<name> .infobox-below
:cssText(args.belowstyle)
:wikitext(fixChildBoxes(args.below,'td'))
end

local function addSubheaderRow(subheaderArgs)
if subheaderArgs.data and
subheaderArgs.data:gsub(category_in_empty_row_pattern, ''):match('^%S') then
has_rows = true
has_list_class({ subheaderArgs.rowclass, subheaderArgs.class })

local row = root:tag('tr')
row:addClass(subheaderArgs.rowclass)

local dataCell = row:tag('td')
dataCell
:attr('colspan', '2')
:addClass('infobox-subheader')
:addClass(subheaderArgs.class)
:cssText(subheaderArgs.datastyle)
:cssText(subheaderArgs.rowcellstyle)
:wikitext(fixChildBoxes(subheaderArgs.data, 'td'))
else
table.insert(empty_row_categories, subheaderArgs.data or '')
end
end

local function renderSubheaders()
if args.subheader then
args.subheader1 = args.subheader
end
if args.subheaderrowclass then
args.subheaderrowclass1 = args.subheaderrowclass
end
local subheadernums = getArgNums('subheader')
for k, num in ipairs(subheadernums) do
addSubheaderRow({
data = args['subheader' .. tostring(num)],
-- @deprecated next; target .infobox-<name> .infobox-subheader
datastyle = args.subheaderstyle,
rowcellstyle = args['subheaderstyle' .. tostring(num)],
class = args.subheaderclass,
rowclass = args['subheaderrowclass' .. tostring(num)]
})
end
end

local function addImageRow(imageArgs)

if imageArgs.data and
imageArgs.data:gsub(category_in_empty_row_pattern, ''):match('^%S') then

has_rows = true
has_list_class({ imageArgs.rowclass, imageArgs.class })

local row = root:tag('tr')
row:addClass(imageArgs.rowclass)

local dataCell = row:tag('td')
dataCell
:attr('colspan', '2')
:addClass('infobox-image')
:addClass(imageArgs.class)
:cssText(imageArgs.datastyle)
:wikitext(fixChildBoxes(imageArgs.data, 'td'))
else
table.insert(empty_row_categories, imageArgs.data or '')
end
end

local function renderImages()
if args.image then
args.image1 = args.image
end
if args.caption then
args.caption1 = args.caption
end
local imagenums = getArgNums('image')
for k, num in ipairs(imagenums) do
local caption = args['caption' .. tostring(num)]
local data = mw.html.create():wikitext(args['image' .. tostring(num)])
if caption then
data
:tag('div')
:addClass('infobox-caption')
-- @deprecated next; target .infobox-<name> .infobox-caption
:cssText(args.captionstyle)
:wikitext(caption)
end
addImageRow({
data = tostring(data),
-- @deprecated next; target .infobox-<name> .infobox-image
datastyle = args.imagestyle,
class = args.imageclass,
rowclass = args['imagerowclass' .. tostring(num)]
})
end
end

-- When autoheaders are turned on, preprocesses the rows
local function preprocessRows()
if not args.autoheaders then return end

local rownums = union(getArgNums('header'), getArgNums('data'))
table.sort(rownums)
local lastheader
for k, num in ipairs(rownums) do
if args['header' .. tostring(num)] then
if lastheader then
args['header' .. tostring(lastheader)] = nil
end
lastheader = num
elseif args['data' .. tostring(num)] and
args['data' .. tostring(num)]:gsub(
category_in_empty_row_pattern, ''
):match('^%S') then
local data = args['data' .. tostring(num)]
if data:gsub(category_in_empty_row_pattern, ''):match('%S') then
lastheader = nil
end
end
end
if lastheader then
args['header' .. tostring(lastheader)] = nil
end
end

-- Gets the union of the header and data argument numbers,
-- and renders them all in order
local function renderRows()

local rownums = union(getArgNums('header'), getArgNums('data'))
table.sort(rownums)
for k, num in ipairs(rownums) do
addRow({
header = args['header' .. tostring(num)],
label = args['label' .. tostring(num)],
data = args['data' .. tostring(num)],
datastyle = args.datastyle,
class = args['class' .. tostring(num)],
rowclass = args['rowclass' .. tostring(num)],
-- @deprecated next; target .infobox-<name> rowclass
rowstyle = args['rowstyle' .. tostring(num)],
rowcellstyle = args['rowcellstyle' .. tostring(num)]
})
end
end

local function renderNavBar()
if not args.name then return end

has_rows = true
root
:tag('tr')
:tag('td')
:attr('colspan', '2')
:addClass('infobox-navbar')
:wikitext(require('Module:Navbar')._navbar{
args.name,
mini = 1,
})
end

local function renderItalicTitle()
local italicTitle = args['italic title'] and mw.ustring.lower(args['italic title'])
if italicTitle == '' or italicTitle == 'force' or italicTitle == 'yes' then
root:wikitext(require('Module:Italic title')._main({}))
end
end

-- Categories in otherwise empty rows are collected in empty_row_categories.
-- This function adds them to the module output. It is not affected by
-- args.decat because this module should not prevent module-external categories
-- from rendering.
local function renderEmptyRowCategories()
for _, s in ipairs(empty_row_categories) do
root:wikitext(s)
end
end

-- Render tracking categories. args.decat == turns off tracking categories.
local function renderTrackingCategories()
if args.decat == 'yes' then return end
if args.child == 'yes' then
if args.title then
root:wikitext(
'[[Category:Pages using embedded infobox templates with the title parameter]]'
)
end
elseif #(getArgNums('data')) == 0 and mw.title.getCurrentTitle().namespace == 0 then
root:wikitext('[[Category:Articles using infobox templates with no data rows]]')
end
end

--[=[
Loads the templatestyles for the infobox.

TODO: FINISH loading base templatestyles here rather than in
MediaWiki:Common.css. There are 4-5000 pages with 'raw' infobox tables.
See [[Mediawiki_talk:Common.css/to_do#Infobox]] and/or come help :).
When we do this we should clean up the inline CSS below too.
Will have to do some bizarre conversion category like with sidebar.

]=]
local function loadTemplateStyles()
local frame = mw.getCurrentFrame()

local hlist_templatestyles = ''
if lists.hlist_t.found then
hlist_templatestyles = frame:extensionTag{
name = 'templatestyles', args = { src = lists.hlist_t.styles }
}
end

local plainlist_templatestyles = ''
if lists.plainlist_t.found then
plainlist_templatestyles = frame:extensionTag{
name = 'templatestyles', args = { src = lists.plainlist_t.styles }
}
end

-- See function description
local base_templatestyles = frame:extensionTag{
name = 'templatestyles', args = { src = 'Module:Infobox/styles.css' }
}

local templatestyles = ''
if args['templatestyles'] then
templatestyles = frame:extensionTag{
name = 'templatestyles', args = { src = args['templatestyles'] }
}
end

local child_templatestyles = ''
if args['child templatestyles'] then
child_templatestyles = frame:extensionTag{
name = 'templatestyles', args = { src = args['child templatestyles'] }
}
end

local grandchild_templatestyles = ''
if args['grandchild templatestyles'] then
grandchild_templatestyles = frame:extensionTag{
name = 'templatestyles', args = { src = args['grandchild templatestyles'] }
}
end

return table.concat({
-- hlist -> plainlist -> base is best-effort to preserve old Common.css ordering.
-- this ordering is not a guarantee because the rows of interest invoking
-- each class may not be on a specific page
hlist_templatestyles,
plainlist_templatestyles,
base_templatestyles,
templatestyles,
child_templatestyles,
grandchild_templatestyles
})
end

-- common functions between the child and non child cases
local function structure_infobox_common()
renderSubheaders()
renderImages()
preprocessRows()
renderRows()
renderBelowRow()
renderNavBar()
renderItalicTitle()
renderEmptyRowCategories()
renderTrackingCategories()
cleanInfobox()
end

-- Specify the overall layout of the infobox, with special settings if the
-- infobox is used as a 'child' inside another infobox.
local function _infobox()
if args.child ~= 'yes' then
root = mw.html.create('table')

root
:addClass(args.subbox == 'yes' and 'infobox-subbox' or 'infobox')
:addClass(args.bodyclass)
-- @deprecated next; target .infobox-<name>
:cssText(args.bodystyle)

has_list_class({ args.bodyclass })

renderTitle()
renderAboveRow()
else
root = mw.html.create()

root
:wikitext(args.title)
end
structure_infobox_common()

return loadTemplateStyles() .. root
end

-- If the argument exists and isn't blank, add it to the argument table.
-- Blank arguments are treated as nil to match the behaviour of ParserFunctions.
local function preprocessSingleArg(argName)
if origArgs[argName] and origArgs[argName] ~= '' then
args[argName] = origArgs[argName]
end
end

-- Assign the parameters with the given prefixes to the args table, in order, in
-- batches of the step size specified. This is to prevent references etc. from
-- appearing in the wrong order. The prefixTable should be an array containing
-- tables, each of which has two possible fields, a "prefix" string and a
-- "depend" table. The function always parses parameters containing the "prefix"
-- string, but only parses parameters in the "depend" table if the prefix
-- parameter is present and non-blank.
local function preprocessArgs(prefixTable, step)
if type(prefixTable) ~= 'table' then
error("Non-table value detected for the prefix table", 2)
end
if type(step) ~= 'number' then
error("Invalid step value detected", 2)
end

-- Get arguments without a number suffix, and check for bad input.
for i,v in ipairs(prefixTable) do
if type(v) ~= 'table' or type(v.prefix) ~= "string" or
(v.depend and type(v.depend) ~= 'table') then
error('Invalid input detected to preprocessArgs prefix table', 2)
end
preprocessSingleArg(v.prefix)
-- Only parse the depend parameter if the prefix parameter is present
-- and not blank.
if args[v.prefix] and v.depend then
for j, dependValue in ipairs(v.depend) do
if type(dependValue) ~= 'string' then
error('Invalid "depend" parameter value detected in preprocessArgs')
end
preprocessSingleArg(dependValue)
end
end
end

-- Get arguments with number suffixes.
local a = 1 -- Counter variable.
local moreArgumentsExist = true
while moreArgumentsExist == true do
moreArgumentsExist = false
for i = a, a + step - 1 do
for j,v in ipairs(prefixTable) do
local prefixArgName = v.prefix .. tostring(i)
if origArgs[prefixArgName] then
-- Do another loop if any arguments are found, even blank ones.
moreArgumentsExist = true
preprocessSingleArg(prefixArgName)
end
-- Process the depend table if the prefix argument is present
-- and not blank, or we are processing "prefix1" and "prefix" is
-- present and not blank, and if the depend table is present.
if v.depend and (args[prefixArgName] or (i == 1 and args[v.prefix])) then
for j,dependValue in ipairs(v.depend) do
local dependArgName = dependValue .. tostring(i)
preprocessSingleArg(dependArgName)
end
end
end
end
a = a + step
end
end

-- Parse the data parameters in the same order that the old {{infobox}} did, so
-- that references etc. will display in the expected places. Parameters that
-- depend on another parameter are only processed if that parameter is present,
-- to avoid phantom references appearing in article reference lists.
local function parseDataParameters()

preprocessSingleArg('autoheaders')
preprocessSingleArg('child')
preprocessSingleArg('bodyclass')
preprocessSingleArg('subbox')
preprocessSingleArg('bodystyle')
preprocessSingleArg('title')
preprocessSingleArg('titleclass')
preprocessSingleArg('titlestyle')
preprocessSingleArg('above')
preprocessSingleArg('aboveclass')
preprocessSingleArg('abovestyle')
preprocessArgs({
{prefix = 'subheader', depend = {'subheaderstyle', 'subheaderrowclass'}}
}, 10)
preprocessSingleArg('subheaderstyle')
preprocessSingleArg('subheaderclass')
preprocessArgs({
{prefix = 'image', depend = {'caption', 'imagerowclass'}}
}, 10)
preprocessSingleArg('captionstyle')
preprocessSingleArg('imagestyle')
preprocessSingleArg('imageclass')
preprocessArgs({
{prefix = 'header'},
{prefix = 'data', depend = {'label'}},
{prefix = 'rowclass'},
{prefix = 'rowstyle'},
{prefix = 'rowcellstyle'},
{prefix = 'class'}
}, 50)
preprocessSingleArg('headerclass')
preprocessSingleArg('headerstyle')
preprocessSingleArg('labelstyle')
preprocessSingleArg('datastyle')
preprocessSingleArg('below')
preprocessSingleArg('belowclass')
preprocessSingleArg('belowstyle')
preprocessSingleArg('name')
-- different behaviour for italics if blank or absent
args['italic title'] = origArgs['italic title']
preprocessSingleArg('decat')
preprocessSingleArg('templatestyles')
preprocessSingleArg('child templatestyles')
preprocessSingleArg('grandchild templatestyles')
end

-- If called via #invoke, use the args passed into the invoking template.
-- Otherwise, for testing purposes, assume args are being passed directly in.
function p.infobox(frame)
if frame == mw.getCurrentFrame() then
origArgs = frame:getParent().args
else
origArgs = frame
end

parseDataParameters()

return _infobox()
end

-- For calling via #invoke within a template
function p.infoboxTemplate(frame)
origArgs = {}
for k,v in pairs(frame.args) do origArgs[k] = mw.text.trim(v) end

parseDataParameters()

return _infobox()
end
return p

User:MrSolis

2025-10-07T23:50:38Z

MrSolis: Blanked the page

User talk:MrSolis

2025-10-07T23:50:27Z

MrSolis: minor message

== 7 Oct 2025 ==
Three things:
# I believe I have fixed all instances of "math error" on the wiki due to "\textrm," although I have not checked every page.
# I am on the Discord, I just don't chat, nor am I considering revealing myself for now.
# Don't reply, I will not respond.

Directed head notation

2025-10-07T23:44:03Z

MrSolis: …

'''Directed head notation''' is a notation for specifying a [[Turing machine]] configuration using tape compression and a TM head which "points" either to the left or right. Directed head notation may be used for a complete tape configuration<math display="block">0^\infty \; 1 \; \textrm{<}\textrm{B} \; 0^3 \; 13^{10} \; 2 \; 0^\infty</math>

or for a partial configuration <math display="block">101 \; \textrm{A}\textrm{>} \; 1^n</math>

== Tape Compression ==
This notation supports run-length encoding for tape compression using "exponents". Given a "word" (sequence of tape symbols) <math>w</math> and a count <math>n</math>, <math>w^n</math> represents <math>n</math> repetitions of <math>w</math> concatenated. So for example, <math>2^4 = 2222</math> and <math>10^3 = 101010</math>.

It is important to note here that the words "2" and "10" in these examples are sequences of tape symbols and not integers and that the counts "4" and "3" are integer repetition counts, not representing integer exponentiation. It is perhaps unfortunate that these compressed blocks look identical to integer mathematical expressions. Generally, it should be obvious from the context that this is a tape configuration and not a math expression.

Segments of the tape may also be specified without exponents which represent unrepeated (or 1 repeat) of that segment. The notation <math>0^\infty</math> is used to represent the infinite sequence of blank symbols at either end of a configuration. In general, there will be many different notations for identical tape segments. For example:<math display="block">0^\infty \; 121212 = 0^\infty \; 12 \; 12 \; 12 = 0^\infty \; 12^3 = 0^\infty \; 01 \; 21^2 \; 2</math>

== Directed Head ==
Traditionally, the Turing machine head is considered to be located "on" a tape cell, for example some common traditional notation for a TM configuration include:<math display="block">\dots 0110 \underset{A}{\underline{2}} 01110 \dots</math>or<math display="block">\dots 0110 (A2) 01110 \dots</math>which indicate that the TM is in state A and currently positioned on the tape cell containing the 2. In these notations there are 3 groupings of symbols: those to the left (<math>\dots 0110</math>), those to the right (<math>01110 \dots</math>) and the single current symbol (2).

In directed head notation, we instead conceptualize the TM head as in the process of moving from one tape cell to another. So the above configuration could be represented by either<math display="block">\dots 0110 \; \textrm{A}\textrm{>} \; 2 01110 \dots</math>or<math display="block">\dots 0110 2 \; \textrm{<}\textrm{A} \; 01110 \dots</math>depending on which direction it moved immediately previous to this config. In many contexts, these may be considered equivalent configurations (since the forward behavior is identical for either). Here the notation "A>" means that the TM is in state A moving toward the right and "<A" means that it is moving to the left. The "current symbol" is the symbol "small end" of these "directed head" arrows.

== Partial Configurations ==
A directed head configuration includes a directed head and zero or more tape segments on each side. If it includes <math>0^\infty</math> at both ends, then it is a complete configuration (specifying precisely the entire tape), otherwise it is a partial configuration (specifying only a limited context around the TM head). For example, the partial configuration<math display="block">101\;\textrm{C}\textrm{>}\;1^3</math>matches any of these complete configurations<math display="block">\begin{array}{rcl}
0^\infty \; 101 & \textrm{C}\textrm{>} & 1^3 \; 0^\infty \\
0^\infty \; 11101 & \textrm{C}\textrm{>} & 1^8 \; 0^\infty \\
0^\infty \; 01^3 & \textrm{C}\textrm{>} & 11^2 \; 0^\infty \\
\end{array}</math>Partial configurations may have no segments specified even on the side the TM head is facing. For example<math display="block">\textrm{<}\textrm{C} \; 101</math>is a valid partial configuration. In these cases, we cannot tell what the "current symbol" is until we know the complete configuration. These configurations are common as the result of configuration transitions as described below.

== Configuration Transitions ==
One of the most common use cases for directed head notation is for specifying configuration transition rules. For example, the rule<math display="block">\begin{array}{c}
\\
0^\infty \; 011 \; \textrm{<}\textrm{C} \; 0^\infty \; \xrightarrow{3} \; 0^\infty \; \textrm{<}\textrm{C} \; 101 \; 0^\infty \\
\end{array}</math>indicates that if the TM starts in config <math> 0^\infty \; 011 \; \textrm{<}\textrm{C} \; 0^\infty</math>, 3 steps later it will be in configuration <math> 0^\infty \; \textrm{<}\textrm{C} \; 101 \; 0^\infty</math>. It is common to define these rules for partial configurations. For example,<math display="block">\begin{array}{c}
\\
011 \; \textrm{<}\textrm{C} \; \xrightarrow{3} \; \textrm{<}\textrm{C} \; 101 \\
\end{array}</math>which means that for any complete configuration <math> w \; 011 \; \textrm{<}\textrm{C} \; u</math> (where <math> w, u</math> are any valid left and right half-tapes), 3 steps later it will be in configuration <math> w \; \textrm{<}\textrm{C} \; 101 \; u</math>.

Transition rules become especially useful once you use induction to prove them over arbitrary repetition counts. For example, the previous transition rule can prove this [[Shift rule|shift rule]] for all <math> n \ge 0</math>:<math display="block">\begin{array}{c}
\\
011^n \; \textrm{<}\textrm{C} \; \xrightarrow{3n} \; \textrm{<}\textrm{C} \; 101^n \\
\end{array}</math>
[[Category:Analysis Techniques]]

Block Analysis

2025-10-07T23:39:55Z

MrSolis: ˘𝀂˘

'''Block Analysis''' is when instead of looking at the head and symbols as individual entities, we group multiple of them into a "block" of symbols (Examples: [10], [102], [10011]). Blocks can be infinite, containing the infinite string of 0s on either side of the tape, generally represented by a dollar sign (Examples: [$10], [101$]). They can also contain the head, assuming [[Directed Head Notation]]. Generally the head is always on the outside of the block, pointing outwards (Examples: [1B>], [<C], [102A>], [<D11]).

== Example: 1RB---1LC_2RC0LA2LB_1LB0LB0RB ==
In 66 steps from the starting position, the tape becomes <math>0^\infty \; 22212 \; \textrm{<}\textrm{B} \; 201021 \; 0^\infty</math>, which can be grouped as follows: <math>[\$2] \; [22] \; [12] \; [\textrm{<}\textrm{B}] \; [201021\$]</math>. The grouping is arbitrary, but it typically has a purpose.

Suppose we want to simulate the TM while the tape is grouped together, we ungroup the head and the block it is pointing to, in this case it's the [12] and the [<B]. And simulate it until the head points outwards:

<math display="block">12 \; \textrm{<}\textrm{B} \; \rightarrow 1 \; \textrm{<}\textrm{B} \; 2 \; \rightarrow \; \textrm{<}\textrm{A} \; 02</math>

Finally, we regroup the resulting tape segment however we like. In this case: I want to group everything into one block: [<A02], but any grouping is allowed. So the current tape is now <math>[\$2] \; [22] \; [\textrm{<}\textrm{A}02] \; [201021\$]</math>. What we've effectively done is created a rule: whenever we see [12] [<B] in that order, replace it with [<A02]. We can do this again with [22] [<A02]: first ungroup, then simulate, then regroup:

<math display="block">[22] \; [\textrm{<}\textrm{A}02] \; \rightarrow \; 22 \; \textrm{<}\textrm{A} \; 02 \; \rightarrow \; 2 \; \textrm{<}\textrm{C}
\; 102 \; \rightarrow \; 0 \; \textrm{B}\textrm{>} \; 102 \; \rightarrow \; 0 \; \textrm{<}\textrm{A} \; 002
\; \rightarrow \; 1 \; \textrm{B}\textrm{>} \; 002 \; \rightarrow \; 12 \; \textrm{C}\textrm{>} \; 02 \; \rightarrow \;
12 \; \textrm{<}\textrm{B} \; 12 \; \rightarrow \; 1 \; \textrm{<}\textrm{B} \; 212 \rightarrow \; \textrm{<}\textrm{A} \; 0212
\; \rightarrow \; [\textrm{<}\textrm{A}02] \; [12]</math>

Note that I regrouped it in such a way that we get [<A02] again. This is intentional, as we want to minimize the block types for our analysis to be effective. In fact, if we restrict blocks to the left of the head to only be [$2], [12], and [22], the blocks to the right of the head to be [12], [22], [0102], and [201021$], and the blocks containing the head to be [<B], [<A02], and [0B>], then we can create a closed set of blocks that can always be regrouped to a different set of these blocks: we can show this using two tables, the first being every block with a left-pointing head interacting with every left block, and every block with a right-pointing head interacting with every right block:
{| class="wikitable"
|+
!
![$2]
![12]
![22]
|-
|[<B]
|[$2] [0B>]
|[<A02]
|[<B] [22]
|-
|[<A02]
|[$2] [22] [12] [0B>]
|[<B] [0102]
|[<A02] [12]
|}
{| class="wikitable"
|+
!
![12]
![22]
![0102]
![201021$]
|-
|[0B>]
|[12] [0B>]
|[22] [0B>]
|[22] [12] [0B>]
|[<B] [22] [201021$]
|}
It's important to note the tape after can be expressed using the blocks in this closed set after a number of steps.

After 66 steps, the tape becomes <math>[\$2] \; [22] \; [12] \; [\textrm{<}\textrm{B}] \; [201021\$]</math>, and from that point on, we will always be able to return to another tape using only the blocks we allow without ever halting. Therefore 1RB---1LC_2RC0LA2LB_1LB0LB0RB never halts.

Usually, some of these block configurations is closed, but with the exception of a few rules that halt. In those cases, further analysis is typically needed.

== Bonus: Regrouping Symbols ==
Sometimes, a few block interactions can almost be closed with the exception of an extra symbol that messes everything up. One solution is to make that symbol its own block, which may end up multiplying the number of blocks you have to deal with. Another way to deal with this is to regroup the extra symbol with the rest of the tape.

Take the TM 1RB2LB0LC_2LA2RA1RB_---2LA1LC for example. There is the following set of blocks that is almost closed: with the exception of a single rule:
{| class="wikitable"
|+
!
![102]
![1102]
![1022]
![10202]
![11022]
![10222]
![110202]
![102202]
![102$]
![1102$]
![1022$]
|-
|[B>]
|[211] [B>]
|[<C] [1022]
|[2111] [B>]
|[<C] [11022]
|[<C] [10222]
|[21111] [B>]
|[<C] [102202]
|[<C02] [1022]
|[<C] [1102$]
|[<C] [1022$]
|[<C02] [102$]
|}
{| class="wikitable"
|+
!
![211]
![111]
![2111]
![21111]
![$11]
![$1111]
|-
|[<C]
|[111] [B>]
|[<C] [102]
|[<C] [1022]
|[<C02] [102]
|[$1111] [B>]
|[$11] [211] [B>]
|-
|[<C02]
|???
|[<C] [10202]
|[<C] [102202]
|[<C02] [10202]
|[$1111] [2111] [B>]
|[$11] [211] [21111] [B>]
|}
The only interaction left is [211] [<C02]. Simulating this gives us <math>\textrm{<}\textrm{A} \; 21022 </math>, which can't be regrouped to our previously mentioned blocks. However, if we take one step back, we get <math>1 \; \textrm{<}\textrm{C} \; 1022</math>, which can be grouped as <math>1 \; [ \textrm{<}\textrm{C} ] \; [1022] </math>. The extra 1 can then be regrouped with other blocks on the left. Let's denote 1 as [<1] with the arrow indicating that it will try to regroup with blocks on the left. This completes our second table:
{| class="wikitable"
!
![211]
![111]
![2111]
![21111]
![$11]
![$111]
![$1111]
|-
|[<C]
|[111] [B>]
|[<C] [102]
|[<C] [1022]
|[<C02] [102]
|[$1111] [B>]
|Halt
|[$11] [211] [B>]
|-
|[<C02]
|[<1] [<C] [1022]
|[<C] [10202]
|[<C] [102202]
|[<C02] [10202]
|[$1111] [2111] [B>]
|Halt
|[$11] [211] [21111] [B>]
|-
|[<1]
|[2111]
|[<1] [111]
|[21111]
|[211] [111]
|[$111]
|[$1111]
|[$11] [111]
|}
Note that the interaction [<1] [<C] is undefined, so you would have to combine the [<1] with the block to its left before proceeding. Also note the newly introduced halting interactions, meaning further analysis is needed to solve this TM.
[[Category:Analysis Techniques]]

Longitudinal Analysis

2025-10-07T23:31:54Z

MrSolis: who wrote this?

'''Longitudinal Analysis''' is a type of analysis on a TM, where, instead of analyzing the TM based on its direct forward behavior, takes advantage of a certain property of the TM which allows you to predict certain interactions ahead of time and simulate steps out of order. The best way to explain this is through an example.

== Example TM: 1RB4LA1LB2LA0RB_2LB3RB4LA---1RA ==
A [[Block Analysis]] of 1RB4LA1LB2LA0RB_2LB3RB4LA---1RA provides the following rules:
{| class="wikitable"
|+
!
![2]
![22]
![24]
![42]
![44]
![4$]
![2$]
![22$]
![24$]
![42$]
![44$]
|-
|[B>]
|[<A] [4>]
|[<A] [42]
|[<A] [44]
|[33] [B>]
|[10] [B>]
|[<A] [42] [4$]
|[<A] [4$]
|[<A] [42$]
|[<A] [44$]
|Halt
|[<A] [24] [2$]
|-
|[4>]
|[42]
|[42] [2]
|[42] [4>]
|[44] [2]
|[44] [4>]
|[44$]
|[42$]
|[42] [2$]
|[42] [4$]
|[44] [2$]
|[44] [4$]
|}
{| class="wikitable"
|+
!
![33]
![10]
![11]
![$1]
|-
|[<A]
|[<A] [22]
|[11] [B>]
|[<A] [44]
|[$1] [B>] [4>]
|}
Starting from: [$1] [B>] [24$]

Note that the ''only'' possible interaction with any of the left blocks ([33], [10], [11], and [$1]) can be with [<A]. So we can predict that ahead of time and "borrow" an [<A], along with an [<A^-1] indicating that an [<A] has been borrowed. So a possible simulation in Longitudinal Analysis could look like this:<math display="block">[\textrm{<}\textrm{A}^{-1}] \; [33] \; \rightarrow \; [\textrm{<}\textrm{A}^{-1}] \; [33] \; [\textrm{<}\textrm{A}] \;
[\textrm{<}\textrm{A}^{-1}] \; \rightarrow \; [\textrm{<}\textrm{A}^{-1}] \; [\textrm{<}\textrm{A}] \; [22] \; [\textrm{<}\textrm{A}^{-1}]
\; \rightarrow \; [22] \; [\textrm{<}\textrm{A}^{-1}]</math>

What makes this so useful is that we can pair [<A^-1] with [B>] to create a new block: [<A^-1 B>]. Let's see what we can do with this new type of block:<math display="block">[\textrm{<}\textrm{A}^{-1} \; \textrm{B}\textrm{>}] [24] \rightarrow [\textrm{<}\textrm{A}^{-1}][\textrm{B}\textrm{>}][24] \rightarrow
[\textrm{<}\textrm{A}^{-1}][\textrm{<}\textrm{A}][44] \rightarrow [44]</math><math display="block">[\textrm{<}\textrm{A}^{-1} \; \textrm{B}\textrm{>}][42] \rightarrow [\textrm{<}\textrm{A}^{-1}][\textrm{B}\textrm{>}][42] \rightarrow
[\textrm{<}\textrm{A}^{-1}][33][\textrm{B}\textrm{>}] \rightarrow
[\textrm{<}\textrm{A}^{-1}][33][\textrm{<}\textrm{A}][\textrm{<}\textrm{A}^{-1} \; \textrm{B}\textrm{>}] \rightarrow
[\textrm{<}\textrm{A}^{-1}][\textrm{<}\textrm{A}][22][\textrm{<}\textrm{A}^{-1} \; \textrm{B}\textrm{>}] \rightarrow
[22][\textrm{<}\textrm{A}^{-1} \; \textrm{B}\textrm{>}]</math><math>[\textrm{<}\textrm{A}^{-1} \; \textrm{B}\textrm{>}][44] \rightarrow [\textrm{<}\textrm{A}^{-1}][\textrm{B}\textrm{>}][44] \rightarrow
[\textrm{<}\textrm{A}^{-1}][10][\textrm{B}\textrm{>}] \rightarrow
[\textrm{<}\textrm{A}^{-1}][10][\textrm{<}\textrm{A}][\textrm{<}\textrm{A}^{-1}\;\textrm{B}\textrm{>}] \rightarrow
[\textrm{<}\textrm{A}^{-1}][11][\textrm{B}\textrm{>}][\textrm{<}\textrm{A}^{-1}\;\textrm{B}\textrm{>}] \rightarrow
[\textrm{<}\textrm{A}^{-1}][11][\textrm{<}\textrm{A}][\textrm{<}\textrm{A}^{-1}\;\textrm{B}\textrm{>}][\textrm{<}\textrm{A}^{-1}\;\textrm{B}\textrm{>}]
\rightarrow [\textrm{<}\textrm{A}^{-1}][\textrm{<}\textrm{A}][44][\textrm{<}\textrm{A}^{-1}\;\textrm{B}\textrm{>}]^2 \rightarrow
[44][\textrm{<}\textrm{A}^{-1}\;\textrm{B}\textrm{>}]^2
</math>We can modify the first table from our block analysis to get this new table:
{| class="wikitable"
!
![2]
![22]
![24]
![42]
![44]
![4$]
![2$]
![22$]
![24$]
![42$]
![44$]
|-
|[<A^-1 B>]
|[4>]
|[42]
|[44]
|[22] [<A^-1 B>]
|[44] [<A^-1 B>]^2
|[42] [4$]
|[4$]
|[42$]
|[44$]
|Halt
|[24] [2$]
|-
|[4>]
|[42]
|[42] [2]
|[42] [4>]
|[44] [2]
|[44] [4>]
|[44$]
|[42$]
|[42] [2$]
|[42] [4$]
|[44] [2$]
|[44] [4$]
|}Our current starting position is [$1] [B>] [24$], which can also be [$1] [<A] [<A^-1 B>] [24$]. One last change, we can almost completely get rid of [<A]. If we combine [$1] and [<A], we will get [$1 <A], which can be simulated by itself:
<math display="block">[\$1 \; \textrm{<}\textrm{A}] \rightarrow [\$1][\textrm{<}\textrm{A}] \rightarrow [\$1][\textrm{B}\textrm{>}][4>] \rightarrow
[\$1 \; \textrm{<}\textrm{A}][\textrm{<}\textrm{A}^{-1} \; \textrm{B}\textrm{>}][4>]</math>At the end, you get the full transition table:
{| class="wikitable"
|+
!From
!To
|-
|[$1 <A]
|[$1 <A] [<A^-1 B>] [4>]
|}
{| class="wikitable"
!
![2]
![22]
![24]
![42]
![44]
![4$]
![2$]
![22$]
![24$]
![42$]
![44$]
|-
|[<A^-1 B>]
|[4>]
|[42]
|[44]
|[22] [<A^-1 B>]
|[44] [<A^-1 B>]^2
|[42] [4$]
|[4$]
|[42$]
|[44$]
|Halt
|[24] [2$]
|-
|[4>]
|[42]
|[42] [2]
|[42] [4>]
|[44] [2]
|[44] [4>]
|[44$]
|[42$]
|[42] [2$]
|[42] [4$]
|[44] [2$]
|[44] [4$]
|}
Start: [$1 <A] [<A^-1 B>] [24$]

Note that we completely omitted [<A] from our set of blocks, since we have fully predicted when [<A] arrives.

There are multiple ways to proceed with analysis, but I will show the standard way:

== Standard Longitudinal Analysis (and Example Proof) ==
The standard way to proceed is to analyze each individual block to infinity one at a time, then progressing cell by cell rather than time, hence the name "Longitudinal." We will see how this type of analysis can produce results that may not be noticeable in a direct forward analysis. In our previous example, we start with the edge block [$1 <A] and apply the rule infinite times to get [$1 <A] ([<A^-1 B>] [4>])^inf. Our starting position would now be [$1 <A] ([<A^-1 B>] [4>])^inf [<A^-1 B>] [24$]. Now the [$1 <A] is irrelevant, so we can actually get away with just writing ([<A^-1 B>] [4>])^inf [<A^-1 B>] [24$] -> ([<A^-1 B>] [4>])^inf [44$]. For this TM, let's define B(n) = [<A^-1 B>]^n [4>], so our tape becomes (B(1))^inf [44$]. Let's first take out a B(1) and interact it with [44$] to get

<math display="block">B(1) \; [44\$] \rightarrow [\textrm{<}\textrm{A}^{-1} \; \textrm{B}\textrm{>}] [4>] [44\$]
\rightarrow [\textrm{<}\textrm{A}^{-1} \; \textrm{B}\textrm{>}] [44] [4\$] \rightarrow
[44] [\textrm{<}\textrm{A}^{-1} \; \textrm{B}\textrm{>}]^2 [4\$] \rightarrow
[44] [\textrm{<}\textrm{A}^{-1} \; \textrm{B}\textrm{>}] [42] [4\$] \rightarrow
[44] [22] [\textrm{<}\textrm{A}^{-1} \; \textrm{B}\textrm{>}] [4\$] \rightarrow
[44] [22] [42] [4\$]</math>

So now we have (B(1))^inf [42] [22] [42] [4$]. Now, we can derive these rules (left as an exercise for the reader):

B(2n+1) [22] -> [22] B(n)

B(2n+2) [22] -> [42] B(n)

B(n+1) [42] -> [44] B(2n+1)

B(n) [44] -> [44] B(2n)

I'll also claim that if we have B(i_0) B(j_0) ([22] or [42] or [44]) and i_0 >= j_0 >= 1, then we will end with ([22] or [42] or [44]) B(i_1) B(j_1) and i_1 >= j_1. This applies to any number of variables (also left as an exercise for the reader)

We haven't yet developed a set of closed rules, but we're getting there. We still need one more condition that is not yet met in our current tape, so let's simulate it until we get that condition:

Let's take another step in our longitudinal analysis: (B(1))^inf [42] -> (B(1))^inf B(1) [42] -> (B(1))^inf [44] B(1) -> [44] (B(2))^inf B(1)

Our [44] is now irrelevant, so we can remove it:

(B(2))^inf B(1) [22] [42] [4$]

We repeat this process to get

(B(4))^inf B(3) B(0) B(0) [42] [4$]

But now we run into a rule that's not handled by the rules we derived, so we have to leave our universe of rules and start thinking about the tape individually. This is the only time in the analysis where this happens. Note that B(0) is just a 4 symbol, and two 4 symbols become a [44] block. So we have

(B(4))^inf B(3) [44] [42] [4$] -> (B(8))^inf B(6) [42] [4$] -> (B(16))^inf B(11) [4$]

Note that [4$] is equivalent to [4>] [$], so we will do that to get (B(16))^inf B(11) B(0) [$], and we also get these rules:

B(n+3) B(0) [$] -> [44] B(2n+1) [$] -> [44] [42] B(n) [$]

B(2n+1) [$] -> [42] B(n) [$]

B(2n+2) [$] -> [22] B(n+1) [$]

Now I will state my inductive claim: Given <math>\dots B(a_2) \; B(a_1) \; B(a_0) \; B(b) \; [ \$ ]</math> where <math>a_0\leq a_1 \leq a_2\dots </math> and one of the following:

* <math>a_0+1 \geq 3b\text{ and }b \geq 1</math> or
* <math>a_0 \geq 3\text{ and }b=0</math>

You can reach a tape of the form <math>\dots B(a_2) \; B(a_1) \; B(a_0) \; B(b) \; [ \$ ]</math> again with the same conditions.

I will not prove this on this page, as it is a bit tedious, but hopefully the idea is clear enough that you'll just accept it for the sake of understanding the purpose of Longitudinal Analysis. Afterwards, since we've reached a position that satisfies the inductive condition, we know it will stay like that forever without halting.

== Warnings ==
The standard way to proceed is to analyze each individual block to infinity one at a time, then progressing cell by cell rather than time, hence the name "Longitudinal." However, the flexibility allows for analysis in any order, with a catch:

Because we are now able to simulate steps in different orders, there are different rules as to when a TM halts or not. Just because we can make infinite steps without halting doesn't necessarily mean the TM doesn't halt. in our previous example, we can just simply apply rule [$1 <A] -> [$1 <A] [<A^-1 B>] [4>] infinite times to get [$1 <A] ([<A^-1 B>] [4>])^inf [<A^-1 B>] [24$], but we didn't really simulate the important part of the TM. In particular, if we already have two blocks that halt, [<A^-1 B>][42$], we could avoid it indefinitely by constantly making other transitions. However, if we maintain the rule that every possible interaction between blocks will eventually be made, then showing that such a process doesn't lead to halting ''will'' show that the original TM never halts.

Conversely, if you find a halting interaction during analysis, you need an extra condition that simply shows that the halting transition will eventually happen: any block to the right of the halting location (or left if your rules are mirrored) must eventually die out. If it does not, then that means in the original TM, when we assumed that the head would eventually come back as [<A], it actually never comes back, becoming a translated cycler or for another reason.
[[Category:Analysis Techniques]]

Maximum Consecutive Ones Function

2025-10-07T23:28:35Z

MrSolis: <°ᗨ°)⦣

The '''Maximum Consecutive Ones''' function (named <math>num(n)</math> by Ben-Amram, Julstrom and Zwick)<ref>Ben-Amram A.M., Julstrom B.A. and Zwick U. (1996). [http://dx.doi.org/10.1007/BF01192693 A note on busy beavers and other creatures]. ''Mathematical Systems Theory'' '''29''' (4), July-August 1996, 375-386.</ref> is a [[Busy Beaver function]] which measures the maximum number of consecutive 1s left on the tape at halt across all n-state 2-symbol [[Turing machine]]s which leave all their 1s consecutively. Unlike <math>\Sigma(n)</math>, this allows some amount of order over the "API" of these TMs, so that their output can be used as inputs to another TM in some deterministic fashion. Note however, that this definition does not stipulate where the TM head must be positioned relative to the sequence of consecutive ones, so it is not completely trivial to use these results as input to a second TM.

This function is only defined for 2-symbol TMs. It is not entirely clear how best to extend it to multi-symbol TMs. One option would be to keep the definition the same, so only TMs which halt with all 1s on the tape would qualify. Another would be to allow any symbols as long as all non-0 symbols were in one contiguous chunk on the tape.

== Champions ==

{| class="wikitable"
|+ Known Values of num(n) function
|-
! Domain !! <math>num(n)</math> !! Champion TM !! Halting Config
!Source
|-
| [[BB(1)]]|| 1 || {{TM|1RZ---|halt}} || <math>0^\infty \; 1 \; \textrm{Z}\textrm{>} \; 0^\infty</math>
|Ben-Amram, Julstrom and Zwick (1996)
|-
|[[BB(2)]]
|4
|{{TM|1RB1LB_1LA1LZ|halt}}
|<math>0^\infty \; 1 \; \textrm{<}\textrm{Z} \; 1^3 \; 0^\infty</math>
|Ben-Amram, Julstrom and Zwick (1996)
|-
|[[BB(3)]]
|6
|{{TM|1RB1LC_1RC1LZ_1LA0LB|halt}} and 3 others
|<math>0^\infty \; 1 \; \textrm{<}\textrm{Z} \; 1^5 \; 0^\infty</math>
|Ben-Amram, Julstrom and Zwick (1996)
|-
|[[BB(4)]]
|12
|{{TM|1RB0LA_1RC1LB_1LB1RD_1RZ0RA|halt}}
|<math>0^\infty \; 1^{12} \; \textrm{Z}\textrm{>} \; 0^\infty</math>
|Ben-Amram, Julstrom and Zwick (1996)
|-
|[[BB(5)]]
|165
|{{TM|1RB1LA_1RC1LE_1RD1RE_0LA1RC_1RZ0LB|halt}}
|<math>0^\infty \; 1^{165} \; \textrm{Z}\textrm{>} \; 0^\infty</math>
|[https://groups.google.com/g/busy-beaver-discuss/c/pvtXPmuMsAg/m/UP0xcmwoEAAJ Announcement] by Andrés Sancho in Feb 2025
|}
Note: All TMs here are listed in [[TNF-1RB]] format with the exception that sometimes the halt transition is chosen to be <code>1LZ</code> when that leads to a "simpler" halting configuration.

For BB(3), there are actually 4 champion machines that all leave exactly 6 1s: {{TM|1RB1RZ_0RC1RB_1LC1LA|halt}}, {{TM|1RB1LC_1LA1RB_1LB1RZ|halt}}, {{TM|1RB1RA_1LC1RZ_1RA1LB|halt}}, {{TM|1RB1LC_1RC1RZ_1LA0LB|halt}}.

The num(5) champion was found in 2009 by Joachim Hertel.<ref>J. Hertel, "[https://content.wolfram.com/sites/19/2009/11/Hertel.pdf Computing the Uncomputable Rado Sigma Function]". The Mathematica Journal vol. 11 (2009).</ref><sup>p. 282</sup>

== References ==
<references />
[[category:Functions]]

Inductive Proof System

2025-10-07T23:25:48Z

MrSolis: :3

An '''Inductive Proof System''' is an [[Accelerated Simulator]] and [[Decider]] which operates by automatically detecting and proving [[Transition rule|transition rules]] using Mathematical Induction.

== Inductive Rule ==
An inductive rule is a general transition rule (a start and end configuration, generalized with variables for repetition counts) along with a proof. The proof generally has two pieces: the base case and the inductive case. Each is a list of steps where each step is (A) a specific TM transition, (B) an application of the inductive hypothesis, (C) an application of a previously defined rule.

=== Rule Levels ===
We can assign levels to any Inductive Rule. A Level 0 (L0) rule does not depend on any previously defined inductive rules. A Level 1 (L1) rule depends only upon previously proven L0 rules, etc. All L0 Rules (which only invoke the inductive hypothesis once) are [[Shift rule|Shift rules]].

== Example Proofs ==

=== Notation ===
In this article we will use the following notation for an Inductive Rule and its proof:

<math>P(n)</math>

* Proof by induction on n:
** Base case: ''List of steps to prove the base case <math>P(0)</math>. Often this is the empty list since <math>P(0)</math> is trivially true (in zero steps).''
** Inductive case: ''List of steps to prove <math>P(n+1)</math> of which some can be "IH" the inductive hypothesis that <math>P(n)</math>.''

=== Bouncer ===
Consider the [[bouncer]] {{TM|1RB0RC_0LC---_1RD1RC_0LE1RA_1RD1LE|non-halt}}. We can prove the following Inductive Rules:

# Shift (L0) Rule: <math>C(n) : \textrm{C}\textrm{>} \; 1^n \to 1^n \; \textrm{C}\textrm{>}</math>
#* Proof by induction on n
#** Base case: []<math display="block">\textrm{C}\textrm{>} \; 1^0 \to 1^0 \; \textrm{C}\textrm{>}</math>
#** Inductive case: [C1, IH]<math display="block">\textrm{C}\textrm{>} \; 1^{n+1} \xrightarrow{C1} 1 \; \textrm{C}\textrm{>} \; 1^n \xrightarrow{IH} 1^{n+1} \; \textrm{C}\textrm{>}</math>
# Shift (L0) Rule: <math>E(n) : 1^n \; \textrm{<}\textrm{E} \to \textrm{<}\textrm{E} \; 1^n</math>
#* Proof by induction on n
#** Base case: []
#** Inductive case: [E1, IH]
# L1 Rule: <math>A(n) : \textrm{A}\textrm{>} \; 1^n \; 0^\infty \to 1^{2n} \; \textrm{A}\textrm{>} \; 0^\infty</math>
#* Proof by induction on n
#** Base case: []
#** Inductive case: [A1, C(n), C0, D0, E(n+1), E0, D1, IH]<math display="block">\begin{array}{l}
\\
\textrm{A}\textrm{>} \; 1^{n+1} \; 0^\infty
& \xrightarrow{A1} &
0 \; \textrm{C}\textrm{>} \; 1^n \; 0^\infty \\
& \xrightarrow{C(n)} &
0 \; 1^n \; \textrm{C}\textrm{>} \; 0^\infty \\
& \xrightarrow{C0} &
0 \; 1^{n+1} \; \textrm{D}\textrm{>} \; 0^\infty \\
& \xrightarrow{D0} &
0 \; 1^{n+1} \; \textrm{<}\textrm{E} \; 0^\infty \\
& \xrightarrow{E(n+1)} &
0 \; \textrm{<}\textrm{E} \; 1^{n+1} \; 0^\infty \\
& \xrightarrow{E0} &
1 \; \textrm{D}\textrm{>} \; 1^{n+1} \; 0^\infty \\
& \xrightarrow{D1} &
1^2 \; \textrm{A}\textrm{>} \; 1^n \; 0^\infty \\
& \xrightarrow{IH} &
1^{2(n+1)} \; \textrm{A}\textrm{>} \; 0^\infty \\
\end{array}</math>
# L2 Rule: <math>0^\infty \; 1^a \; \textrm{A}\textrm{>} \; 0^\infty \to 0^\infty \; 1^{2a+6} \; \textrm{A}\textrm{>} \; 0^\infty</math>
#* Proof: [A0, B0, C1, C0, D0, E(a+2), E0, D1, A(a+1)]<math display="block">\begin{array}{l}
\\
0^\infty \; 1^a \; \textrm{A}\textrm{>} \; 0^\infty
& \xrightarrow{A0, B0, C1, C0, D0} &
0^\infty \; 1^{a+2} \; \textrm{<}\textrm{E} \; 0^\infty \\
& \xrightarrow{E(a+2)} &
0^\infty \; \textrm{<}\textrm{E} \; 1^{a+2} \; 0^\infty \\
& \xrightarrow{E0,D1} &
0^\infty \; 1^2 \; \textrm{A}\textrm{>} \; 1^{a+1} \; 0^\infty \\
& \xrightarrow{A(a+1)} &
0^\infty \; 1^{2a+4} \; \textrm{A}\textrm{>} \; 0^\infty \\
\end{array}</math>

We can see now that the last rule can be applied repeatedly forever, so if it is ever applied once, the TM will never halt. In fact, in this case the start config is equal to <math>0^\infty \; 1^0 \; \textrm{A}\textrm{>} \; 0^\infty</math> and thus this TM will never halt.

== Tape Compression ==
We need some automated way to compress the tape into a tuple of integers, and decompress the tape when needed.

=== Macro Machine ===
We can divide the tape into blocks of fixed size, and merge adjacent identical blocks into one and record the number of repetitions.

Here is an example of how a half-tape is compressed using macro machine:<pre>
111110110110101010110110 0^inf
= 111 110 110 110 101 010 110 110 000^inf (use block size 3)
= 111 110^3 101 010 110^2 000^inf
</pre>

=== Nested Repeater ===
We can compress the tape by looking for repeaters:<pre>
101110111 0^inf
= 1 0 1 1 1 0 1 1 1 0^inf
= 1 0 1 1 1 0 1 1^2 0^inf (use a a = a^2 for a = 1)
= 1 0 1 1 1 0 1^3 0^inf (use a a^n = a^(n+1) for a = 1)
= 1 0 1 1^2 0 1^3 0^inf (use a a = a^2 for a = 1)
= 1 0 1^3 0 1^3 0^inf (use a a^n = a^(n+1) for a = 1)
= 1 (0 1^3)^2 0^inf (use a a = a^2 for a = 0 1^3)
</pre>Decompression is simple: we only decompress the tape when the head points to a repeater:<pre>
l X> a^(n+1) r = l X> a a^n r
l X> a^0 r = l X> r
</pre>

=== Fixed Length Repeater ===
<pre>
1101111101111110 0^inf = 1101 (11)^2 0 (11)^3 0 0^inf (length = 2)
</pre>

=== Others ===
For counters and other complex pattern, we can design some specific methods to represent them.

A typical binary counter can be represented by:<pre>
definition of C:
C(d0,d1,dh,1) = dh 0^inf
C(d0,d1,dh,2n+0) = d0 C(d0,d1,n), n>0
C(d0,d1,dh,2n+1) = d1 C(d0,d1,n), n>0
increment rule: l qR QR> C(d0,d1,dh,n) → l <QL qL C(d0,d1,dh,n+1)
where d0,d1,dh,qL,qR are tape segments, l is half-tape, QL,QR are TM states, n is positive integer.
</pre>For [[Bell eats counter|bell eats counters]], when the head points to C, (i.e. l X> C(_,_,_,_)), if X=QL we can decompress tape in l to see whether it's prefix matches qR, if it matches we can apply the increment rule of the counter, otherwise we decompress C by expanding the definition of C (but not recursively unless the head points to C again) so that we can run the TM further.

For [[Sync bouncer counter|sync bouncer counters]], the counter may overflow, so we can use a different representation of the binary counter:<pre>
C'(0,0,0) = dh 0^inf
C'(2a,2b+1,0) = d0 C'(a,b,0)
C'(2a+1,2b,0) = d1 C'(a,b,0)
C'(a,b,n) is well formed iff a+b+1=2^n
increment: l qR QR> C'(a+1,b,n) → l <QL qL C'(a,b+1,n)
overflow: l qR' QR'> C'(0,b,n) → l <QL' qL' C'(2b+1,0,n+1)
where a,b,n are natural numbers, l is half-tape, QL,QR are states, and d0,d1,dh,qL,qR are tape segments.
</pre>We can also support arithmetic sequence:<pre>
0 1^2 0 1^3 0 1^4 0 1^5 = ((0 1^(2+1*i)) for i in range(4))
</pre>And some simple structural counters that can be described by a single integer:<pre>
B(1) = dh 0^inf
B(2n+0) = w^n d0 B(n)
B(2n+1) = w^n d1 B(n)
l qR QR> B(n) → l <QL qL B(n+1)
</pre>

== Find and Prove Rules ==
We need some automated way to find rules and prove/use them.

=== Find New Rule by Generalizing Known Rules ===
We can prove special rules, and generalize them by interpolation (and maybe also need to generalize their proof).

Example:<pre>
0^inf A> 0^inf → 0^inf A> 0 0^inf
0^inf A> 0 0^inf → 0^inf 1 A> 0^inf
0^inf 1 A> 0^inf → 0^inf 1 A> 0 0^inf
0^inf 1 A> 0 0^inf → 0^inf 1 1 A> 0^inf
0^inf 1 1 A> 0^inf → 0^inf 1^2 A> 0^inf

0^inf 1^2 A> 0^inf → 0^inf 1^2 A> 0 0^inf
0^inf 1^2 A> 0 0^inf → 0^inf 1^2 1 A> 0^inf
0^inf 1^2 1 A> 0^inf → 0^inf 1^3 A> 0^inf

0^inf 1^3 A> 0^inf → 0^inf 1^3 A> 0 0^inf
0^inf 1^3 A> 0 0^inf → 0^inf 1^3 1 A> 0^inf
0^inf 1^3 1 A> 0^inf → 0^inf 1^4 A> 0^inf

interpolation:
0^inf 1^(2+i) A> 0^inf → 0^inf 1^(2+i) A> 0 0^inf
0^inf 1^(2+i) A> 0 0^inf → 0^inf 1^(2+i) 1 A> 0^inf
0^inf 1^(2+i) 1 A> 0^inf → 0^inf 1^(3+i) A> 0^inf

merge:
0^inf 1^(2+i) A> 0^inf → 0^inf 1^(3+i) A> 0^inf

induction:
0^inf 1^2 A> 0^inf → 0^inf 1^(2+n) A> 0^inf

</pre>

=== Find New Rule by Specializing Known Rules ===
We can maintain a sequence of used rules, and keep the rules as general as possible, then specialize the rules when needed.

Example:<pre>
l A> 0^inf → l A> 0 0^inf
l A> 0 r → l 1 A> r
l A> 0^inf → l A> 0 0^inf
l A> 0 r → l 1 A> r
l 1 1 A> r → l 1^2 A> r

l A> 0^inf → l A> 0 0^inf
l A> 0 r → l 1 A> r
l 1^n 1 A> r → l 1^(n+1) A> r

l A> 0^inf → l A> 0 0^inf
l A> 0 r → l 1 A> r
l 1^n 1 A> r → l 1^(n+1) A> r

to merge
l1 A> 0^inf → l1 A> 0 0^inf
l2 A> 0 r2 → l2 1 A> r2
we need to solve equation:
l1 A> 0 0^inf = l2 A> 0 r2
then we have l1=l2, 0^inf=r2 and substitute them:
l2 A> 0^inf → l2 A> 0 0^inf
l2 A> 0 0^inf → l2 1 A> 0^inf
and then these two rules are ready to be merged as
l2 A> 0^inf → l2 1 A> 0^inf
then we can merge
l2 A> 0^inf → l2 1 A> 0^inf
l 1^n 1 A> r → l 1^(n+1) A> r
in a similar way into
l 1^n A> 0^inf → l 1^(n+1) A> 0^inf

induction:
l 1^n A> 0^inf → l 1^(n+m) A> 0^inf

</pre>A method for solving equations (similar to unification in type theory):<pre>
First we use ((X -> A→B) /\ (Y -> C→D)) -> (B=C -> X -> Y -> A→D) to get a rule A→D that has premises B=C,X,Y.
Then we simplify the rule (B=C -> X -> Y -> A→D) by solving equantions in the premise:
If (a,b)=(c,d) is in the premise list, we can replace it with a=c, b=d, where (x,y) can be tape segment concatenation (x y), tape segment repeation (x^y) or something similar.
If a=b is in the premise list, a is variable, we substitute all occurence of a by b in the rule.
If a*x+b=c*y+d is in the premise list, x,y are natural number variables, a,b,c,d are natural number constants, we can divide a,b,c,d by gcd(a,b,c,d) and then substitute x,y by a'*x'+b',c'*x'+d' based on some number theory methods.
For an expression of natural numbers, we can simplify it as a1*x1+a2*x2+...+an*xn+b, where a1,a2,...,an,b are natural number constants.
We can remove a=a from the premise list.

If the premise list is not empty after using these methods repeatly, we just leave it as part of the rule.
</pre>

=== Recursive Record-Breaking Analysis ===
We can run a Turing machine on a tape segment until it leaves the tape segment.

In this process, every time the Turing machine visits a new position, we recursively consider when the Turing machine will leave the positions it has already visited (i.e. visit the next new position or leave the current tape segment).

We can use memoize search in this process for acceleration, and regard the process of leaving a tape segment as a rule. Then the rule sequence (or rule dependency graph) may be generalized to new induction rules.
[[Category:Deciders]]

Consistent Collatz

2025-10-07T23:21:13Z

MrSolis: 0_o

A '''consistent Collatz''' sequence is a [[Collatz-like]] sequence of integers which can be defined by a recurrence relation of the following form:

<math>mx_{n+1} = rx_n + J[x_n\ {\operatorname{mod}}\ m]</math>

where the sequence itself is <math>x_0, x_1, \ldots</math>, <math>m</math> and <math>r</math> are positive integers, and <math>J</math> is a map from integers modulo <math>m</math> to (possibly negative) integers (with the values chosen to ensure that all <math>x_n</math> are integers). The sequence is entirely defined by <math>m</math>, <math>r</math>, <math>J</math>, and the value of its first element <math>x_0</math>. The recurrence relation is a special case of a Collatz function (e.g. as seen in [[wikipedia:Collatz conjecture#Undecidable generalizations]]) in which all the multipliers are the same (i.e. the same value of <math>r</math> is used regardless of the value of <math>x_n\ {\operatorname{mod}}\ m</math>).

Many small [[cryptids]] work by calculating the elements of a consistent Collatz sequence modulo <math>m</math>, and deciding whether or not to halt based on the remainders. For example, [[Hydra]] calculates the consistent Collatz sequence with <math>m=2</math>, <math>r=3</math>, <math>J=\{0 \mapsto 0, 1 \mapsto -1\}</math>, and <math>x_0=3</math>, halting only if the sequence has contained more than twice as many even elements as odd elements. <math>m=2, r=3</math> seems to be particularly common among small cryptids, due to creating the simplest consistent Collatz sequences that have nontrivial behaviour; however, other values have been observed, such as [[Bigfoot]]'s <math>m=81, r=256</math>.

== Efficiently calculating consistent Collatz sequences ==

For any given Collatz sequence, it is possible to calculate its sequence of remainders <math>x_n\ {\operatorname{mod}}\ m</math> in amortized [[wikipedia:quasilinear time|quasilinear time]]. This can be accomplished via the use of two helper sequences:

<math>w_n = x_n\ {\operatorname{mod}}\ m^{f(n)}</math>, except <math>w_0 = x_0</math><br>
<math>j_n = m^{f(n)}x_n - r^{f(n)}x_{n-f(n)}</math>, with <math>j_0</math> undefined (the algorithm never uses it)

where <math>f(n)</math> is the largest power of 2 that divides into <math>n</math>.

=== Time complexity ===

The algorithm works by calculating <math>j_n</math> then <math>w_n</math> for each <math>n</math> in turn, with the only operations used being additions, subtractions, and multiplications of numbers whose number of digits is proportional to <math>f(n)</math>; division and modulo by powers of <math>m</math>; and calculation of <math>r^t</math> with <math>t \leq f(n)</math>. Because the values of <math>r^t</math> can be memoized, and it is possible to trivialise the division and modulus operations by storing the numbers in base <math>m</math>, this means that the only slow operations are additions and subtractions taking <math>O(f(n))</math> time, and multiplications taking <math>O(f(n) \log f(n) \log \log f(n))</math> time (and there are <math>O(\log f(n))</math> such operations performed), so the calculation of each <math>w_n, j_n</math> pair takes time quasilinear in <math>f(n)</math>. <math>\Sigma_{t=1}^n{f(t)}=O(n \log n)</math>: as such, the calculation of the entire sequences <math>w_0, \ldots, w_n</math> and <math>j_0, \ldots, j_n</math> takes time quasilinear in <math>n \log n</math>, thus quasilinear in <math>n</math>.

=== Details of the algorithm ===

The algorithm itself is:

<math>j_n = m^{f(n)-1} J[w_{n-1}\ {\operatorname{mod}}\ m] + \Sigma_{e=1}^{\log_2 f(n)}\left(m^{f(n)-2^e}r^{2^{e-1}}j_{n-2^{e-1}}\right)</math><br>
<math>w'_n = j_n + r^{f(n)} w_{n-f(n)} \mod m^{2f(n)}</math> (i.e. all the calculations are done modulo <math>m^{2f(n)}</math>, saving time in cases where <math>w_{n-f(n)}</math> happens to be much larger than <math>m^{2f(n)}</math>)<br>
<math>w_n = w'_n \div m^{f(n)}</math> (which should always be an integer).

(If <math>n</math> is odd, then <math>f(n) = 1</math>, <math>\log_2 f(n) = 0</math>, and the sum in the calculation of <math>j_n</math> is a degenerate sum with no elements.)

=== Sketch proof of correctness ===

The proof that the algorithm is correct starts with the definition <math>j_n = m^{f(n)}x_n - r^{f(n)}x_{n-f(n)}</math>, adds a degenerate sum (that sums to zero) to produce the following expression:

<math>j_n = m^{f(n)}x_n + \Sigma_{e=1}^{\log_2 f(n)}\left(-m^{f(n)-2^{e-1}}r^{2^{e-1}}x_{n-2^{e-1}}+m^{f(n)-2^{e-1}}r^{2^{e-1}}x_{n-2^{e-1}}\right) - r^{f(n)}x_{n-f(n)}</math> (with each element of the sum being of the form <math>-q+q</math> and thus 0)

and then rebrackets by grouping the term before the sum with the first half of the first element of the sum, the second half of the first element of the sum with the first half of the second element of the sum, etc., and finally the second half of the last element of the sum with the term after the sum. From there, the proof is mostly just a matter of expanding definitions.

=== Possible tricks to optimize the implementation ===

Once the algorithm produces a value of <math>j_n</math> or <math>w_n</math>, it happens that it will never again read a value <math>j_{n'}</math> or <math>w_{n'}</math> where <math>f(n)=f(n')</math>. As such, it is possible to save memory by storing only one value of <math>j_n</math> and one value of <math>w_n</math> for each <math>f(n)</math>.

It is probably faster to switch to an alternative implementation (e.g. simple repeated multiplication) when the <math>f(n)</math> values are small, because at that point the numbers are small enough to fit into a machine register; this does not improve the asymptotic behaviour of the implementation but is likely to speed it up by a reasonably high constant factor.

Every <math>w'_n</math> is necessarily a multiple of <math>m^{f(n)}</math>. It seems like that might provide some sort of shortcut to calculate it faster, although the details are currently unclear.

=== Proof-of-concept implementation ===

Here's a proof-of-concept implementation, using Python 3 and gmpy2 (configured to calculate [[Hydra]], but it could easily be adapted for other consistent Collatz sequences with <math>m=2</math>):

<syntaxhighlight lang="python3">
import gmpy2
import time

# The Rules of Hydra:
# if x_n = 2y + 0, then x_{n+1} = 3y + 0, i.e. 2x_{n+1} = 3x_n + 0
# if x_n = 2y + 1, then x_{n+1} = 3y + 1, i.e. 2x_{n+1} = 3x_n - 1
m = 2 # modulus; denominator of the ratio between successive elements
r = 3 # numerator of the ratio between successive elements
J = [0, -1] # J[x_n % m] is the difference between m*x_{n+1} and r*x_n
x_0 = 3 # first term of the sequence

def f(n):
"""The largest power of 2 that divides into the argument"""
return n & ~(n - 1)

global mod_m_exp
if m == 2:
mod_m_exp = lambda v,e: gmpy2.f_mod_2exp(v, e)
else:
mod_m_exp = lambda v,e: gmpy2.f_mod(v, gmpy2.pow(m, e))

global div_m_exp
if m == 2:
div_m_exp = lambda v,e: gmpy2.f_div_2exp(v, e)
else:
div_m_exp = lambda v,e: gmpy2.f_div(v, gmpy2.pow(m, e))

global mul_m_exp
if m == 2:
mul_m_exp = lambda v,e: gmpy2.mpz(v) << e
else:
mul_m_exp = lambda v,e: gmpy2.mul(v, gmpy2.pow(m, e))

r_exp_cache = {1: gmpy2.mpz(r)}
def r_exp(e):
"""Returns r raised to the power of e. e must be a power of 2."""
global r_exp_cache
if not e in r_exp_cache:
r_exp_cache[e] = gmpy2.square(r_exp(e/2))
return r_exp_cache[e]

# The bulk of the calculation is to calculate w_n and j_n for each n.
# The definitions are:
# w_n = x_n mod m**f(n)
# j_n = m**f(n) * x_n - r**f(n) * x_{n-f(n)}
# The output from the program is the sequence of x_n mod m.
# This can be calculated by taking the values of w_n mod m.
w = {0: x_0} # most recently seen w for each f value
j = {} # most recently seen j for each f value

modulus_count = {0: 0, 1: 0}

n = 0
perf_counter_timestamp = time.perf_counter_ns()
while True:
last_f = f(n)
last_x_mod_m = mod_m_exp(w[last_f], 1)
# print(last_x_mod_m, end="")

modulus_count[last_x_mod_m] += 1
if n % 1000000 == 0:
last_timestamp = perf_counter_timestamp
perf_counter_timestamp = time.perf_counter_ns()
print("Reached n = ", n, "; modulus counts: ", modulus_count,
"; time for last 1000000 elements = ",
(perf_counter_timestamp - last_timestamp) // 1000000,
" ms", sep="")

n = n + 1
cur_f = f(n)

# j can be a sum of multiple terms; J[last_x_mod_m] is always present
# but if f > 1 there are other terms too
m_shift = cur_f - 1
r_shift = 1
new_j = mul_m_exp(J[last_x_mod_m], m_shift)
while m_shift >= r_shift:
m_shift -= r_shift
new_j += mul_m_exp(j[r_shift] * r_exp(r_shift), m_shift)
r_shift *= 2
j[cur_f] = new_j

# w can be calculated directly from the new j and the appropriate past w
wrap = lambda v: mod_m_exp(v, cur_f * 2)
past_w = w[f(n - f(n))]
new_w = wrap(wrap(new_j) + wrap(wrap(r_exp(cur_f)) * wrap(past_w)))
assert(mod_m_exp(new_w, cur_f) == 0)
new_w = div_m_exp(new_w, cur_f)
w[cur_f] = new_w
</syntaxhighlight>

This implementation is probably not suitable for serious use due to having poor constant factors: a faster implementation would use an alternative algorithm for low <math>f(n)</math> values. It is also intened only for <math>m=2</math>, because the complexity result is dependent on modulus by powers of <math>m</math> being fast regardless of the size of the dividend, but gmpy2 is only able to store numbers in binary and that operation is quick only if the modulus is a power of the base. As such, a full implementation of efficient consistent Collatz calculation would probably involve writing a new arbitrarily-large-integers library which is able to store numbers in arbitrary bases.

Hydra function

2025-10-07T23:17:32Z

MrSolis: not done…

[[category:Functions]]
[[File:Hydra Spiral.png|thumb|185px|A spiral-like figure that gives the first few terms of the Hydra sequences with initial values 2, 5, 8, 11, 14, and 17.]]
The '''Hydra function''' is a [[Collatz-like]] function defined as:
<math display="block">\textstyle H(n)\equiv n+\big\lfloor\frac{1}{2}n\big\rfloor=\Big\lfloor\frac{3}{2}n\Big\rfloor=\begin{cases}
\frac{3n}{2}&\text{if }n\equiv0\pmod{2},\\
\frac{3n-1}{2}&\text{if }n\equiv1\pmod{2}.\\
\end{cases}</math>
It is named as such because of its connection to the unsolved halting problems for the [[Cryptids]] [[Hydra]] and [[Antihydra]]. Due to its simplicity, simulations for both of these [[Turing machines]] utilize this function instead of what can initially be proven.
== Relationship to Hydra and Antihydra problems==
Using the Hydra function, we can obtain simplified rules for Hydra and Antihydra:
{|class="wikitable"
! Hydra !! Antihydra
|-align="center"
|Let <math>C_H(a,b):=0^\infty\;\textrm{<}\textrm{A}\;2\;0^{3(a-2)}\;3^b\;2\;0^\infty</math>:<math display="block">\begin{array}{|lll|}\hline
0^\infty\;\textrm{A}\textrm{>}\;0^\infty&\xrightarrow{20}&C_H(3,0),\\
C_H(2a,0)&\xrightarrow{54a^2-48a-2}&0^\infty\;3^{9a-8}\;1\;\textrm{A}\textrm{>}\;2\;0^\infty,\\
C_H(2a,b+1)&\xrightarrow{54a^2-39a-5}&C_H(3a,b),\\
C_H(2a+1,b)&\xrightarrow{4b+54a^2-3a+4}&C_H(3a+1,b+2).\\\hline
\end{array}</math>
|Let <math>A_H(a,b):=0^\infty\;1^a\;0\;1^{b-4}\;\textrm{E}\textrm{>}\;0^\infty</math>:<math display="block">\begin{array}{|lll|}\hline
0^\infty\;\textrm{A}\textrm{>}\;0^\infty&\xrightarrow{11}&A_H(0,8),\\
A_H(a,2b)& \xrightarrow{2a+3b^2-1}& A_H(a+2,3b),\\
A_H(0,2b+1)&\xrightarrow{3b^2-3b-7}& 0^\infty\;\textrm{<}\textrm{F}\;110\;1^{3b-6}\;0^\infty,\\
A_H(a+1,2b+1)&\xrightarrow{3b^2-7}& A_H(a,3b+1).\\\hline
\end{array}</math>
|}
<div class="toccolours mw-collapsible mw-collapsed">'''Proof'''<div class="mw-collapsible-content">
Recall the high-level rules for Hydra and Antihydra:
{|class="wikitable"
! Hydra !! Antihydra
|-align="center"
|Let <math>C(a,b):=0^\infty\;\textrm{<}\textrm{A}\;2\;0^a\;3^b\;2\;0^\infty</math>:<math display="block">\begin{array}{|lll|}\hline
0^\infty\;\textrm{A}\textrm{>}\;0^\infty&\xrightarrow{20}&C(3,0),\\
C(2a,0)&\xrightarrow{6a^2+20a+4}&0^\infty\;3^{3a+1}\;1\;\textrm{A}\textrm{>}\;2\;0^\infty,\\
C(2a,b+1)&\xrightarrow{6a^2+23a+10}&C(3a+3,b),\\
C(2a+1,b)&\xrightarrow{4b+6a^2+23a+26}&C(3a+3,b+2).\\\hline
\end{array}</math>
|Let <math>A(a,b):=0^\infty\;1^a\;0\;1^b\;\textrm{E}\textrm{>}\;0^\infty</math>:<math display="block">\begin{array}{|lll|}\hline
0^\infty\;\textrm{A}\textrm{>}\;0^\infty&\xrightarrow{11}&A(0,4),\\
A(a,2b)& \xrightarrow{2a+3b^2+12b+11}& A(a+2,3b+2),\\
A(0,2b+1)&\xrightarrow{3b^2+9b-1}& 0^\infty\;\textrm{<}\textrm{F}\;110\;1^{3b}\;0^\infty,\\
A(a+1,2b+1)&\xrightarrow{3b^2+12b+5}& A(a,3b+3).\\\hline
\end{array}</math>
|}
Already, both machines appear to be very similar. They have one parameter that increases exponentially with growth factor <math display="inline">\frac{3}{2}</math> and another that takes a pseudo-random walk. Below, the exponentially increasing variables are described by integer sequences:
{|class="wikitable"
! Hydra !! Antihydra
|-align="center"
|<math display="block">a_0=3,a_{n+1}=\begin{cases}\frac{3a_n+6}{2}&\text{if }a_n\equiv0\pmod{2}\\\frac{3a_n+3}{2}&\text{if }a_n\equiv1\pmod{2}\end{cases}</math>
|<math display="block">a_0=4,a_{n+1}=\begin{cases}\frac{3a_n+4}{2}&\text{if }a_n\equiv0\pmod{2}\\\frac{3a_n+3}{2}&\text{if }a_n\equiv1\pmod{2}\end{cases}</math>
|}
This will make demonstrating the transformation easier. Now we will define a new integer sequence based on the old one and discover the recursive rules for that sequence. This new sequence is <math display="inline">b_n=\frac{1}{3}a_n+2</math> and <math>b_n=a_n+4</math> for Hydra and Antihydra respectively. We start by using <math>b_{n+1}</math> instead and substituting <math>a_{n+1}</math> for its recursive formula. By doing so, we get:
{|class="wikitable"
! Hydra !! Antihydra
|-align="center"
|<math display="block">b_0=3,b_{n+1}=\begin{cases}\frac{a_n+6}{2}&\text{if }a_n\equiv0\pmod{2}\\\frac{a_n+5}{2}&\text{if }a_n\equiv1\pmod{2}\end{cases}</math>
|<math display="block">b_0=8,b_{n+1}=\begin{cases}\frac{3a_n+12}{2}&\text{if }a_n\equiv0\pmod{2}\\\frac{3a_n+11}{2}&\text{if }a_n\equiv1\pmod{2}\end{cases}</math>
|}
After that, we can substitute <math>a_n</math> for its solution in terms of <math>b_n</math>. What results is the following:
{|class="wikitable"
! Hydra !! Antihydra
|-align="center"
|<math display="block">b_0=3,b_{n+1}=\begin{cases}\frac{3(b_n-2)+6}{2}&\text{if }3(b_n-2)\equiv0\pmod{2}\\\frac{3(b_n-2)+5}{2}&\text{if }3(b_n-2)\equiv1\pmod{2}\end{cases}</math>
|<math display="block">b_0=8,b_{n+1}=\begin{cases}\frac{3(b_n-4)+12}{2}&\text{if }b_n-4\equiv0\pmod{2}\\\frac{3(b_n-4)+11}{2}&\text{if }b_n-4\equiv1\pmod{2}\end{cases}</math>
|}
The <math>\text{if}</math> statements amount to checking if <math>b_n</math> is even or odd. After simplifying, we are done:
{|class="wikitable"
! Hydra !! Antihydra
|-align="center"
|<math display="block">b_0=3,b_{n+1}=\begin{cases}\frac{3b_n}{2}&\text{if }b_n\equiv0\pmod{2}\\\frac{3b_n-1}{2}&\text{if }b_n\equiv1\pmod{2}\end{cases}</math>
|<math display="block">b_0=8,b_{n+1}=\begin{cases}\frac{3b_n}{2}&\text{if }b_n\equiv0\pmod{2}\\\frac{3b_n-1}{2}&\text{if }b_n\equiv1\pmod{2}\end{cases}</math>
|}
Now that we have demonstrated a strong similarity in the behaviour of both Turing machines, we can return to using the high-level rules. Doing that while considering the step counts yields the final result.
</div></div>
Under these rules, the halting problem for Hydra is about whether repeatedly applying the function <math>H(n)</math>, starting with <math>n=3</math>, will eventually generate more even terms than twice the number of odd terms. Similarly, Antihydra halts if and only if repeatedly applying <math>H(n)</math>, starting with <math>n=8</math>, will eventually generate more odd terms than twice the number of even terms.

=== Coding the Hydra and Antihydra problems using the Hydra function ===
Paired with the corresponding even/odd criterion as loop halting condition (implemented as a counter variable) and initial Hydra function value, the Hydra function definition can be used to write computer programs that simulate the abstracted behavior of the Hydra and Antihydra Turing machines. The following Python program is a Hydra simulator:
<syntaxhighlight lang="python" line="1">
# 'a' and 'b' fulfill the same purpose as in the Hydra rules:
# The current hydra function value
a = 3
# The even/odd condition counter
b = 0
# As long as Hydra has not halted, 'b' remains greater than -1.
while b != -1:
# If 'a' is even, decrement 'b', otherwise increase 'b' by 2.
if a % 2 == 0:
b -= 1
else:
b += 2
# This performs one step of the Hydra function H(a) = a + floor(a/2).
# Note that integer division by 2 is equivalent to one bit shift to the right (a >> 1)
a += a//2
</syntaxhighlight>
Replacing <code>a = 3</code> with <code>a = 8</code> and swapping <code>b -= 1</code> with <code>b += 2</code> turns this program into an Antihydra simulator.

Determining whether these programs halt or not (and if so, after how many loop iterations) would resolve these open problems.
==Properties==
The Hydra function can be rewritten as follows:
<math display="block">\begin{array}{l}
H(2n)&=&3n,\\
H(2n+1)&=&3n+1.\\
\end{array}</math>
Now assume that for some positive integer <math>s</math> and every odd integer <math>t</math>, <math>H^s(2^st)=3^st</math> and <math>H^s(2^st+1)=3^st+1</math>, where <math>H^i(n)</math> is function iteration. Notice that we can write <math>2^{s+1}t=2\cdot2^st</math> and <math>2^{s+1}t+1=2\cdot2^st+1</math>, so if we apply <math>H</math> to these numbers, we get <math>H(2\cdot2^st)=3\cdot 2^st</math> and <math>H(2\cdot2^st+1)=3\cdot2^st+1</math>. Now, if we apply <math>H</math> to these numbers <math>s</math> times, we get <math>H^{s+1}\big(2^{s+1}t\big)=H^s(2^s\cdot3t)=3^{s+1}t</math> and <math>H^{s+1}\big(2^{s+1}t+1\big)=H^s(2^s\cdot3t+1)=3^{s+1}t+1</math>. Therefore, by mathematical induction we have proved the following formulas:
<math display="block">\begin{array}{l}
H^s(2^st)&=&3^st,\\
H^s(2^st+1)&=&3^st+1.\\
\end{array}</math>
This optimization can be directly applied to the high-level rules for Hydra and Antihydra, producing this result:
{|class="wikitable"
! Hydra !! Antihydra
|-align="center"
|Let <math>C_H(a,b):=0^\infty\;\textrm{<}\textrm{A}\;2\;0^{3(a-2)}\;3^b\;2\;0^\infty</math>:
<math display="block">\begin{array}{|lll|}\hline
C_H(2^st,b+s)&\xrightarrow{f_1(s,t)}&C_H(3^st,b),\\
C_H(2^st+1,b)&\xrightarrow{f_2(s,t,b)}&C_H(3^st+1,b+2s),\\\hline
\end{array}</math>
where <math display="inline">f_1(s,t)=\frac{3t(3^s-2^s)(18(3^s+2^s)t-65)}{5}-5s</math> and <math display="inline">f_2(s,t,b)=(b+s)4s+\frac{3t(3^s-2^s)(18(3^s+2^s)t-5)}{5}</math>.
|Let <math>A_H(a,b):=0^\infty\;1^a\;0\;1^{b-4}\;\textrm{E}\textrm{>}\;0^\infty</math>:<math display="block">\begin{array}{|lll|}\hline
A_H(a,2^st)& \xrightarrow{f_3(s,t,a)}& A_H(a+2s,3^st),\\
A_H(a+s,2^st+1)&\xrightarrow{f_4(s,t)}& A_H(a,3^st+1),\\\hline
\end{array}</math>
where <math display="inline">f_3(s,t,a)=(2a-3+2s)s+\frac{3t^2(9^s-4^s)}{5}</math> and <math display="inline">f_4(s,t)=\frac{3t^2(9^s-4^s)}{5}-7s</math>.
|}
== Visualizations ==
The four images below depict the first 1000 values of four Hydra sequences with different initial values. Each row of pixels shows a number in binary on the right and its parity on the left (blue for even, red for odd):
<gallery mode="packed" heights="250">
File:HydraFunction-StartingValue2.png|Starting value 2. There are 492 even numbers and 508 odd numbers.
File:HydraFunction-StartingValue5.png|Starting value 5. There are 497 even numbers and 503 odd numbers.
File:Antihydra increasing value.png|Starting value 8. There are 499 even numbers and 501 odd numbers.
File:HydraFunction-StartingValue11.png|Starting value 11. There are 481 even numbers and 519 odd numbers.
</gallery>

Piecewise Affine Function

2025-10-07T23:12:26Z

MrSolis: section swap

<blockquote>Note: This article is currently in flux as we investigate previous literature on the topic shared by @savask: https://discord.com/channels/960643023006490684/1239205785913790465/1422997913558323392</blockquote>'''Linear-Inequality Affine Transformation Automata (LIATA)''' are a model for computation based upon applying affine transformations to vectors based on cases defined by linear inequalities. They are a generalization of the rules for [[BMO1]] and were proven to be Turing complete.

== Formal Definition ==
A ''n''-dimension, ''k''-case LIATA is a piecewise defined partial function <math>f: \Z^n \to \Z^n</math>:<math display="block">f(\vec{x}) = \begin{cases}
f_0(\vec{x}) & \text{if } C_0(\vec{x}) \\
f_1(\vec{x}) & \text{if } C_1(\vec{x}) \\
& \vdots \\
f_{k-1}(\vec{x}) & \text{if } C_{k-1}(\vec{x}) \\
\end{cases}</math>Where each <math>f_i: \Z^n \to \Z^n</math> is an affine function and each <math>C_i: \Z^n \to \{T,F\}</math> is a "linear inequality condition" (defined below) such that for all <math>\vec{x}</math> at most one condition <math>C_i(\vec{x})</math> applies. If none of the conditions apply to <math>\vec{x}</math>, we say that it halts on that configuration.

Let a '''linear inequality term''' be any equation of the form <math>g(\vec{x}) \sim c</math> where <math>g: \Z^n \to \Z</math> is a linear function and ~ is replaced by any (in)equality relation (=,<,≤,>,≥). Then let a '''linear inequality condition''' be any combination of linear inequality terms using logical AND, OR and NOT operations.

So, for example, the following are all linear inequality conditions:

* <math>a<b</math> represented formally as <math>a-b < 0</math>
* <math>3a \le b < 4a</math> represented formally as <math>(b-3a \ge 0) \and (4a-b > 0)</math>
* <math>a = 2</math> (note that we allow equalities as well)

Given a LIATA ''f'', we say that it halts in ''k'' steps starting from configuration <math>\vec{x}</math> iff <math>f^k(\vec{x})</math> is undefined.

== Example ==
An example of a LIATA are the rules for BMO1:<math display="block">f(a,b) = \begin{cases}
(a-b, 4b+2) & \text{if } a > b \\
(2a+1, b-a) & \text{if } a < b
\end{cases}</math>where <math>f(n,n)</math> is undefined. BMO1 halts iff there exists k such that <math>f^k(1,2)</math> is undefined (in other words <math>f^{k-1}(1,2) = (n,n)</math> for some n).

This is a 2-dimension, 2-case LIATA. The 2 dimensions are the parameters ''a,b'' and the two cases are the <math>a<b</math> and <math>a>b</math> rows. For each case the parameters are transformed via an affine transformation.

== Turing Complete ==
LIATA are Turing complete. This has been proven by implementing Minsky machines as LIATA:
* @Bard's proved that 3-dim LIATA are Turing complete: [https://discord.com/channels/960643023006490684/1239205785913790465/1420457986564030641 Discord link]
* @star's proved that 2-dim LIATA are Turing complete: [https://discord.com/channels/960643023006490684/1239205785913790465/1421271424588451915 Discord link]
* In progress: Shawn Ligocki is working on a proof that 2-case LIATA are Turing complete: [https://discord.com/channels/960643023006490684/1239205785913790465/1422772752980639866 Discord link]

1RB0RA 1LC1LF 1RD0LB 1RA1LE 1RZ0LC 1RG1LD 0RG0RF

2025-10-07T23:11:06Z

MrSolis: ('◡')

{{machine|1RB0RA_1LC1LF_1RD0LB_1RA1LE_1RZ0LC_1RG1LD_0RG0RF}}
{{TM|1RB0RA_1LC1LF_1RD0LB_1RA1LE_1RZ0LC_1RG1LD_0RG0RF|halt}} is the current [[BB(7)]] [[champion]], running for over <math>2 \uparrow^{11} 2 \uparrow^{11} 3</math> steps before it halts. It was discovered by Pavel Kropitz on 10 May 2025 ([https://discord.com/channels/960643023006490684/1369339127652159509/1370678203395604562 Discord link]) and analyzed by Shawn Ligocki (here) on 13 May 2025.

== Analysis by Shawn Ligocki ==
Consider general configurations matching the regex:

<math display="block">0^\infty \; 11 \; (1 \; (01)^*)^* \; 0011100 \; \textrm{A}\textrm{>} \; 0^\infty</math>

=== Low level rules ===
<pre>
01 1 01^n 0011100 A> 00 --> 1 01^n+2 0011100 A>
01^3 11 01^n 0011100 A> 0^6 --> 1 01^n+5 1 01 0011100 A>
01^3 (1 01)^k+1 11 01^n 0011100 A> 0^6 --> 1 01^n+6 (1 01)^k 11 01 0011100 A>
011 (1 01)^k 11 01^n 0011100 A> 0^2 --> 1 Z> 111 01^n+1 00 101^k+2
</pre>

=== Mid level rules ===
Let

<math display="block">
B(a; b, c, ..., z) = 0^\infty \; 111 \; (01)^{3z+1} \; 1 \; \cdots \; 1 (01)^{3c+1} \; 1 \; (01)^{3b+1} \; 1 \; (01)^0 \; 1 \; (01)^{3a+1} \; 0011100 \; \textrm{A}\textrm{>} \; 0^\infty
</math>

and let <code>B(a; [x]*k, y, ...)</code> = <math>B(a; \underbrace{x, \cdots, x}_k, y, ...)</math> (In other words, <code>[x]*k</code> represents k repeats of the value x in a config).

then

<pre>
B(a; b+1, ...) -> B(2a+4; b, ...)
B(a; [0]*k, 0, n+1, ...) -> B(0; [0]*k, a+2, n, ...)
B(a; [0]*k) -> Halt(3a + 2k + 9)

Start at step 8178: B(2, [1]*12)
</pre>

=== High level rule ===
Let

<math display="block">\begin{array}{l}
g_0(x) & = & 2x + 4 \\
g_{k+1}(x) & = & g_k^{x+2}(0) \\
\end{array}</math>

then

<math display="block">
B(a; \underbrace{0, \cdots, 0}_k, n, ...) \to B(g_k^n(a); \underbrace{0, \cdots, 0}_k, 0, ...)
</math>

=== Bound ===
Let

<math display="block">\begin{array}{l}
a_0 & = & 2 \\
a_{k+1} & = & g_k(a_k) \\
\end{array}
</math>

then

<math display="block">
B(a_0; \underbrace{1, \cdots, 1}_k)
\to B(a_k, \underbrace{0, \cdots, 0}_k)
\to \text{Halt}(3 a_k + 2 k + 9)
</math>and

<math display="block">
\text{Start} \to B(a_0; \underbrace{1, \cdots, 1}_{12})
</math>

and so this TM halts with a sigma score of <math> \sigma = 3 a_{12} + 33 </math>

Note that <math>g_k(x) = (2 \uparrow^k (x+4)) - 4</math> and so for <math>k \ge 2</math>,

<math display="block">a_{k+1}+4>2\uparrow^k 2 \uparrow^k 3</math>

and so this TM halts with sigma score <math>\sigma > 2 \uparrow^{11} 2 \uparrow^{11} 3</math>.

This bound is pretty tight: <math>\sigma < 2 \uparrow^{11} 2 \uparrow^{11} 4 = 2 \uparrow^{12} 4</math>.
[[Category:BB(7)]]

Shift rule

2025-10-07T23:07:34Z

MrSolis: ╎|

A '''shift rule''' (also called a '''chain rule''') is a finite sequence of transitions which may be repeated an arbitrary number of times to "jump" over an entire repeated block of symbols on a compressed tape.

A simple canonical example is that if we have a [[Turing machine]] with the transition <math>(\textrm{S}, 1) \to (0, R, \textrm{S})</math> then using [[directed head notation]]:
<math display="block">
\vphantom{\int}\textrm{S}\textrm{>}\;1^n \xrightarrow{n} 0^n\;\textrm{S}\textrm{>}
</math>
In other words, if the machine is in state <math>\textrm{S}</math> and the head is reading the leftmost of a sequence of <math>n</math> ones, then <math>n</math> steps later it will have moved to the right of this entire sequence of ones, converting them all to zeros.

To give a precise definition, suppose that there are words <math>t</math>, <math>r</math> and <math>r'</math> in the alphabet of the Turing machine in question,
and assume that for some state <math>\textrm{S}</math> the machine transitions from <math>t \; \textrm{S}\textrm{>} \; r</math> to <math>r' t \; \textrm{S}\textrm{>}</math>. Then we have a ''right'' shift rule
<math display="block">
\displaystyle\vphantom{\int} t \; \textrm{S}\textrm{>} \; r \to r'\;t\;\textrm{S}\textrm{>}.
</math>
Similarly, if the machine transitions from <math> r \; \textrm{<}\textrm{S} \; t</math> to <math>\textrm{<}\textrm{S} \; t r'</math>, then we have a ''left'' shift rule
<math display="block">
\vphantom{\int}r\;\textrm{<}\textrm{S}\;t\to\textrm{<}\textrm{S}\;t\;r'.
</math>

== General Shift Rules ==
Shift rules can jump over larger blocks. For example [[Skelet 1|Skelet #1]] ({{TM|1RB1RD_1LC0RC_1RA1LD_0RE0LB_---1RC}}) exhibits the following transitions:
<math display="block">
\begin{array}{rcl}
\displaystyle\vphantom{\int} 011 \; \textrm{<}\textrm{C} & \xrightarrow{3} & \textrm{<}\textrm{C} \; 101 \\
\textrm{A}\textrm{>} \; 110 110 & \xrightarrow{10} & 011 011 \;\textrm{A}\textrm{>}
\end{array}
</math>
Each of these can be repeated an arbitrary number of times, producing the general shift rules:
<math display="block">
\begin{array}{rcl}
\displaystyle\vphantom{\int}011^n \; \textrm{<}\textrm{C} & \xrightarrow{3n} & \textrm{<}\textrm{C} \; 101^n \\
\textrm{A}\textrm{>} \; {110 110}^n & \xrightarrow{10n} & {011 011}^n \;\textrm{A}\textrm{>} \\
\end{array}
</math>
Shift rules can also depend upon additional "local context". For example, Skelet #1 also exhibits this transition:
<math display="block">
\vphantom{\int} 01 \; \textrm{<}\textrm{C} \; 1 \xrightarrow{6} \textrm{<}\textrm{C} \; 1 \; 01
</math>
and since the resulting config has the same "context" (a 1 to the right of the head), this can be repeated as well to produce the shift rule:
<math display="block">
\vphantom{\int} 01^n \; \textrm{<}\textrm{C} \; 1 \xrightarrow{6n} \textrm{<}\textrm{C} \; 1 \; 01^n.
</math>

== Inductive Rules ==
Shift rules can be seen as the simplest example of [[Inductive Proof System|inductive rules]]. Specifically, they are Level 0 Inductive rules which only use the inductive hypothesis once: Tape rewrite rules that can be proven using induction, where each step in the proof is either a basic Turing machine transition or an inductive application of the rule being proven that does not use any other previously proven rules).

== Simulation Acceleration ==
One of the main uses of shift rules is to [[Accelerated Simulator|accelerate the simulation]] of Turing machines. For example, consider the simple [[bouncer]] {{TM|1RB1LA_1LA1RB}} using the shift rules:
<math display="block">\begin{array}{rcl}
\displaystyle\vphantom{\int}1^n \; \textrm{<}\textrm{A} & \xrightarrow{n} & \textrm{<}\textrm{A} \; 1^n \\
\textrm{B}\textrm{>} \; 1^n & \xrightarrow{n} & 1^n \; \textrm{B}\textrm{>} \\
\end{array}</math>

We can accelerate the simulation like this:

<math display="block">\begin{array}{ll}
\text{Start}{:}&0^\infty \; \textrm{<}\textrm{A} \; 0^\infty \\
\text{Step 1}{:}&0^\infty \; 1 \; \textrm{B}\textrm{>} \; 0^\infty \\
\text{Step 2}{:}&0^\infty \; 1 \; \textrm{<}\textrm{A} \; 1 \; 0^\infty \\
\text{Step 3}{:}&0^\infty \; \textrm{<}\textrm{A} \; 1^2 \; 0^\infty \\
\qquad\qquad\qquad\vdots \\
\text{Step }2n^2+n{:}&0^\infty \; \textrm{<}\textrm{A} \; 1^{2n} \; 0^\infty \\
\text{Step }2n^2+n+1{:}&0^\infty \; 1 \; \textrm{B}\textrm{>} \; 1^{2n} \; 0^\infty \\
\text{Step }2n^2+3n+1{:}&0^\infty \; 1^{2n+1} \; \textrm{B}\textrm{>} \; 0^\infty \\
\text{Step }2n^2+3n+2{:}&0^\infty \; 1^{2n+1} \; \textrm{<}\textrm{A} \; 1 \; 0^\infty \\
\text{Step }2n^2+5n+3{:}&0^\infty \; \textrm{<}\textrm{A} \; 1^{2n+2} \; 0^\infty \\
\qquad\qquad\qquad\vdots \\
\end{array}</math>
In this case, they allow one to use <math>n</math> simulator steps to simulate <math>O(n^2)</math> base steps, which is the best-case speedup using only shift rules. More general [[Inductive Proof System|inductive rules]] that can further accelerate a Turing machine's simulation may build on top of shift rules.

== Moving across an infinite line of 0s ==
Any Turing machine that has at least one of the two following types of shift rules:
<math display="block">
\displaystyle\vphantom{\int}t\;\textrm{S}\textrm{>} \; 0^n \to r'\;t\;\textrm{S}\textrm{>}\qquad\text{or}\qquad \displaystyle\vphantom{\int}0^n\;\textrm{<}\textrm{S}\;t\to \textrm{<}\textrm{S}\;t\;r',
</math>
and which eventually reaches the configuration <math>t\;\textrm{S}\textrm{>}\;0^\infty</math> (for the first rule) or <math>0^\infty\;\textrm{<}\textrm{S}\;t</math> (for the second rule) is non-halting, becoming a [[translated cycler]].

[[Category:Analysis Techniques]]

Collatz-like

2025-10-07T23:00:36Z

MrSolis: :D

A '''Collatz-like function''' is a partial function defined piecewise depending on the remainder of an input modulo some number. The canonical example is the original Collatz function:<math display="block">\begin{array}{l}
c(2k) & = & k \\
c(2k+1) & = & 3k+2 \\
\end{array}</math>

A '''Collatz-like problem''' is a question about the behavior of iterating a Collatz-like function. Collatz-like problems are famously difficult.

Many [[Busy Beaver Champions]] have '''Collatz-like behavior''', meaning that their behavior can be concisely described via the iterated values of a Collatz-like function.

== Examples ==

=== 5-state busy beaver winner ===
Consider the [[5-state busy beaver winner]] and the generalized configuration:

<math display="block">M(n) = 0^\infty \; \textrm{<}\text{A} \; 1^n \; 0^\infty</math>Pascal Michel showed that:

<math display="block">\begin{array}{lcl}
0^\infty \; \textrm{<}\textrm{A} \; 0^\infty & = & M(0) \\
M(3k) & \xrightarrow{5k^2+19k+15} & M(5k+6) \\
M(3k+1) & \xrightarrow{5k^2+25k+27} & M(5k+9) \\
M(3k+2) & \xrightarrow{6k+12} & 0^\infty\;1\;\textrm{Z}\textrm{>}\;01\;{(001)}^{k+1}\;1\;0^\infty \\
\end{array}</math>

Starting on a blank tape <math>M(0)</math>, these rules iterate 15 times before reaching the halt config.<ref>[https://bbchallenge.org/~pascal.michel/beh#tm52a Pascal Michel's Analysis of the BB(5, 2) Champion]</ref>

=== Hydra ===
Consider [[Hydra]] and the generalized configuration:

<math display="block">C(a, b) = 0^\infty\;\textrm{<}\textrm{A}\;2\;0^{3(a-2)} \; 3^b \; 2 \; 0^\infty</math>
Daniel Yuan showed that:<math display="block">\begin{array}{l}
\\
0^\infty \; \textrm{A}\textrm{>} \; 0^\infty & & \xrightarrow{20} & C(3, 0) \\
C(2n, & 0) & \to & \text{Halt}(9n-6) \\
C(2n, & b+1) & \to & C(3n,b) \\
C(2n+1, & b) & \to & C(3n+1,b+2) \\
\end{array}</math>

Where <math>\text{Halt}(n)</math> is a halting configuration with <math>n</math> non-zero symbols on the tape.

Starting from <math>C(3, 0)</math>, this simulates a pseudo-random walk along the <math>b</math> parameter, increasing it by 2 every time <math>a</math> is odd, decreasing by 1 every time it's even. Deciding whether or not Hydra halts requires determining whether through the process of applying the Collatz-like function
<math display="block">\begin{array}{l}
H(2n) & = & 3n &\text{(even transition)} \\
H(2n+1) & = & 3n+1&\text{(odd transition)} \\
\end{array}</math>
to 3 recursively, there eventually comes a point where the amount of even transitions applied is more than twice the amount of odd transitions applied.<ref>Shawn Ligocki. [https://www.sligocki.com/2024/05/10/bb-2-5-is-hard.html BB(2, 5) is Hard (Hydra)]. 10 May 2024.</ref> The first few transitions are displayed below:
<math display="block">\begin{array}{l}
\vphantom{\frac{\frac{0}{.}}{.}}3 \xrightarrow{O} 4 \xrightarrow{E} 6\xrightarrow{E} 9 \xrightarrow{O} 13 \xrightarrow{O} 19 \xrightarrow{O} 28 \xrightarrow{E} 42 \xrightarrow{E} 63\xrightarrow{O} \cdots \\
\end{array}
</math>
=== Exponential Collatz ===
Consider the machine {{TM|1RB0LD_1RC0RF_1LC1LA_0LE1RZ_1LF0RB_0RC0RE|halt}}, discovered by Pavel Kropitz in May 2022, and the general configuration:<math display="block">K(n):=0^\infty\;1\;0^n\;11\;0^5\;\textrm{C}\textrm{>}\;0^\infty</math>Shawn Ligocki showed that:
<math display="block">\begin{array}{l}
\\
0^\infty\;\textrm{A}\textrm{>}\;0^\infty&\xrightarrow{45}&K(5) \\
K(4k) & \to & \operatorname{Halt}\Bigl(\frac{3^{k+3} - 11}{2}\Bigr) \\
K(4k+1) & \to & K\Bigl(\frac{3^{k+3} - 11}{2}\Bigr) \\
K(4k+2) & \to & K\Bigl(\frac{3^{k+3} - 11}{2}\Bigr) \\
K(4k+3) & \to & K\Bigl(\frac{3^{k+3} + 1}{2}\Bigr) \\
\end{array}</math>

Demonstrating Collatz-like behavior with exponential piecewise component functions.

Starting from config <math>K(5)</math>, these rules iterate 15 times before reaching the halt config leaving over <math>10 \uparrow\uparrow 15</math> non-zero symbols on the tape.<ref>Shawn Ligocki. [https://www.sligocki.com/2022/06/21/bb-6-2-t15.html BB(6, 2) > 10↑↑15]. 21 Jun 2022.</ref>
== References ==
<references />
[[Category:Zoology]]

1RB1LD 1RC1RB 1LC1LA 0RC0RD

2025-10-07T22:52:22Z

MrSolis: ??

{{machine|1RB1LD_1RC1RB_1LC1LA_0RC0RD}}
{{TM|1RB1LD_1RC1RB_1LC1LA_0RC0RD}} is the current [[Blanking Busy Beaver]] BLB(4,2) and [[Beeping Busy Beaver]] BBB(4,2) champion, creating a blank tape after 32,779,477 steps and [[Quasihalt|quasihalting]] after 32,779,478 steps at which point it becomes a [[translated cycler]] with period 1. It was discovered and reported by Nick Drozd in 2021.<ref>Nick Drozd. [https://nickdrozd.github.io/2021/07/11/self-cleaning-turing-machine.html A New Record in Self-Cleaning Turing Machines]. 2021.</ref>

== Analysis by [[User:sligocki|Shawn Ligocki]] ==
Let <math display="block">D(a, b):= 0^\infty\;1^a\;0^b\;\textrm{D}\textrm{>}\;0^\infty</math>then:<math display="block">\begin{array}{lc}
D(a+3, & b) & \to & D(a, b+5) \\
D(0, & b) & \to & \text{Blank} \\
D(1, & b) & \to & D(b+2, 4) \\
D(2, & b) & \to & D(b+3, 4) \\
\end{array}</math>let <math>D(a):= D(a, 4)</math>, then we can simplify to:

<math display="block">\begin{array}{lc}
D(3k ) & \to & \text{Blank} \\
D(3k+1) & \to & D(5k+6) \\
D(3k+2) & \to & D(5k+7) \\
\end{array}</math>Starting from <math>D(2)</math> (at step 19) we get the trajectory:

<math display="block">\begin{array}{l}
D(2)
& \to & D(7) & \to & D(16) & \to & D(31) & \to & D(56) & \to & D(97) \\
& \to & D(166) & \to & D(281) & \to & D(472) & \to & D(791) & \to & D(1322) \\
& \to & D(2207) & \to & D(3682) & \to & D(6141) & \to & \text{Blank} \\
\end{array} </math>which has the remarkable luck of applying this [[Collatz-like]] map 14 times before reaching the blanking config (expected # of applications before halting is 3).

See also, previous analysis in 2021: https://www.sligocki.com/2021/07/17/bb-collatz.html

== Relation to other machines ==

The map and trajectory are equivalent to that of the [[BB(5) champion]]. For all <math>k</math>, let <math>f(k)</math> be the number such that <math>D(k)\to D(f(k))</math>, or <math>\text{HALT}</math> if <math>D(k)\to\text{Blank}</math>, and let <math>g</math> be the map simulated by the BB(5) champion. Then:

<math display="block">\begin{array}{lc}
g(2(3k)+2) & = & g(6k+2) & = & \text{HALT} & = & f(3k) \\
g(2(3k+1)+2) & = & g(6k+4) & = & 10k+14 & = & 2f(3k+1)+2 \\
g(2(3k+2)+2) & = & g(6k+6) & = & 10k+16 & = & 2f(3k+2)+2 \\
\end{array}</math>

So the size of this machine's BLB output is tied to the size of the BB(5) champion's output.

== References ==

Translated cycler

2025-10-07T22:48:28Z

MrSolis:

[[File:Translated_cycler_44394115_annotated.svg|right|thumb|Example "Translated cycler": 45-step space-time diagram of bbchallenge's machine {{TM|1RB0RE_0LC1RC_0RD1LA_1LE---_1LB1RC}}. The same bounded pattern is being translated to the right forever. The text annotations illustrate the main idea for recognising "Translated Cyclers": find two configurations that break a record (i.e. visit a memory cell that was never visited before) in the same state (here state D) such that the content of the memory tape at distance L from the record positions is the same in both record configurations. Distance L is defined as being the maximum distance to record position 1 that was visited between the configuration of record 1 and record 2.]]

A '''translated cycler''' (also known as a '''partial recurrent''' or '''Lin recurrent''' TM) is a non-halting [[Turing machine]] which eventually exhibits a traveling cyclic behavior. Specifically, a TM has ented a translated cycle once it begins repeating a fixed sequence of transition rules in such a way that it will continue repeating them forever. It is, by far, the most common type of non-halting behavior. For example, 95% of all infinite [[BB(6)]] TMs are translated cyclers (which have cycled at least once within the first 1000 steps) and this number is relatively consistent across other BB "domains" (Say BB(5), BB(3,3), etc.).

See [https://github.com/bbchallenge/bbchallenge-proofs/blob/build-latex-pdf/deciders/correctness-deciders.pdf Section 3] of bbchallenge's deciders write-up for a formal presentation of translated cyclers.

== History ==
Translated cycling behavior was first described by Shen Lin in his proof of [[BB(3)]] where he called it "partial recurrence".<ref>Lin, Shen; Radó, Tibor (April 1965). "Computer Studies of Turing Machine Problems". ''Journal of the ACM''. '''12''' (2): 196–212. <nowiki>https://doi.org/10.1145/321264.321270</nowiki></ref> He describes an algorithm for detecting it which appears to be the first documented example of a [[decider]]. This behavior has been given many names over the years. For example, Nick Drozd calls this Lin recurrence in honor of Shen Lin.<ref>Nick Drozd. 2021. [https://nickdrozd.github.io/2021/02/24/lin-recurrence-and-lins-algorithm.html Lin Recurrence and Lin's Algorithm]</ref>

== Record breaking ==
One way to detect translated cycling is by analyzing [[record breaking]] configurations. This is the algorithm used by [[bbchallenge]]. A Turing machine is a translated cycler if it has two configurations that break a record (i.e. visit a memory cell that was never visited before) in the same state such that the content of the memory tape at distance L from the record positions is the same in both record configurations. Distance L is defined as being the maximum distance to record position 1 that was visited between the configuration of record 1 and record 2.

Here are the properties of the translated cycler shown in the figure:

* L = 2. After the translated cycler reaches record 1, the translated cycler moves at most L = 2 symbols to the left.
* The '''cycle period''' is 10 steps. This is the number of steps from record 1 to record 2.
* The '''cycle offset''' is 2 symbols to the right. In other words, after each cycle, the TM moves 2 places to the right.
* The '''cycle start time''' is 6 steps. This is the position of record 1. The cycle start time of a translated cycler can also be called its '''preperiod'''.

Translated cyclers are close to [[Cycler|Cyclers]] in the sense that they are only repeating a pattern but there is added complexity as they are able to translate the pattern in space at the same time, hence the decider for Cyclers cannot directly apply here.

== Infinite shift rule ==
A translated cycle can be seen as an infinite [[shift rule]]. For example, consider the TM {{TM|1RB0RE_0LC1RC_0RD1LA_1LE---_1LB1RC|non-halt}} in the image at the right. It performs the following [[transition rule]]:<math display="block">\begin{array}{l}
\\
10\;\textrm{D}\textrm{>}\;00\xrightarrow{10}00\;10\;\textrm{D}\textrm{>} \\
\end{array}</math>

which can be repeated to form the shift rule:<math display="block">\begin{array}{l}
\\
10\;\textrm{D}\textrm{>}\;{00}^n\xrightarrow{10n}{00}^n\;10\;\textrm{D}\textrm{>} \\
\end{array}</math>

Furthermore, on step 6, this TM is in config

<math display="block">0^\infty\;1\;10\;\textrm{D}\textrm{>}\;0^\infty</math>

Therefore, we can see that for all <math>n \ge 0</math> we can apply the shift rule and so this TM can never halt.

==Related Functions==

* Busy Preperiodic Beaver ([[BBS]](n,m)): The longest possible preperiod of a cycler or translated cycler with n states and m symbols.
* Busy Periodic Beaver ([[BBP]](n,m)): The longest possible period of a cycler or translated cycler with n states and m symbols.

== Notable translated cyclers ==

* [[Skelet 1]] is a translated cycler that has a period of 8,468,569,863 steps, an offset of 107,917 symbols to the right, and a start time of about <math>5.42 \times 10^{51}</math>.
* {{TM|1RB1LD_1RC1RB_1LC1LA_0RC0RD}} is the current [[Beeping Busy Beaver]] (4,2) and [[Blanking Busy Beaver]] (4,2) champion. It has a preperiod of 32,779,478 steps, a period of 1 step and a cycle offset of 1 symbol to the left. Its tape configuration in record <math>k</math> is <math>0^\infty\;\textrm{<}\textrm{C}\;1^{k} 0^\infty\;</math>.

== See also ==

* [[non-halting Turing machine]]

== Sources ==
<references />

[[Category:Zoology]]
[[Category:Deciders]]

Translated cycler

2025-10-07T22:48:12Z

MrSolis:

[[File:Translated_cycler_44394115_annotated.svg|right|thumb|Example "Translated cycler": 45-step space-time diagram of bbchallenge's machine {{TM|1RB0RE_0LC1RC_0RD1LA_1LE---_1LB1RC}}. The same bounded pattern is being translated to the right forever. The text annotations illustrate the main idea for recognising "Translated Cyclers": find two configurations that break a record (i.e. visit a memory cell that was never visited before) in the same state (here state D) such that the content of the memory tape at distance L from the record positions is the same in both record configurations. Distance L is defined as being the maximum distance to record position 1 that was visited between the configuration of record 1 and record 2.]]

A '''translated cycler''' (also known as a '''partial recurrent''' or '''Lin recurrent''' TM) is a non-halting [[Turing machine]] which eventually exhibits a traveling cyclic behavior. Specifically, a TM has ented a translated cycle once it begins repeating a fixed sequence of transition rules in such a way that it will continue repeating them forever. It is, by far, the most common type of non-halting behavior. For example, 95% of all infinite [[BB(6)]] TMs are translated cyclers (which have cycled at least once within the first 1000 steps) and this number is relatively consistent across other BB "domains" (Say BB(5), BB(3,3), etc.).

See [https://github.com/bbchallenge/bbchallenge-proofs/blob/build-latex-pdf/deciders/correctness-deciders.pdf Section 3] of bbchallenge's deciders write-up for a formal presentation of translated cyclers.

== History ==
Translated cycling behavior was first described by Shen Lin in his proof of [[BB(3)]] where he called it "partial recurrence".<ref>Lin, Shen; Radó, Tibor (April 1965). "Computer Studies of Turing Machine Problems". ''Journal of the ACM''. '''12''' (2): 196–212. <nowiki>https://doi.org/10.1145/321264.321270</nowiki></ref> He describes an algorithm for detecting it which appears to be the first documented example of a [[decider]]. This behavior has been given many names over the years. For example, Nick Drozd calls this Lin recurrence in honor of Shen Lin.<ref>Nick Drozd. 2021. [https://nickdrozd.github.io/2021/02/24/lin-recurrence-and-lins-algorithm.html Lin Recurrence and Lin's Algorithm]</ref>

== Record breaking ==
One way to detect translated cycling is by analyzing [[record breaking]] configurations. This is the algorithm used by [[bbchallenge]]. A Turing machine is a translated cycler if it has two configurations that break a record (i.e. visit a memory cell that was never visited before) in the same state such that the content of the memory tape at distance L from the record positions is the same in both record configurations. Distance L is defined as being the maximum distance to record position 1 that was visited between the configuration of record 1 and record 2.

Here are the properties of the translated cycler shown in the figure:

* L = 2. After the translated cycler reaches record 1, the translated cycler moves at most L = 2 symbols to the left.
* The '''cycle period''' is 10 steps. This is the number of steps from record 1 to record 2.
* The '''cycle offset''' is 2 symbols to the right. In other words, after each cycle, the TM moves 2 places to the right.
* The '''cycle start time''' is 6 steps. This is the position of record 1. The cycle start time of a translated cycler can also be called its '''preperiod'''.

Translated cyclers are close to [[Cycler|Cyclers]] in the sense that they are only repeating a pattern but there is added complexity as they are able to translate the pattern in space at the same time, hence the decider for Cyclers cannot directly apply here.

== Infinite shift rule ==
A translated cycle can be seen as an infinite [[shift rule]]. For example, consider the TM {{TM|1RB0RE_0LC1RC_0RD1LA_1LE---_1LB1RC|non-halt}} in the image at the right. It performs the following [[transition rule]]:<math display="block">\begin{array}{l}
\\
10\;\textrm{D}\textrm{>}\;00\xrightarrow{10}00\;10\;\textrm{D}\textrm{>} \\
\end{array}</math>

which can be repeated to form the shift rule:<math display="block">\begin{array}{l}
\\
10\;\textrm{D}\textrm{>}\;{00}^n\xrightarrow{10n}{00}^n\;10\;\textrm{D}\textrm{>} \\
\end{array}</math>

Furthermore, on step 6, this TM is in config

<math display="block">0^\infty\;1\;10\;\textrm{D}\textrm{>}\;0^\infty</math>

Therefore, we can see that for all <math>n \ge 0</math> we can apply the shift rule and so this TM can never halt.

==Related Functions==

* Busy Preperiodic Beaver ([[BBS]](n,m)): The longest possible preperiod of a cycler or translated cycler with n states and m symbols.
* Busy Periodic Beaver ([[BBP]](n,m)): The longest possible period of a cycler or translated cycler with n states and m symbols.

== Notable translated cyclers ==

* [[Skelet 1]] is a translated cycler that has a period of 8,468,569,863 steps, an offset of 107,917 symbols to the right, and a start time of about <math>5.42 \times 10^{51}</math>.
* {{TM|1RB1LD_1RC1RB_1LC1LA_0RC0RD}} is the current [[Beeping Busy Beaver]] (4,2) and [[Blanking Busy Beaver]] (4,2) champion. It has a preperiod of 32,779,478 steps, a period of 1 step and a cycle offset of 1 symbol to the left. Its tape configuration in record <math>k</math> is <math>0^\infty\;\textrm{<}\textrm{C} 1^{k} 0^\infty\;</math>.

== See also ==

* [[non-halting Turing machine]]

== Sources ==
<references />

[[Category:Zoology]]
[[Category:Deciders]]

Translated cycler

2025-10-07T22:47:53Z

MrSolis: :O

[[File:Translated_cycler_44394115_annotated.svg|right|thumb|Example "Translated cycler": 45-step space-time diagram of bbchallenge's machine {{TM|1RB0RE_0LC1RC_0RD1LA_1LE---_1LB1RC}}. The same bounded pattern is being translated to the right forever. The text annotations illustrate the main idea for recognising "Translated Cyclers": find two configurations that break a record (i.e. visit a memory cell that was never visited before) in the same state (here state D) such that the content of the memory tape at distance L from the record positions is the same in both record configurations. Distance L is defined as being the maximum distance to record position 1 that was visited between the configuration of record 1 and record 2.]]

A '''translated cycler''' (also known as a '''partial recurrent''' or '''Lin recurrent''' TM) is a non-halting [[Turing machine]] which eventually exhibits a traveling cyclic behavior. Specifically, a TM has ented a translated cycle once it begins repeating a fixed sequence of transition rules in such a way that it will continue repeating them forever. It is, by far, the most common type of non-halting behavior. For example, 95% of all infinite [[BB(6)]] TMs are translated cyclers (which have cycled at least once within the first 1000 steps) and this number is relatively consistent across other BB "domains" (Say BB(5), BB(3,3), etc.).

See [https://github.com/bbchallenge/bbchallenge-proofs/blob/build-latex-pdf/deciders/correctness-deciders.pdf Section 3] of bbchallenge's deciders write-up for a formal presentation of translated cyclers.

== History ==
Translated cycling behavior was first described by Shen Lin in his proof of [[BB(3)]] where he called it "partial recurrence".<ref>Lin, Shen; Radó, Tibor (April 1965). "Computer Studies of Turing Machine Problems". ''Journal of the ACM''. '''12''' (2): 196–212. <nowiki>https://doi.org/10.1145/321264.321270</nowiki></ref> He describes an algorithm for detecting it which appears to be the first documented example of a [[decider]]. This behavior has been given many names over the years. For example, Nick Drozd calls this Lin recurrence in honor of Shen Lin.<ref>Nick Drozd. 2021. [https://nickdrozd.github.io/2021/02/24/lin-recurrence-and-lins-algorithm.html Lin Recurrence and Lin's Algorithm]</ref>

== Record breaking ==
One way to detect translated cycling is by analyzing [[record breaking]] configurations. This is the algorithm used by [[bbchallenge]]. A Turing machine is a translated cycler if it has two configurations that break a record (i.e. visit a memory cell that was never visited before) in the same state such that the content of the memory tape at distance L from the record positions is the same in both record configurations. Distance L is defined as being the maximum distance to record position 1 that was visited between the configuration of record 1 and record 2.

Here are the properties of the translated cycler shown in the figure:

* L = 2. After the translated cycler reaches record 1, the translated cycler moves at most L = 2 symbols to the left.
* The '''cycle period''' is 10 steps. This is the number of steps from record 1 to record 2.
* The '''cycle offset''' is 2 symbols to the right. In other words, after each cycle, the TM moves 2 places to the right.
* The '''cycle start time''' is 6 steps. This is the position of record 1. The cycle start time of a translated cycler can also be called its '''preperiod'''.

Translated cyclers are close to [[Cycler|Cyclers]] in the sense that they are only repeating a pattern but there is added complexity as they are able to translate the pattern in space at the same time, hence the decider for Cyclers cannot directly apply here.

== Infinite shift rule ==
A translated cycle can be seen as an infinite [[shift rule]]. For example, consider the TM {{TM|1RB0RE_0LC1RC_0RD1LA_1LE---_1LB1RC|non-halt}} in the image at the right. It performs the following [[transition rule]]:<math display="block">\begin{array}{l}
\\
10\;\textrm{D}\textrm{>}\;00\xrightarrow{10}00\;10\;\textrm{D}\textrm{>} \\
\end{array}</math>

which can be repeated to form the shift rule:<math display="block">\begin{array}{l}
\\
10\;\textrm{D}\textrm{>}\;{00}^n\xrightarrow{10n}{00}^n\;10\;\textrm{D}\textrm{>} \\
\end{array}</math>

Furthermore, on step 6, this TM is in config

<math display="block">0^\infty\;1\;10\;\textrm{D}\textrm{>}\;0^\infty</math>

Therefore, we can see that for all <math>n \ge 0</math> we can apply the shift rule and so this TM can never halt.

==Related Functions==

* Busy Preperiodic Beaver ([[BBS]](n,m)): The longest possible preperiod of a cycler or translated cycler with n states and m symbols.
* Busy Periodic Beaver ([[BBP]](n,m)): The longest possible period of a cycler or translated cycler with n states and m symbols.

== Notable translated cyclers ==

* [[Skelet 1]] is a translated cycler that has a period of 8,468,569,863 steps, an offset of 107,917 symbols to the right, and a start time of about <math>5.42 \times 10^{51}</math>.
* {{TM|1RB1LD_1RC1RB_1LC1LA_0RC0RD}} is the current [[Beeping Busy Beaver]] (4,2) and [[Blanking Busy Beaver]] (4,2) champion. It has a preperiod of 32,779,478 steps, a period of 1 step and a cycle offset of 1 symbol to the left. Its tape configuration in record <math>k</math> is <math>0^\infty\;\textrm{<C} 1^{k} 0^\infty\;</math>.

== See also ==

* [[non-halting Turing machine]]

== Sources ==
<references />

[[Category:Zoology]]
[[Category:Deciders]]

Busy Beaver Functions

2025-10-07T22:44:41Z

MrSolis: !

The Busy Beaver Game is the search for [[Turing machine|Turing machines]] which maximize various '''Busy Beaver Functions'''. All Busy Beaver functions are non-computable. There are several, related functions with different authors referring to one or the other as "the Busy Beaver function". Therefore, it is recommended that you use a more specific designation when referring to one specific Busy Beaver function.

The two most commonly used Busy Beaver functions are:

* The Maximum Shift function <math>S(n, m)</math> which is the most commonly used Busy Beaver function by [[Bbchallenge.org|bbchallenge]] and is generally called <math>BB(n, m)</math> here.
* The Maximum Score function <math>\Sigma(n, m)</math> which is Tibor Radó's original Busy Beaver function.
where <math>n</math> denotes the number of states and <math>m</math> the number of symbols.

== Max Shift Function S(n, m) ==
The Maximum Shift or Maximum Step function is the largest number of steps (or shifts) that any Turing machine (of a certain size, and starting with a blank tape) takes before halting. It was introduced by Tibor Radó in his seminal Busy Beaver paper.<ref>Tibor Radó (May 1962). "[https://computation4cognitivescientists.weebly.com/uploads/6/2/8/3/6283774/rado-on_non-computable_functions.pdf On non-computable functions]" (PDF). ''Bell System Technical Journal''. '''41''' (3): 877–884. https://doi.org/10.1002%2Fj.1538-7305.1962.tb00480.x</ref> He used the notation <math>S(n)</math> to define it for Turing machines with <math>n</math> states and 2 symbols. This was later extended to <math>S(n, m)</math> for <math>n</math> states and <math>m</math> symbols. Notably, the halting transition counts as a step, so the TM with rule <code>A0 -> 1RZ</code> halts in 1 step.

Ben-Amram calls this the <math>time(n)</math> function.<ref name=":0">Ben-Amram A.M., Julstrom B.A. and Zwick U. (1996). [http://dx.doi.org/10.1007/BF01192693 A note on busy beavers and other creatures]. ''Mathematical Systems Theory'' '''29''' (4), July-August 1996, 375-386.</ref> Harland calls it the "frantic frog" function <math>ff(n)</math>.<ref name=":1">James Harland. [https://dl.acm.org/doi/pdf/10.5555/1151785.1151794 The Busy Beaver, the Placid Platypus and other Crazy Creatures]. 2006.</ref>

In his 2020 [[Busy Beaver Frontier]] survey, Scott Aaronson used the notation <math>BB(n, m)</math> for the Max Shift function and referred to it as "the" Busy Beaver function.<ref name=":2">Scott Aaronson. [https://scottaaronson.blog/?p=4916 The Busy Beaver Frontier]. 2020.</ref>

== Max Score Function Σ(n, m) ==
The Maximum Score function is the largest number of ones (or non-zero symbols in general) left on the tape by any halting Turing machine (of a certain size, and starting with a blank tape) at the moment it halts. It was also introduced by Tibor Radó in his seminal paper. He called it the "score" of the Turing machine. He used the notation <math>\Sigma(n)</math> to define it for Turing machines with <math>n</math> states and 2 symbols. This was later extended to <math>\Sigma(n, m)</math> for <math>n</math> states and <math>m</math> symbols.

Ben-Amram calls this the <math>ones(n)</math> function.<ref name=":0" /> Harland calls it the "busy beaver" function <math>bb(n)</math>.<ref name=":1" /> Before Aaronson's survey, this was the function that most people called "the" Busy Beaver function.

== Other Busy Beaver functions ==
In addition to the above functions, there are a couple of others that have appeared in the literature:

* [[Maximum Space Function|Maximum space]]: Ben-Amram calls this <math>space(n)</math><ref name=":0" />, bbchallenge calls it <code>BB_SPACE(n)</code> or <math>BB_{space}(n)</math>. This is the total number of tape cells read before halting. According to Ben-Amram, it includes the starting cell, but not necessarily the cell the halting transition moves to.<ref name=":0" />
* [[Maximum Consecutive Ones Function|Maximum consecutive ones]]: Ben-Amram calls this <math>num(n)</math>.<ref name=":0" /> A TM only qualifies if it halts with all ones consecutive on tape.
* <math>N_e</math> function: Radó formulated the number of halting machines in terms of the set of all valid busy beaver entries <math>M,s</math> where <math>M</math> is the Turing machine, and <math>s</math> is the exact number of steps the halting Turing machine took. The set of all halting <math>n</math>-card machines is denoted <math>E_n</math>, and the cardinality of this set is denoted <math>N_e(n)</math> The number of <math>n</math>-card Turing machines that halt after exactly or not more than s steps are respectively denoted <math>N(s,n)</math> and <math>G(s,n)</math>.
* [[Blanking Busy Beaver]]: <math>BLB(n,m)</math> is the largest amount of steps done by any Turing machine with n states and m symbols before blanking the tape.
* [[Beeping Busy Beaver|Beeping busy beaver]]: <math>BBB(n,m)</math> is the largest amount of steps done by any Turing machine with ''n'' states and ''m'' symbols before [[Quasihalt|quasihalting]].
* [[BBP|Busy periodic beaver]]: <math>BBP(n,m)</math> is the longest period of any cycler or [[translated cycler]] with ''n'' states and ''m'' symbols.
* [[BBS|Busy preperiodic beaver]]: <math>BBS(n,m)</math> is the longest preperiod of any cycler or [[translated cycler]] with ''n'' states and ''m'' symbols.
* Higher order busy beaver functions:
*BB<sub>L</sub>(n) (busy beaver for L programs): People have also studied variants with a 2-dimensional tape, or where the tape head is allowed to stay still in addition to moving left or right, etc. More broadly, given any programming language L, whose programs consist of bit-strings, one can define a Busy Beaver function for L-programs:BB<sub>L</sub>(n) := max<sub>P∈L∩{0,1}</sub><sup>≤n</sup><sub>: s(P)<∞</sub>s(P) where s(P) is the number of steps taken by P on a blank input. Alternatively, some people define a “Busy Beaver function for L-programs” using Kolmogorov complexity. That is, they let BB’<sub>L</sub>(n) be the largest integer m such that K<sub>L</sub> (m) ≤ n, where K<sub>L</sub>(m) is the length of the shortest L-program whose output is m on a blank input.<ref name=":3">[https://www.scottaaronson.com/papers/bb.pdf Scott Aaronson - The Busy Beaver frontier]</ref>
*<math>R(n)</math> (The runtime spectrum function): <math>T(n)</math> is the set of <math>n</math>-state Turing machines, and <math>s(M)</math> is the running time of machine <math>M</math> on an all-0 input tape. Let <math>R(n)</math> be the spectrum of possible runtimes of <math>n</math>-state machines on the all-0 input<math> R(n) := \lbrace k \in \natnums : s(M) = k\text{ for some }M \in T(n) \rbrace</math>.<ref name=":3" />
*[[Instruction-Limited Busy Beaver]] Function: <math> BBi(n)</math> is the longest runtime for all halting n-instruction (allowing any states and symbols) TMs when started on a blank tape.
*[[Reversible Turing Machine|Reversible Busy Beaver]] Function: <math> BB_{rev}(n,m)</math> is the longest runtime for all halting reversible n-states m-symbols TMs.

== References ==
<references />
[[category:Functions]]

Skelet 17

2025-10-07T22:41:48Z

MrSolis: :/

{{machine|1LB---_0RC1LE_0RD1RC_1LA1RB_0LB0LA}}{{Stub}}
{{TM|1RB---_0LC1RE_0LD1LC_1RA1LB_0RB0RA}}, called '''Skelet #17''', was one of [[Skelet's 43 holdouts]] and one of the last holdouts in [[BB(5)]].

The first step towards its resolution was made by savask, who showed the connection to [[wikipedia:Gray_code|Gray Code]]: https://docs.bbchallenge.org/other/skelet17_savasks_analysis.pdf

Building upon this work, Chris Xu produced a full proof of its non-halting that can be found here: https://chrisxudoesmath.com/papers/skelet17.pdf

Adapting the above, a formal proof of its non-halting by mxdys can be found here: https://github.com/ccz181078/Coq-BB5/blob/main/CoqBB5/Skelet17.md

== TM Behavior ==

{| class="wikitable floatright" style="text-align:center;"
! rowspan="2"|
|-
! 5 !! 4 !! 3 !! 2 !! 1 !! 0 !! value !! length !! <math>\sigma</math>
|-
| 0 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || 0 || 3 || +1
|-
| 1 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|0}} || 1 || 3 || +1
|-
| 1* || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#DDD"|{{mono|1}} || style="background:#DDD"|{{mono|1}} || style="background:#F22"|{{mono|-1}} || 2 || 3 || +1
|-
| 2 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#DDD"|{{mono|1}} || style="background:#DDD"|{{mono|1}} || 1 || 2 || -1
|-
| 3 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|0}} || 0 || 2 || -1
|-
| 3* || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|0}} || 0 || 2 || -1
|-
| 4 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|3}} || 0 || 3 || +1
|-
| 5 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || 1 || 3 || +1
|-
| 6 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#DDD"|{{mono|1}} || style="background:#DDD"|{{mono|1}} || style="background:#DDD"|{{mono|1}} || 2 || 3 || +1
|-
| 7 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|0}} || 3 || 3 || +1
|-
| 7* || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|0}} || 0 || 4 || -1
|-
| 7** || style="background:#0FF"|{{mono|0}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|2}} || style="background:#F22"|{{mono|-1}} || 7 || 6 || -1
|-
| 8 || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|2}} || 3 || 5 || +1
|-
| 9 || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#DDD"|{{mono|1}} || 4 || 5 || +1
|-
| 10 || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#DDD"|{{mono|1}} || style="background:#DDD"|{{mono|3}} || style="background:#0FF"|{{mono|0}} || 5 || 5 || +1
|-
| 10* || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#DDD"|{{mono|3}} || style="background:#F22"|{{mono|-1}} || 6 || 5 || +1
|-
| 11 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#DDD"|{{mono|3}} || 3 || 4 || -1
|-
| 12 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#DDD"|{{mono|3}} || style="background:#0FF"|{{mono|2}} || 2 || 4 || -1
|-
| 13 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#0FF"|{{mono|2}} || style="background:#DDD"|{{mono|3}} || style="background:#DDD"|{{mono|1}} || 1 || 4 || -1
|-
| 14 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|4}} || style="background:#0FF"|{{mono|0}} || 0 || 4 || -1
|-
| 14* || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|4}} || style="background:#0FF"|{{mono|0}} || 7 || 5 || +1
|-
| 14** || style="background:#0FF"|{{mono|0}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|4}} || style="background:#F22"|{{mono|-1}} || 7 || 6 || -1
|-
| 15 || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|4}} || 3 || 5 || +1
|-
| 16 || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#DDD"|{{mono|3}} || 4 || 5 || +1
|-
| 17 || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#DDD"|{{mono|1}} || style="background:#DDD"|{{mono|3}} || style="background:#0FF"|{{mono|2}} || 5 || 5 || +1
|-
| 18 || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#DDD"|{{mono|3}} || style="background:#DDD"|{{mono|1}} || 6 || 5 || +1
|-
| 19 || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|0}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|4}} || style="background:#0FF"|{{mono|0}} || 7 || 5 || +1
|-
| 19* || style="background:#111"|{{mono|-}} || style="background:#DDD"|{{mono|1}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|4}} || style="background:#F22"|{{mono|-1}} || 8 || 5 || +1
|-
| 20 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#DDD"|{{mono|1}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|4}} || 4 || 4 || -1
|-
| 21 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|2}} || style="background:#DDD"|{{mono|1}} || style="background:#0FF"|{{mono|2}} || style="background:#DDD"|{{mono|3}} || 3 || 4 || -1
|-
| 22 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|2}} || style="background:#DDD"|{{mono|1}} || style="background:#DDD"|{{mono|3}} || style="background:#0FF"|{{mono|2}} || 2 || 4 || -1
|-
| 23 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|2}} || style="background:#DDD"|{{mono|3}} || style="background:#DDD"|{{mono|1}} || 1 || 4 || -1
|-
| 24 || style="background:#111"|{{mono|-}} || style="background:#111"|{{mono|-}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|2}} || style="background:#0FF"|{{mono|4}} || style="background:#0FF"|{{mono|0}} || 0 || 4 || -1
|}

It can be shown that when the machine head is at the right end of the tape, the complete tape configuration is of the following form (using [[Directed head notation]]):

<math>0^\infty\;10^{n_1}\;1\;10^{n_2}\;\dots\;1\;10^{n_k}\;\textrm{B}\textrm{>}\;0^\infty</math>,

where <math>n_i</math> represents a non-negative integer. Essentially, Skelet 17 builds <math>k</math>-length lists of non-negative numbers delimited with individual cells imprinted with a 1.

The most common transformation (frequency tends to 1 as the number of steps increases) occuring between such configurations is described by Increment rule, similar to the Lucal form of Gray Code: the value at the last index is decremented and the value to the left of the rightmost index with odd value is incremented.

It is useful to consider the following ''state variables'':

* Gray Code value (denoted by <math>n</math>): the integer that is obtained by calculating the parity of each number (except the last) in the list, considering the result as a Gray Code bitstring corresponding to some integer and "recovering" this integer.
* Increment value (denoted by <math>\sigma</math>): the parity of the entire sequence, mapped to <math>\{-1, 1\}</math>. Dirung Increment steps, Skelet 17 counts forwards when <math>\sigma = +1</math> or backwards if <math>\sigma = -1</math>.
* Length of the sequence (including leading zeros).

When started on a blank tape, the machine visits configurations of the form <math>(0, 2, 4, ..., 2^{2k+2}, 0)</math> infinitely often (the step numbers where it occurs approximately equal power of 16: 14, 251, 4088, 65537, 1048646, 16777607, 268437188, etc).

=== Analysis by bisimulation ===

Chris Xu found it useful to divide some tape transformations into two phases, one of them is "virtual" or "invisible", as it does not actually occur on the tape. Indeed, the intermediate step involves negative numbers (the last number being decremented to -1 from 0), which of course cannot correspond to the <math>10^{a_i}</math> written on the tape.

Such skipped intermediate steps are denoted by asterisks in the table to preserve the "real" step counts (e.g. steps 7* and 7**).
[[Category:BB(5)]]

0RB1LD 1LC1RB 1LD1RE 1LA1LE 1LZ0RC

2025-10-07T22:39:00Z

MrSolis: :(

{{machine|0RB1LD_1LC1RB_1LD1RE_1LA1LE_1LZ0RC}}
{{TM|0RB1LD_1LC1RB_1LD1RE_1LA1LE_1LZ0RC|halt}} is the [[Busy Beaver Functions|num(5)]] champion (the [[BB(5)|five-state, two-symbol]] TM which halts leaving the most consecutive ones on the tape) according to Andrés Sancho.<ref>[https://discord.com/channels/960643023006490684/1242208042460647575/1337655697348886558 Discord message] by Andrés Sancho on 8 Feb 2025</ref><ref>https://github.com/MatterAndy/BB5-contiguous-1s</ref> It halts after 15590 steps with 165 consecutive ones on the tape.

It is tied for the num(5) championship with {{TM|1RB1LA_1RC1LE_1RD1RE_0LA1RC_1RZ0LB|halt}} which is the [[TNF-1RB]] version of the same TM (The [[permutation]] of this TM starting at state B).

== Analysis ==
Let <math>A(a):=0^\infty\;1^a\;\textrm{<}\textrm{A}\;11\;0^\infty</math>. Then,
<math display="block">\begin{array}{lll}A(3a)&\to&A(4a+2)\\A(3a+1)&\to&A(4a+4)\\A(3a+2)&\to&0^\infty\;\textrm{<}\textrm{Z}\;1^{4a+5}\;0^\infty\end{array}</math>
== Trajectory ==
This Turing machine starts with <math>A(3)</math> after 13 steps and halts after 10 rule applications:
<math display="block">A(3)\to A(6)\to A(10)\to A(16)\to A(24)\to A(34)\to A(48)\to A(66)\to A(90)\to A(122)\to 0^\infty\;\textrm{<}\textrm{Z}\;1^{165}\;0^\infty</math>

== References ==
<references/>
[[Category:BB(5)]]

1RB0LD 1RC0RF 1LC1LA 0LE1RZ 1LF0RB 0RC0RE

2025-10-07T22:18:19Z

MrSolis: >:(

{{machine|1RB0LD_1RC0RF_1LC1LA_0LE1RZ_1LF0RB_0RC0RE}}{{Stub}}
{{TM|1RB0LD_1RC0RF_1LC1LA_0LE1RZ_1LF0RB_0RC0RE|halt}} is a former [[BB(6)]] champion. It was discovered by Pavel Kropitz on 30 May 2022. This TM runs for over 10 ↑↑ 15 steps. An improved bound for this TMs runtime was achieved by Shawn Ligocki, using an extended version of tetration: <math>10 \uparrow\uparrow 15.60463 < \mathrm{Score} < \mathrm{Runtime} < 10 \uparrow\uparrow 15.60466</math>.<ref>S. Ligocki, "[https://www.sligocki.com/2022/06/25/ext-up-notation.html Extending Up-arrow Notation]". Blog Post, 2022. Accessed 15 August 2025.</ref><ref>S. Ligocki, "[https://www.sligocki.com/2022/06/21/bb-6-2-t15.html BB(6, 2) > 10↑↑15]". Blog post, 2022. Accessed 20 June 2024.</ref>

It simulates the following Collatz-like rules, starting at <math>C(5)</math>, on tape configurations <math>C(n):= 0^\infty\; 1\; 0^n\; 11\; 0^5\; \textrm{C}\textrm{>}\; 0^\infty</math>:

<math display="block">\begin{array}{l}
C(4k) & \to & \operatorname{Halt}\Bigl(\frac{3^{k+3} - 11}{2}\Bigr) \\
C(4k+1) & \to & C\Bigl(\frac{3^{k+3} - 11}{2}\Bigr) \\
C(4k+2) & \to & C\Bigl(\frac{3^{k+3} - 11}{2}\Bigr) \\
C(4k+3) & \to & C\Bigl(\frac{3^{k+3} + 1}{2}\Bigr) \\
\end{array}</math>

==References==
<references />

[[Category:BB(6)]]

Hydra

2025-10-07T22:14:02Z

MrSolis: :(

{{machine|1RB3RB---3LA1RA_2LA3RA4LB0LB0LA}}{{unsolved|Does Hydra run forever?}}
{{TM|1RB3RB---3LA1RA_2LA3RA4LB0LB0LA|undecided}}, called '''Hydra''', is a [[BB(2,5)]] [[Cryptid]]. Its high-level rules were first reported [https://discord.com/channels/960643023006490684/1084047886494470185/1231110668288135208 on Discord] by Daniel Yuan on 20 April 2024, who also gave Hydra said name. Later on, a 6-state, 2-symbol [[Turing machine]] was discovered and named [[Antihydra]] for having similar behaviour to Hydra, making the study of this machine important to the study of that one.

Hydra is known to not generate Sturmian words<ref>Dubickas A. On Integer Sequences Generated by Linear Maps. ''Glasgow Mathematical Journal''. 2009; 51(2): 243-252. doi:[https://doi.org/10.1017/S0017089508004655 10.1017/S0017089508004655]</ref> (Corollary 4).
<div style="width: fit-content; text-align: center; margin-left: auto; margin-right: auto;">
{|class="wikitable" style="margin-left: auto; margin-right: auto;"
! !!0!!1!!2!!3!!4
|-
!A
|1RB
|3RB
| ---
|3LA
|1RA
|-
!B
|2LA
|3RA
|4LB
|0LB
|0LA
|}
The transition table of Hydra.</div>
== Analysis ==
Let <math>C(a,b):=0^\infty\;\textrm{<}\textrm{A}\;2\;0^a\;3^b\;2\;0^\infty</math>. Then,<ref>S. Ligocki, "[https://www.sligocki.com/2024/05/10/bb-2-5-is-hard.html BB(2, 5) is Hard (Hydra)] (2024). Accessed 22 July 2024.</ref>
<math display="block">\begin{array}{|lll|}\hline
C(2a,0)&\xrightarrow{6a^2+20a+4}&0^\infty\;3^{3a+1}\;1\;\textrm{A}\textrm{>}\;2\;0^\infty,\\
C(2a,b+1)&\xrightarrow{6a^2+23a+10}&C(3a+3,b),\\
C(2a+1,b)&\xrightarrow{4b+6a^2+23a+26}&C(3a+3,b+2).\\\hline
\end{array}</math>
<div class="toccolours mw-collapsible mw-collapsed">'''Proof'''<div class="mw-collapsible-content">
Consider the partial configuration <math>P(m,n):=0^\infty\;3^m\;\textrm{A}\textrm{>}\;02\;0^n</math>. After 14 steps this configuration becomes
<math>0^\infty\;3^{m+3}\;\textrm{<}\textrm{A}\;2\;0^{n-2}</math>. We note the following shift rule:
<math display="block">\begin{array}{|c|}\hline3^s\;\textrm{<}\textrm{A}\xrightarrow{s}\textrm{<}\textrm{A}\;3^s\\\hline\end{array}</math>
Using this shift rule, we get <math>0^\infty\;\textrm{<}\textrm{A}\;3^{m+3}\;2\;0^{n-2}</math> in <math>m+3</math> steps. From here, we can observe that <math>\textrm{A}\textrm{>}\;0\;3^s</math> turns into <math>3\;\textrm{A}\textrm{>}\;0\;3^{s-1}</math> in three steps if <math>s\ge 1</math>. By repeating this process, we acquire this transition rule:
<math display="block">\begin{array}{|c|}\hline\textrm{A}\textrm{>}\;0\;3^s\xrightarrow{3s}3^s\;\textrm{A}\textrm{>}\;0\\\hline\end{array}</math>
With this rule, it takes <math>3m+9</math> steps to reach the configuration <math>0^\infty\;3^{m+3}\;\textrm{A}\textrm{>}\;02\;0^{n-2}</math>, which is the same configuration as <math>P(m+3,n-2)</math>. To summarize:
<math display="block">\begin{array}{|c|}\hline P(m,n)\xrightarrow{4m+26}P(m+3,n-2)\text{ if }n\ge 2.\\\hline\end{array}</math>
With <math>C(a,b)</math> we have <math>P(0,a)</math>. As a result, we can apply this rule <math display="inline">\big\lfloor\frac{1}{2}a\big\rfloor</math> times, which creates two possible scenarios:
#If <math>a\equiv0\ (\operatorname{mod}2)</math>, then in <math>\sum_{i=0}^{(a/2)-1}(4\times 3i+26)=\textstyle\frac{3}{2}a^2+10a</math> steps we arrive at <math display="inline">P\Big(\frac{3}{2}a,0\Big)</math>. The matching complete configuration is <math>0^\infty\;3^{(3/2)a}\;\textrm{A}\textrm{>}\;02\;3^b\;2\;0^\infty</math>, which in four steps becomes <math>0^\infty\;3^{(3/2)a+1}\;1\;\textrm{A}\textrm{>}\;3^b\;2\;0^\infty.</math> If <math>b=0</math> then we have reached the undefined <code>A2</code> transition in <math display="inline">\frac{3}{2}a^2+10a+4</math> steps total. Otherwise, continuing for three steps gives us <math>0^\infty\;3^{(3/2)+2}\;\textrm{<}\textrm{B}\;0\;3^{b-1}\;2\;0^\infty</math>. Another shift rule is required here:<math display="block">\begin{array}{|c|}\hline3^s\;\textrm{<}\textrm{B}\xrightarrow{s}\textrm{<}\textrm{B}\;0^s\\\hline\end{array}</math>This means the configuration becomes <math>0^\infty\;\textrm{<}\textrm{B}\;0^{(3/2)a+3}\;3^{b-1}\;2\;0^\infty</math> in <math display="inline">\frac{3}{2}a+2</math> steps, and <math>0^\infty\;\textrm{<}\textrm{A}\;2\;0^{(3/2)a+3}\;3^{b-1}\;2\;0^\infty</math>, equal to <math display="inline">C\Big(\frac{3}{2}a+3,b-1\Big)</math>, one step later. This gives a total of <math display="inline">\frac{3}{2}a^2+\frac{23}{2}a+10</math> steps.
#If <math>a\equiv1\ (\operatorname{mod}2)</math>, then in <math display="inline">\frac{3}{2}a^2+7a-\frac{17}{2}</math> steps we arrive at <math display="inline">P\Big(\frac{3a-3}{2},1\Big)</math>. The matching complete configuration is <math>0^\infty\;3^{(3a-3)/2}\;\textrm{A}\textrm{>}\;020\;3^b\;2\;0^\infty</math>, which in four steps becomes <math>0^\infty\;3^{(3a-1)/2}\;1\;\textrm{A}\textrm{>}\;0\;3^b\;2\;0^\infty</math>, and then <math>0^\infty\;3^{(3a-1)/2}\;1\;3^b\;\textrm{A}\textrm{>}\;02\;0^\infty</math> in <math>3b</math> steps. After 14 steps, we see the configuration <math>0^\infty\;3^{(3a-1)/2}\;1\;3^{b+3}\;\textrm{<}\textrm{A}\;2\;0^\infty</math>, which turns into <math>0^\infty\;3^{(3a-1)/2}\;1\;\textrm{<}\textrm{A}\;3^{b+3}\;2\;0^\infty</math> in <math>b+3</math> steps. In two steps we get <math>0^\infty\;3^{(3a+1)/2}\;\textrm{<}\textrm{B}\;0\;3^{b+2}\;2\;0^\infty</math>, followed by <math>0^\infty\;\textrm{<}\textrm{B}\;0^{(3a+3)/2}\;3^{b+2}\;2\;0^\infty</math> after <math display="inline">\frac{3a+1}{2}</math> more steps. We conclude with <math>0^\infty\;\textrm{<}\textrm{A}\;2\;0^{(3a+3)/2}\;3^{b+2}\;2\;0^\infty</math>, equal to <math display="inline">C\Big(\frac{3a+3}{2},b+2\Big)</math>, one step later. This gives a total of <math display="inline">4b+\frac{3}{2}a^2+\frac{17}{2}a+16</math> steps.
The information above can be summarized as
<math display="block">C(a,b)\rightarrow\begin{cases}0^\infty\;3^{(3/2)a+1}\;1\;\textrm{A}\textrm{>}\;2\;0^\infty&\text{if }a\equiv0\pmod{2}\text{ and }b=0,\\C\Big(\frac{3}{2}a+3,b-1\Big)&\text{if }a\equiv0\pmod{2}\text{ and }b>0,\\C\Big(\frac{3a+3}{2},b+2\Big)&\text{if }a\equiv1\pmod2.\end{cases}</math>
Substituting <math>a\leftarrow 2a</math> for the first two cases and <math>a\leftarrow 2a+1</math> for the third yields the final result.
</div></div>
In effect, the halting problem for Hydra is about whether repeatedly applying the function <math display="inline">f(n)=3\big\lfloor\frac{n}{2}\big\rfloor+3</math> will at some point produce more even values of <math>n</math> than twice the number of odd values.

An alternative version of these rules exists that makes the connection to Antihydra more apparent by using the function <math display="inline">H(n)=\Big\lfloor\frac{3}{2}n\Big\rfloor</math>, or the [[Hydra function]].<ref>S. Ligocki, "[https://www.sligocki.com/2024/07/06/bb-6-2-is-hard.html BB(6) is Hard (Antihydra)]" (2024). Accessed 22 July 2024.</ref>

== Trajectory ==
It takes 20 steps to reach the configuration <math>C(3,0)</math>, and from there, the [[Collatz-like]] rules are repeatedly applied. Simulating Hydra has shown that after 4000000 rule steps, we have <math>b=2005373</math>. Here are the first few:
<math display="block">\begin{array}{|c|}\hline C(3,0)\xrightarrow{55}C(6,2)\xrightarrow{133}C(12,1)\xrightarrow{364}C(21,0)\xrightarrow{856}C(33,2)\xrightarrow{1938}C(51,4)\xrightarrow{4367}C(78,6)\rightarrow\cdots\\\hline\end{array}</math>
The heuristic argument that suggests Antihydra is a [[probviously]] non-halting machine can be applied here. This means that if <math>b</math> is to be thought of as moving randomly, then the probability of Hydra halting is <math display="inline">{\Big(\frac{\sqrt{5}-1}{2}\Big)}^{2005374}\approx 4.168\times 10^{-419099}</math>.
== Code ==

Fast Hydra/[[Antihydra]] simulation code by Greg Kuperberg (who said it could be made faster using FLINT):<syntaxhighlight lang="python2" line="1">
# Python script to demonstrate almost linear time hydra simulation
# using fast multiplication.
# by Greg Kuperberg

import time
from gmpy2 import mpz,bit_mask

# Straight computation of t steps of hydra
def simple(n,t):
for s in range(t): n += n>>1
return n

# Accelerated computation of 2**e steps of hydra
def hydra(n,e):
if e < 9: return simple(n,1<<e)
t = 1<<(e-1)
(p3t,m) = (mpz(3)**t,bit_mask(t))
n = p3t*(n>>t) + hydra(n&m,e-1)
return p3t*(n>>t) + hydra(n&m,e-1)

def elapsed():
(last,elapsed.mark) = (elapsed.mark,time.process_time())
return elapsed.mark-last
elapsed.mark = 0

(n,e) = (mpz(3),25)

elapsed()
print('hydra: steps=%d hash=%016x time=%.6fs'
% (1<<e,hash(hydra(n,e)),elapsed()))

# Quadratic time algorithm for comparison
# print('simple: steps=%d hash=%016x time=%.6fs'
# % (1<<e,hash(simple(n,1<<e)),elapsed()))
</syntaxhighlight>

==References==
[[Category:BB(2,5)]][[Category:Cryptids]]

Bigfoot

2025-10-07T22:07:22Z

MrSolis: :(

{{machine|1RB2RA1LC_2LC1RB2RB_---2LA1LA}}{{unsolved|Does Bigfoot run forever?}}
'''Bigfoot''' ({{TM|1RB2RA1LC_2LC1RB2RB_---2LA1LA}}) is a [[BB(3,3)]] [[Cryptids|Cryptid]]. Its low-level behaviour was first shared [https://discord.com/channels/960643023006490684/1084047886494470185/1163168233445130270 over Discord] by savask on 14 Oct 2023, and within two days, Shawn Ligocki described the high-level rules shown below, whose attributes inspired the [[Turing machine|Turing machine's]] name.<ref name="b">S. Ligocki, "[https://www.sligocki.com/2023/10/16/bb-3-3-is-hard.html BB(3, 3) is Hard (Bigfoot)] (2024). Accessed 22 July 2024.</ref>
<div style="width: fit-content; text-align: center; margin-left: auto; margin-right: auto;">
{|class="wikitable" style="margin-left: auto; margin-right: auto;"
! !!0!!1!!2
|-
!A
|1RB
|2RA
|1LC
|-
!B
|2LC
|1RB
|2RB
|-align="center"
!C
| ---
|2LA
|1LA
|}
The transition table of Bigfoot.</div>

In May of 2024, Iijil [https://github.com/sligocki/sligocki.github.io/issues/8#issuecomment-2140887228 compiled] Bigfoot into a 7-state 2-symbol machine {{TM|0RB1RB_1LC0RA_1RE1LF_1LF1RE_0RD1RD_1LG0LG_---1LB}}.

== Analysis ==
Let <math>A(a,b,c):=0^\infty\;12^a\;1^{2b}\;\textrm{<}\textrm{A}\;1^{2c}\;0^\infty</math>. Then,
<math display="block">\begin{array}{|l l l|}\hline A(a,6b,c)&\xrightarrow{4a+(2b+1)48b+(12b+1)2c+13}&A(a,8b+c-1,2),\\A(a,6b+1,c)&\xrightarrow{4a+(6b+5)16b+(4b+1)6c+29}&A(a+1,8b+c-1,3),\\A(0,6b+2,c)&\xrightarrow{(b+1)96b+(3b+1)8c+18}&0^\infty\;\textrm{<}\textrm{C}\;1^{16b+2c+5}\;2\;0^\infty,\\A(a,6b+2,c)&\xrightarrow{4a+(2b+3)48b+(12b+7)2c+51}&A(a-1,8b+c+3,2)\text{ if }a\ge1,\\A(a,6b+3,c)&\xrightarrow{4a+(6b+7)16b+(12b+5)2c+91}&A(a,8b+c+1,5),\\A(a,6b+4,c)&\xrightarrow{4a+(2b+3)48b+(12b+7)2c+63}&A(a+1,8b+c+3,2),\\A(a,6b+5,c)&\xrightarrow{4a+(6b+11)16b+(4b+3)6c+103}&A(a,8b+c+5,3).\\\hline\end{array}</math>
<div class="toccolours mw-collapsible mw-collapsed">'''Proof'''<div class="mw-collapsible-content">
For now, we will work with the slightly different configuration <math>A'(a,b,c):=0^\infty\;12^a\;1^b\;\textrm{<}\textrm{A}\;1^c\;0^\infty</math>. Consider the partial configuration <math>P(m,n):=1^m\;\textrm{<}\textrm{A}\;1^n\;0^\infty</math>. We first require the following shift rule:
<math display="block">\begin{array}{|l|}\hline\textrm{A}\textrm{>}\;1^s\xrightarrow{s}2^s\;\textrm{A}\textrm{>}\\\hline\end{array}</math>
Using this shift rule, we get <math>1^{m-1}\;2^{n+1}\;\textrm{A}\textrm{>}\;0^\infty</math> after <math>n+1</math> steps, followed by <math>1^{m-1}\;2^n\;\textrm{<}\textrm{C}\;122\;0^\infty</math> four steps later. Observing that <math>22\;\textrm{<}\textrm{C}</math> becomes <math>\textrm{<}\textrm{C}\;11</math> in two steps leads to another shift rule:
<math display="block">\begin{array}{|l|}\hline2^{2s}\;\textrm{<}\textrm{C}\xrightarrow{2s}\textrm{<}\textrm{C}\;1^{2s}\\\hline\end{array}</math>
From here, there are two different scenarios depending on if <math>n</math> is even or odd, given below as histories of transitions that use the aforementioned shift rules:
#If <math>n\equiv0\ (\operatorname{mod}2)</math>, then what follows is:<math display="block">\begin{array}{|l|}\hline 1^{m-1}\;2^n\;\textrm{<}\textrm{C}\;122\;0^\infty \xrightarrow{n} 1^{m-1}\;\textrm{<}\textrm{C}\;1^{n+1}\;22\;0^\infty\xrightarrow{4}1^{m-3}\;\textrm{<}\textrm{A}\;1^{n+3}\;22\;0^\infty\xrightarrow{n+4}\\
1^{m-4}\;2^{n+4}\;\textrm{A}\textrm{>}\;22\;0^\infty\xrightarrow{1}1^{m-4}\;2^{n+4}\;\textrm{<}\textrm{C}\;12\;0^\infty\xrightarrow{n+4}1^{m-4}\;\textrm{<}\textrm{C}\;1^{n+5}\;2\;0^\infty\xrightarrow{4}\\1^{m-6}\;\textrm{<}\textrm{A}\;1^{n+7}\;2\;0^\infty\xrightarrow{n+8}1^{m-7}\;2^{n+8}\;\textrm{A}\textrm{>}\;2\;0^\infty\xrightarrow{1}1^{m-7}\;2^{n+8}\;\textrm{<}\textrm{C}\;1\;0^\infty\xrightarrow{n+8}\\1^{m-7}\;\textrm{<}\textrm{C}\;1^{n+9}\;0^\infty\xrightarrow{4}1^{m-9}\;\textrm{<}\textrm{A}\;1^{n+11}\;0^\infty\\\hline\end{array}</math>Therefore, we have<math display="block">\begin{array}{|l|}\hline P(m,n)\xrightarrow{6n+43}P(m-9,n+11)\text{ if }m\ge9\text{ and }n\equiv0\ (\operatorname{mod}2).\\\hline\end{array}</math>
# If <math>n\equiv1\ (\operatorname{mod}2)</math>, then what follows is:<math display="block">\begin{array}{|l|}\hline 1^{m-1}\;2^n\;\textrm{<}\textrm{C}\;122\;0^\infty \xrightarrow{n-1} 1^{m-1}\;2\;\textrm{<}\textrm{C}\;1^n\;22\;0^\infty \xrightarrow{1}1^{m-1}\;\textrm{<}\textrm{A}\;1^{n+1}\;22\;0^\infty \xrightarrow{n+2}\\ 1^{m-2}\;2^{n+2}\;\textrm{A}\textrm{>}\;22\;0^\infty \xrightarrow{1} 1^{m-2}\;2^{n+2}\;\textrm{<}\textrm{C}\;12\;0^\infty \xrightarrow{n+1}1^{m-2}\;2\;\textrm{<}\textrm{C}\;1^{n+2}\;2\;0^\infty \xrightarrow{1}\\ 1^{m-2}\;\textrm{<}\textrm{A}\;1^{n+3}\;2\;0^\infty \xrightarrow{n+4} 1^{m-3}\;2^{n+4}\;\textrm{A}\textrm{>}\;2\;0^\infty\xrightarrow{1}1^{m-3}\;2^{n+4}\;\textrm{<}\textrm{C}\;1\;0^\infty\xrightarrow{n+3}\\1^{m-3}\;2\;\textrm{<}\textrm{C}\;1^{n+4}\;0^\infty\xrightarrow{1}1^{m-3}\;\textrm{<}\textrm{A}\;1^{n+5}\;0^\infty\\\hline\end{array}</math>Therefore, we have
<math display="block">\begin{array}{|l|}\hline P(m,n)\xrightarrow{6n+19}P(m-3,n+5)\text{ if }m\ge3\text{ and }n\equiv1\ (\operatorname{mod}2).\\\hline\end{array}</math>
From this we know that Bigfoot's behaviour depends on the value of <math>b</math> modulo 12, and with <math>A'(a,b,c)</math> we have <math>P(b,c)</math>. The following shift rules will be useful:
<math display="block">\begin{array}{|l|l|l|}\hline12^s\;\textrm{<}\textrm{A}\xrightarrow{2s}\textrm{<}\textrm{A}\;21^s&\textrm{B}\textrm{>}\;1^s\xrightarrow{s}1^s\;\textrm{B}\textrm{>}&\textrm{B}\textrm{>}\;2^s\xrightarrow{s}2^s\;\textrm{B}\textrm{>}\\\hline\end{array}</math>
Only even values of <math>b</math> and <math>c</math> are relevant, so there remain six possible scenarios:
#If <math>b\equiv0\ (\operatorname{mod}12)</math>, then in <math display="inline">{\displaystyle\sum_{i=0}^{b/12-1}}(6(16i+c)+43+6(16i+11+c)+19)={\displaystyle\sum_{i=0}^{b/12-1}}4(48i+3c+32)=\frac{2}{3}b^2+\frac{8}{3}b+bc</math> steps we arrive at <math display="inline">P\Big(0,16\times\frac{b}{12}+c\Big)</math>, or <math>0^\infty\;12^a\;\textrm{<}\textrm{A}\;1^{4b/3+c}\;0^\infty</math> when considering the complete configuration. What follows is:<math display="block">\begin{array}{|l|}\hline0^\infty\;12^a\;\textrm{<}\textrm{A}\;1^{4b/3+c}\;0^\infty\xrightarrow{2a}0^\infty\;\textrm{<}\textrm{A}\;21^a\;1^{4b/3+c}\;0^\infty\xrightarrow{1}0^\infty\;1\;\textrm{B}\textrm{>}\;21^a\;1^{4b/3+c}\;0^\infty\xrightarrow{2a+4b/3+c}\\0^\infty\;12^a\;1^{4b/3+c+1}\;\textrm{B}\textrm{>}\;0^\infty\xrightarrow{12}0^\infty\;12^a\;1^{4b/3+c-2}\;\textrm{<}\textrm{A}\;1^4\;0^\infty\\\hline\end{array}</math>This means that if <math display="inline">\frac{4}{3}b+c\ge2</math>, then we will reach <math display="inline">A'\Big(a,\frac{4}{3}b+c-2,4\Big)</math> in <math display="inline">4a+\frac{2}{3}b^2+4b+bc+c+13</math> steps.
#If <math>b\equiv2\ (\operatorname{mod}12)</math>, then in <math display="inline">{\displaystyle\sum_{i=0}^{(b-2)/12-1}}4(48i+3c+32)=\frac{2}{3}b^2+bc-2c-\frac{8}{3}</math> steps we arrive at <math display="inline">P\Big(2,\frac{4(b-2)}{3}+c\Big)</math>, or <math>0^\infty\;12^a\;11\;\textrm{<}\textrm{A}\;1^{(4b-2)/3+c}\;0^\infty</math>. What follows is:<math display="block">\begin{array}{|l|}\hline0^\infty\;12^a\;11\;\textrm{<}\textrm{A}\;1^{4(b-2)/3+c}\;0^\infty\xrightarrow{4(b-2)/3+c+1}0^\infty\;12^a\;1\;2^{4(b-2)/3+c+1}\;\textrm{A}\textrm{>}\;0^\infty\xrightarrow{4}\\0^\infty\;12^a\;1\;2^{4(b-2)/3+c}\;\textrm{<}\textrm{C}\;122\;0^\infty\xrightarrow{4(b-2)/3+c}0^\infty\;12^a\;1\;\textrm{<}\textrm{C}\;1^{4(b-2)/3+c+1}\;22\;0^\infty\xrightarrow{1}\\0^\infty\;12^a\;\textrm{<}\textrm{A}\;2\;1^{4(b-2)/3+c+1}\;22\;0^\infty\xrightarrow{2a}0^\infty\;\textrm{<}\textrm{A}\;21^a\;2\;1^{4(b-2)/3+c+1}\;22\;0^\infty\xrightarrow{1}\\0^\infty\;1\;\textrm{B}\textrm{>}\;21^a\;2\;1^{4(b-2)/3+c+1}\;22\;0^\infty\xrightarrow{4(b-2)/3+2a+c+4}0^\infty\;12^{a+1}\;1^{4(b-2)/3+c+1}\;22\;\textrm{B}\textrm{>}\;0^\infty\xrightarrow{18}\\0^\infty\;12^{a+1}\;1^{4(b-2)/3+c-2}\;\textrm{<}\textrm{A}\;1^6\;0^\infty\\\hline\end{array}</math>This means that if <math display="inline">\frac{4(b-2)}{3}+c\ge 2</math>, then we will reach <math display="inline">A'\Big(a+1,\frac{4b-14}{3}+c,6\Big)</math> in <math display="inline">4a+\frac{2}{3}b^2+4b+bc+c+\frac{55}{3}</math> steps.
#If <math>b\equiv4\ (\operatorname{mod}12)</math>, then in <math display="inline>\frac{2}{3}b^2-\frac{8}{3}b+bc-4c</math> steps we arrive at <math display="inline">P\Big(4,\frac{4(b-4)}{3}+c\Big)</math>, or <math>0^\infty\;12^a\;1111\;\textrm{<}\textrm{A}\;1^{4(b-4)/3+c}\;0^\infty</math>. What follows is:<math display="block">\begin{array}{|l|}\hline0^\infty\;12^a\;1111\;\textrm{<}\textrm{A}\;1^{4(b-4)/3+c}\;0^\infty\xrightarrow{(8b-14)/3+2c}0^\infty\;12^a\;11\;\textrm{<}\textrm{A}\;2\;1^{4(b-4)/3+c+1}\;22\;0^\infty\xrightarrow{3}\\0^\infty\;12^a\;1\;\textrm{<}\textrm{A}\;1^{4(b-4)/3+c+3}\;22\;0^\infty\xrightarrow{4(b-4)/3+c+4}0^\infty\;12^a\;2^{4(b-4)/3+c+4}\;\textrm{A}\textrm{>}\;22\;0^\infty\xrightarrow{1}\\0^\infty\;12^a\;2^{4(b-4)/3+c+4}\;\textrm{<}\textrm{C}\;12\;0^\infty\xrightarrow{4(b-4)/3+c+4}0^\infty\;12^a\;\textrm{<}\textrm{C}\;1^{4(b-4)/3+c+5}\;2\;0^\infty\xrightarrow{1}\\0^\infty\;12^{a-1}\;1\;\textrm{<}\textrm{A}\;1^{4(b-4)/3+c+6}\;2\;0^\infty\xrightarrow{4(b-4)/3+c+7}0^\infty\;12^{a-1}\;2^{4(b-4)/3+c+7}\;\textrm{A}\textrm{>}\;2\;0^\infty\xrightarrow{1}\\0^\infty\;12^{a-1}\;2^{4(b-4)/3+c+7}\;\textrm{<}\textrm{C}\;1\;0^\infty\xrightarrow{4(b-4)/3+c+6}0^\infty\;12^{a-1}\;2\;\textrm{<}\textrm{C}\;1^{4(b-4)/3+c+7}\;0^\infty\xrightarrow{1}\\0^\infty\;12^{a-1}\;\textrm{<}\textrm{A}\;1^{4(b-4)/3+c+8}\;0^\infty\xrightarrow{2(a-1)}0^\infty\;\textrm{<}\textrm{A}\;21^{a-1}\;1^{4(b-4)/3+c+8}\;0^\infty\xrightarrow{1}\\0^\infty\;1\;\textrm{B}\textrm{>}\;21^{a-1}\;1^{4(b-4)/3+c+8}\;0^\infty\xrightarrow{2a+4(b-4)/3+c+6}0^\infty\;12^{a-1}\;1^{4(b-4)/3+c+9}\;\textrm{B}\textrm{>}\;0^\infty\xrightarrow{12}\\0^\infty\;12^{a-1}\;1^{4(b-4)/3+c+6}\;\textrm{<}\textrm{A}\;1^4\;0^\infty\\\hline\end{array}</math>This means that if <math>a=0</math>, then Bigfoot will reach the undefined <code>C0</code> transition with the configuration <math>0^\infty\;\textrm{<}\textrm{C}\;1^{(4b-1)/3+c}\;2\;0^\infty</math> in <math display="inline">\frac{2}{3}b^2+\frac{8}{3}b+bc-\frac{10}{3}</math> steps. Otherwise, it will proceed to reach <math display="inline">A'\Big(a-1,\frac{4b+2}{3}+c,4\Big)</math> in <math display="inline">4a+\frac{2}{3}b^2+\frac{20}{3}b+bc+3c+\frac{41}{3}</math> steps.
#If <math>b\equiv6\ (\operatorname{mod}12)</math>, then in <math display="inline">\frac{2}{3}b^2-\frac{16}{3}b+bc-6c+8</math> steps we arrive at <math display="inline">P\Big(6,\frac{4(b-6)}{3}+c\Big)</math>, or <math>0^\infty\;12^a\;111111\;\textrm{<}\textrm{A}\;1^{4(b-6)/3+c}\;0^\infty</math>. What follows is:<math display="block">\begin{array}{|l|}\hline0^\infty\;12^a\;111111\;\textrm{<}\textrm{A}\;1^{4(b-6)/3+c}\;0^\infty\xrightarrow{16b/3+4c-14}0^\infty\;12^a\;11\;\textrm{<}\textrm{C}\;1^{4(b-6)/3+c+5}\;2\;0^\infty\xrightarrow{4}\\0^\infty\;12^a\;\textrm{<}\textrm{A}\;1^{4(b-6)/3+c+7}\;2\;0^\infty\xrightarrow{2a}0^\infty\;\textrm{<}\textrm{A}\;21^a\;1^{4(b-6)/3+c+7}\;2\;0^\infty\xrightarrow{1}\\0^\infty\;1\;\textrm{B}\textrm{>}\;21^a\;1^{4(b-6)/3+c+7}\;2\;0^\infty\xrightarrow{2a+4(b-6)/3+c+8}0^\infty\;12^a\;1^{4(b-6)/3+c+8}\;2\;\textrm{B}\textrm{>}\;0^\infty\xrightarrow{60}\\0^\infty\;12^a\;1^{4(b-6)/3+c+2}\;\textrm{<}\textrm{A}\;1^{10}\;0^\infty\\\hline\end{array}</math>This means that we will reach <math display="inline">A'\Big(a,\frac{4}{3}b+c-6,10\Big)</math> in <math display="inline">4a+\frac{2}{3}b^2+\frac{4}{3}b+bc-c+59</math> steps.
#If <math>b\equiv8\ (\operatorname{mod}12)</math>, then in <math display="inline>\frac{2}{3}b^2-8b+bc-8c+\frac{64}{3}</math> steps we arrive at <math display="inline">P\Big(8,\frac{4(b-8)}{3}+c\Big)</math>, or <math>0^\infty\;12^a\;1^8\;\textrm{<}\textrm{A}\;1^{4(b-8)/3+c}\;0^\infty</math>. What follows is:<math display="block">\begin{array}{|l|}\hline0^\infty\;12^a\;1^8\;\textrm{<}\textrm{A}\;1^{4(b-8)/3+c}\;0^\infty\xrightarrow{(16b-62)/3+4c}0^\infty\;12^a\;11\;\textrm{<}\textrm{A}\;1^{4(b-8)/3+c+7}\;2\;0^\infty\xrightarrow{4(b-8)/3+c+8}\\0^\infty\;12^a\;1\;2^{4(b-8)/3+c+8}\;\textrm{A}\textrm{>}\;2\;0^\infty\xrightarrow{1}0^\infty\;12^a\;1\;2^{4(b-8)/3+c+8}\;\textrm{<}\textrm{C}\;1\;0^\infty\xrightarrow{4(b-8)/3+c+8}\\0^\infty\;12^a\;1\;\textrm{<}\textrm{C}\;1^{4(b-8)/3+c+9}\;0^\infty\xrightarrow{1}0^\infty\;12^a\;\textrm{<}\textrm{A}\;2\;1^{4(b-8)/3+c+9}\;0^\infty\xrightarrow{2a}\\0^\infty\;\textrm{<}\textrm{A}\;21^a\;2\;1^{4(b-8)/3+c+9}\;0^\infty\xrightarrow{1}0^\infty\;1\;\textrm{B}\textrm{>}\;21^a\;2\;1^{4(b-8)/3+c+9}\;0^\infty\xrightarrow{2a+4(b-8)/3+c+10}\\0^\infty\;12^{a+1}\;1^{4(b-8)/3+c+9}\;\textrm{B}\textrm{>}\;0^\infty\xrightarrow{12}0^\infty\;12^{a+1}\;1^{4(b-8)/3+c+6}\;\textrm{<}\textrm{A}\;1^4\;0^\infty\\\hline\end{array}</math>This means that we will reach <math display="inline">A'\Big(a+1,\frac{4b-14}{3}+c,4\Big)</math> in <math display="inline">4a+\frac{2}{3}b^2+\frac{4}{3}b+bc-c+\frac{29}{3}</math> steps.
#If <math>b\equiv10\ (\operatorname{mod}12)</math>, then in <math display="inline">\frac{2}{3}b^2-\frac{32}{3}b+bc-10c+40</math> steps we arrive at <math display="inline">P\Big(10,\frac{4(b-10)}{3}+c\Big)</math>, or <math>0^\infty\;12^a\;1^{10}\;\textrm{<}\textrm{A}\;1^{4(b-10)/3+c}\;0^\infty</math>. What follows is:<math display="block">\begin{array}{|l|}\hline0^\infty\;12^a\;1^{10}\;\textrm{<}\textrm{A}\;1^{4(b- 10)/3+c}\;0^\infty\xrightarrow{8b+6c-37}0^\infty\;12^a\;1\;\textrm{<}\textrm{A}\;1^{4(b- 10)/3+c+11}\;0^\infty\xrightarrow{4(b- 10)/3+c+12}\\0^\infty\;12^a\;2^{4(b- 10)/3+c+12}\;\textrm{A}\textrm{>}\;0^\infty\xrightarrow{4}0^\infty\;12^a\;2^{4(b-10)/3+c+11}\;\textrm{<}\textrm{C}\;122\;0^\infty\xrightarrow{4(b-10)/3+c+10}\\0^\infty\;12^a\;2\;\textrm{<}\textrm{C}\;1^{4(b- 10)/3+c+11}\;22\;0^\infty\xrightarrow{1}0^\infty\;12^a\;\textrm{<}\textrm{A}\;1^{4(b-10)/3+c+12}\;22\;0^\infty\xrightarrow{2a}\\0^\infty\;\textrm{<}\textrm{A}\;12^a\;1^{4(b-10)/3+c+12}\;22\;0^\infty\xrightarrow{1}0^\infty\;1\;\textrm{B}\textrm{>}\;12^a\;1^{4(b-10)/3+c+12}\;22\;0^\infty\xrightarrow{2a+4(b-10)/3+c+14}\\0^\infty\;12^a\;1^{4(b-10)/3+c+13}\;22\;\textrm{B}\textrm{>}\;0^\infty\xrightarrow{18}0^\infty\;12^a\;1^{4(b-10)/3+c+10}\;\textrm{<}\textrm{A}\;1^6\;0^\infty\\\hline\end{array}</math>This means that we will reach <math display="inline">A'\Big(a,\frac{4b-10}{3}+c,6\Big)</math> in <math display="inline">4a+\frac{2}{3}b^2+\frac{4}{3}b+bc-c+23</math> steps.
The information above can be summarized as
<math display="block">A'(a,b,c)\rightarrow\begin{cases}A'\Big(a,\frac{4}{3}b+c-2,4\Big)&\text{if }b\equiv0\pmod{12}\text{ and }\frac{4}{3}b+c\ge2,\\A'\Big(a+1,\frac{4b-14}{3}+c,6\Big)&\text{if }b\equiv2\pmod{12}\text{ and }\frac{4(b-2)}{3}+c\ge2,\\0^\infty\;\textrm{<}\textrm{C}\;1^{(4b-1)/3+c}\;2\;0^\infty&\text{if }b\equiv4\pmod{12}\text{ and }a=0,\\A'\Big(a-1,\frac{4b+2}{3}+c,4\Big)&\text{if }b\equiv4\pmod{12}\text{ and }a>0,\\A'\Big(a,\frac{4}{3}b+c-6,10\Big)&\text{if }b\equiv6\pmod{12},\\A'\Big(a+1,\frac{4b-14}{3}+c,4\Big)&\text{if }b\equiv8\pmod{12},\\A'\Big(a,\frac{4b-10}{3}+c,6\Big)&\text{if }b\equiv10\pmod{12}.\end{cases}</math>
Using the definitions of <math>A'</math> and <math>A</math> to transform these rules produces this:
<math display="block">A(a,b,c)\rightarrow\begin{cases}A\Big(a,\frac{4}{3}b+c-1,2\Big)&\text{if }b\equiv0\pmod{6}\text{ and }\frac{4}{3}b+c\ge1,\\A\Big(a+1,\frac{4b-7}{3}+c,3\Big)&\text{if }b\equiv1\pmod{6}\text{ and }\frac{4(b-1)}{3}+c\ge1,\\0^\infty\;\textrm{<}\textrm{C}\;1^{(8b-1)/3+2c}\;2\;0^\infty&\text{if }b\equiv2\pmod{6}\text{ and }a=0,\\A\Big(a-1,\frac{4b+1}{3}+c,2\Big)&\text{if }b\equiv2\pmod{6}\text{ and }a>0,\\A\Big(a,\frac{4}{3}b+c-3,5\Big)&\text{if }b\equiv3\pmod{6},\\A\Big(a+1,\frac{4b-7}{3}+c,2\Big)&\text{if }b\equiv4\pmod{6},\\A\Big(a,\frac{4b-5}{3}+c,3\Big)&\text{if }b\equiv5\pmod{6}.\end{cases}</math>
Substituting <math>b\leftarrow6b+k</math> where <math>k</math> is the remainder for each case yields the final result.
</div></div>
Using the floor function, it is possible to describe the behaviour of <math>b</math> and <math>c</math> using a function that is not defined piecewise:
<math display="block">\textstyle\begin{array}{c}f(m,n)=\Big(\frac{4m-3-4(\delta_1(m)-\delta_2(m)+\delta_4(m))-2(3\delta_3(m)+\delta_5(m))}{3}+n,2+\delta_1(m)+3\delta_3(m)+\delta_5(m)\Big),\\\delta_i(m)=\Big\lfloor\frac{m-i}{6}\Big\rfloor-\Big\lfloor\frac{m-i-1}{6}\Big\rfloor=\begin{cases}1&\text{if }m\equiv i\pmod{6},\\0&\text{otherwise.}\end{cases}\end{array}</math>
In effect, the halting problem for Bigfoot is about whether through enough iterations of <math>f(m,n)</math> we encounter more <math>m</math> values that are congruent to 2 modulo 6 than ones that are congruent to 1 or 4 modulo 6.

An important insight is that if <math>b</math> is odd and <math>c=2</math>, then after four iterations of <math>A</math>, that will remain the case. This allows one to define a configuration that eliminates the <math>c</math> parameter and whose rules use a modulus of 81.<ref name="b"></ref>

== Trajectory ==
After 69 steps, Bigfoot will reach the configuration <math>A(2,1,2)</math> before the [[Collatz-like]] rules are repeatedly applied. Simulations of Bigfoot have shown that after 24000000 rule steps, we have <math>a=3999888</math>. Here are the first few:
<math display="block">\begin{array}{|l|}\hline A(2,1,2)\xrightarrow{49}A(3,1,3)\xrightarrow{59}A(4,2,3)\xrightarrow{109}A(3,6,2)\xrightarrow{221}A(3,9,2)\xrightarrow{379}A(3,11,5)\xrightarrow{597}A(3,18,3)\rightarrow\cdots\\\hline\end{array}</math>
There exists a heuristic argument for Bigfoot being [[probviously]] non-halting. By only considering the rules for which <math>a</math> changes, one may notice that the trajectory of <math>a</math> values can be approximated by a random walk in which at each step, the walker moves +1 with probability <math display="inline">\frac{2}{3}</math> or moves -1 with probability <math display="inline">\frac{1}{3}</math>, starting at position 2. If <math>P(n)</math> is the probability that the walker will reach position -1 from position <math>n</math>, then <math display="inline">P(n)=\frac{1}{3}P(n-1)+\frac{2}{3}P(n+1)</math>. Solutions to this recurrence relation come in the form <math display="inline"> P(n)=c_02^{-n}+c_1</math>, which after applying the appropriate boundary conditions reduces to <math display="inline">P(n)=2^{-(n+1)}</math>. As a result, if the walker gets to position 3999888, then the probability of it ever reaching position -1 would be <math display="inline">2^{-3999889}\approx 2.697\times 10^{-1204087}</math>.
==References==
<references/>
[[Category:BB(3,3)]][[Category:Cryptids]]

Antihydra

2025-10-07T22:01:59Z

MrSolis: :(

{{machine|1RB1RA_0LC1LE_1LD1LC_1LA0LB_1LF1RE_---0RA}}{{unsolved|Does Antihydra run forever?}}
{{TM|1RB1RA_0LC1LE_1LD1LC_1LA0LB_1LF1RE_---0RA|undecided}}, called '''Antihydra''', is a [[BB(6)]] [[Cryptid]]. Its pseudo-random behaviour was first reported [https://discord.com/channels/960643023006490684/1026577255754903572/1256223215206924318 on Discord] by mxdys on 28 June 2024, and Racheline discovered the high-level rules soon after. It was named after the 2-state, 5-symbol [[Turing machine]] called [[Hydra]] for sharing many similarities to it.<ref>[https://discord.com/channels/960643023006490684/960643023530762341/1257053002859286701 Discord conversation where the machine was named]</ref>

Antihydra is known to not generate Sturmian words<ref>DUBICKAS A. ON INTEGER SEQUENCES GENERATED BY LINEAR MAPS. ''Glasgow Mathematical Journal''. 2009;51(2):243-252. doi:[https://doi.org/10.1017/S0017089508004655 10.1017/S0017089508004655]</ref> (Corollary 4).
<table style="margin: auto; text-align: center;"><tr><td style="width: 200px;">[[File:Antihydra-depiction.png|200px]]<br>Artistic depiction of Antihydra by Jadeix</td><td>      </td><td>
{|class="wikitable" style="margin-left: auto; margin-right: auto;"
! !!0!!1
|-
!A
|1RB
|1RA
|-
!B
|0LC
|1LE
|-
!C
|1LD
|1LC
|-
!D
|1LA
|0LB
|-
!E
|1LF
|1RE
|-
!F
| ---
|0RA
|}
The transition table of Antihydra.
</td><td>      </td><td>[[File:Antihydra_state_diagram.png|200x200px]]
State diagram of Antihydra
</td><td>      </td><td style="width: 220px;">[[File:Antihydra award.jpg|220px]]<br>A community trophy - to be awarded to the first person or group who solves the Antihydra problem
</td></tr></table>
== Analysis ==
Let <math>A(a,b):=0^\infty\;1^a\;0\;1^b\;\textrm{E}\textrm{>}\;0^\infty</math>. Then,<ref name="bl">S. Ligocki, "[https://www.sligocki.com/2024/07/06/bb-6-2-is-hard.html BB(6) is Hard (Antihydra)]" (2024). Accessed 22 July 2024.</ref>
<math display="block">\begin{array}{|lll|}\hline
A(a,2b)& \xrightarrow{2a+3b^2+12b+11}& A(a+2,3b+2),\\
A(0,2b+1)&\xrightarrow{3b^2+9b-1}& 0^\infty\;\textrm{<}\textrm{F}\;110\;1^{3b}\;0^\infty,\\
A(a+1,2b+1)&\xrightarrow{3b^2+12b+5}& A(a,3b+3).\\\hline
\end{array}</math>
<div class="toccolours mw-collapsible mw-collapsed">'''Proof'''<div class="mw-collapsible-content">
Consider the partial configuration <math>P(m,n):=0\;1^m\;\textrm{E}\textrm{>}\;0\;1^n\;0^\infty</math>. The configuration after two steps is <math>0\;1^{m-1}\;0\;\textrm{A}\textrm{>}\;1^{n+1}\;0^\infty</math>. We note the following shift rule:
<math display="block">\begin{array}{|c|}\hline\textrm{A}\textrm{>}\;1^s\xrightarrow{s}1^s\;\textrm{A}\textrm{>}\\\hline\end{array}</math>
As a result, we get <math>0\;1^{m-1}\;0\;1^{n+1}\;\textrm{A}\textrm{>}\;0^\infty</math> after <math>n+1</math> steps. Advancing two steps produces <math>0\;1^{m-1}\;0\;1^{n+2}\;\textrm{<}\textrm{C}\;0^\infty</math>. A second shift rule is useful here:
<math display="block">\begin{array}{|c|}\hline1^s\;\textrm{<}\textrm{C}\xrightarrow{s}\textrm{<}\textrm{C}\;1^s\\\hline\end{array}</math>
This allows us to reach <math>0\;1^{m-1}\;0\;\textrm{<}\textrm{C}\;1^{n+2}\;0^\infty</math> in <math>n+2</math> steps. Moving five more steps gets us to <math>0\;1^{m-2}\;\textrm{E}\textrm{>}\;0\;1^{n+3}\;0^\infty</math>, which is the same configuration as <math>P(m-2,n+3)</math>. Accounting for the head movement creates the condition that <math>m\ge 4</math>. In summary:
<math display="block">\begin{array}{|c|}\hline P(m,n)\xrightarrow{2n+12}P(m-2,n+3)\text{ if }m\ge 4.\\\hline\end{array}</math>
With <math>A(a,b)</math> we have <math>P(b,0)</math>. As a result, we can apply this rule <math display="inline>\big\lfloor\frac{1}{2}b\big\rfloor-1</math> times (assuming <math>b\ge 4</math>), which creates two possible scenarios:
#If <math>b\equiv0\ (\operatorname{mod}2)</math>, then in <math>\sum_{i=0}^{(b/2)-2}(2\times 3i+12)=\textstyle\frac{3}{4}b^2+\frac{3}{2}b-6</math> steps we arrive at <math display="inline">P\Big(2,\frac{3}{2}b-3\Big)</math>. The matching complete configuration is <math>0^\infty\;1^a\;011\;\textrm{E}\textrm{>}\;0\;1^{(3b)/2-3}\;0^\infty</math>. After <math>3b+4</math> steps this is <math>0^\infty\;1^a\;\textrm{<}\textrm{C}\;00\;1^{(3b)/2}\;0^\infty</math>, which then leads to <math>0^\infty\;\textrm{<}\textrm{C}\;1^a\;00\;1^{(3b)/2}\;0^\infty</math> in <math>a</math> steps. After five more steps, we reach <math>0^\infty\;1\;\textrm{E}\textrm{>}\;1^{a+2}\;00\;1^{(3b)/2}\;0^\infty</math>, from which another shift rule must be applied:<math display="block">\begin{array}{|c|}\hline\textrm{E}\textrm{>}\;1^s\xrightarrow{s}1^s\;\textrm{E}\textrm{>}\\\hline\end{array}</math>Doing so allows us to get the configuration <math>0^\infty\;1^{a+3}\;\textrm{E}\textrm{>}\;00\;1^{(3b)/2}\;0^\infty</math> in <math>a+2</math> steps. In six steps we have <math>0^\infty\;1^{a+2}\;011\;\textrm{E}\textrm{>}\;1^{(3b)/2}\;0^\infty</math>, so we use the shift rule again, ending at <math>0^\infty\;1^{a+2}\;0\;1^{(3b)/2+2}\;\textrm{E}\textrm{>}\;0^\infty</math>, equal to <math display="inline">A\Big(a+2,\frac{3}{2}b+2\Big)</math>, <math display="inline">\frac{3}{2}b</math> steps later. This gives a total of <math display="inline">2a+\frac{3}{4}b^2+6b+11</math> steps.
#If <math>b\equiv1\ (\operatorname{mod}2)</math>, then in <math display="inline">\frac{3}{4}b^2-\frac{27}{4}</math> steps we arrive at <math display="inline">P\Big(3,\frac{3b-9}{2}\Big)</math>. The matching complete configuration is <math>0^\infty\;1^a\;0111\;\textrm{E}\textrm{>}\;0\;1^{(3b-9)/2}\;0^\infty</math>. After <math>3b+2</math> steps this becomes <math>0^\infty\;1^a\;\textrm{<}\textrm{F}\;110\;1^{(3b-3)/2}\;0^\infty</math>. If <math>a=0</math> then we have reached the undefined <code>F0</code> transition with a total of <math display="inline">\frac{3}{4}b^2+3b-\frac{19}{4}</math> steps. Otherwise, continuing for six steps gives us <math>0^\infty\;1^{a-1}\;0111\;\textrm{E}\textrm{>}\;1^{(3b-3)/2}\;0^\infty</math>. We conclude with the configuration <math>0^\infty\;1^{a-1}\;0\;1^{(3b+3)/2}\;\textrm{E}\textrm{>}\;0^\infty</math>, equal to <math display="inline">A\Big(a-1,\frac{3b+3}{2}\Big)</math>, in <math display="inline">\frac{3b-3}{2}</math> steps. This gives a total of <math display="inline">\frac{3}{4}b^2+\frac{9}{2}b-\frac{1}{4}</math> steps.
The information above can be summarized as
<math display="block">A(a,b)\rightarrow\begin{cases}A\Big(a+2,\frac{3}{2}b+2\Big)&\text{if }b\ge 2,b\equiv0\pmod{2};\\0^\infty\;\textrm{<}\textrm{F}\;110\;1^{(3b-3)/2}\;0^\infty&\text{if }b\ge3,b\equiv1\pmod{2},\text{ and }a=0;\\A\Big(a-1,\frac{3b+3}{2}\Big)&\text{if }b\ge3,b\equiv1\pmod{2},\text{ and }a>0.\end{cases}</math>
Substituting <math>b\leftarrow 2b</math> for the first case and <math>b\leftarrow 2b+1</math> for the other two yields the final result.
</div></div>
In effect, the halting problem for Antihydra is about whether repeatedly applying the function <math display="inline">f(n)=\Big\lfloor\frac{3n}{2}\Big\rfloor+2</math> will at some point produce more odd values of <math>n</math> than twice the number of even values.

These rules can be modified to use the function <math display="inline">H(n)=\Big\lfloor\frac{3n}{2}\Big\rfloor</math>, or the [[Hydra function]], which strengthens Antihydra's similarities to Hydra.
== Trajectory ==
[[File:Antihydra Walk.png|thumb|Path of parity of repeated applications of Hydra map for Antihydra.]]
Starting from a blank tape, Antihydra reaches <math>A(0, 4)</math> in 11 steps and then the rules are repeatedly applied. So far, Antihydra has been simulated to <math>2^{38}</math> rule steps,<ref>https://discord.com/channels/960643023006490684/1026577255754903572/1271528180246773883</ref> at which point <math>a</math> exceeds <math>2^{37}</math>. Here are the first few:
<math display="block">\begin{array}{|c|}\hline A(0,4)\xrightarrow{47}A(2,8)\xrightarrow{111}A(4,14)\xrightarrow{250}A(6,23)\xrightarrow{500}A(5,36)\xrightarrow{1209}A(7,56)\xrightarrow{2713}A(9,86)\rightarrow\cdots\\\hline\end{array}</math>
The trajectory of <math>a</math> values resembles a random walk in which the walker can only move in step sizes +2 or -1 with equal probability, starting at position 0. If <math>P(n)</math> is the probability that the walker will reach position -1 from position <math>n</math>, then it can be seen that <math display="inline">P(n)=\frac{1}{2}P(n-1)+\frac{1}{2}P(n+2)</math>. Solutions to this recurrence relation come in the form <math display="inline"> P(n)=c_0{\left(\frac{\sqrt{5}-1}{2}\right)}^n+c_1+c_2{\left(-\frac{1+\sqrt{5}}{2}\right)}^n</math>, which after applying the appropriate boundary conditions reduces to <math display="inline">P(n)={\left(\frac{\sqrt{5}-1}{2}\right)}^{n+1}</math>. This means that if the walker were to get to the position of the current <math>a</math> value, then the probability of it ever reaching position -1 is less than <math display="inline">{\left( \frac{\sqrt{5}-1}{2} \right)}^{2^{37}}\approx 2.884\times 10^{-28723042565}</math>. This combined with the fact that the expected position of the walker after <math>k</math> steps is <math display="inline">\frac{1}{2}k</math> strongly suggests Antihydra [[probviously]] runs indefinitely.

== Code ==
The following Python program implements the abstracted behavior of the Antihydra. Proving whether it halts or not would also solve the Antihydra problem:<syntaxhighlight lang="python" line="1">
# Current value of the iterated Hydra function starting with initial value 8 (the values do not overflow)
h = 8
# (Collatz-like) condition counter that keeps track of how many odd and even numbers have been encountered
c = 0
# If c equals -1 there have been (strictly) more than twice as many odd as even numbers and the program halts
while c != -1:
# If h is even, add 2 to c so even numbers count twice
if h % 2 == 0:
c += 2
else:
c -= 1
# Add the current hydra value divided by two (integer division, rounding down) to itself (Hydra function)
# Note that integer division by 2 is equivalent to one bit shift to the right (h >> 1)
h += h//2
</syntaxhighlight>

The variable values of this iteration have been put into the On-Line Encyclopedia of Integer Sequences (OEIS):

* Hydra function values with Antihydra's starting value 8: https://oeis.org/A386792
* Antihydra's condition values: https://oeis.org/A385902

Fast [[Hydra]]/Antihydra simulation code by Greg Kuperberg (who said it could be made faster using FLINT):<syntaxhighlight lang="python2" line="1">
# Python script to demonstrate almost linear time hydra simulation
# using fast multiplication.
# by Greg Kuperberg

import time
from gmpy2 import mpz,bit_mask

# Straight computation of t steps of hydra
def simple(n,t):
for s in range(t): n += n>>1
return n

# Accelerated computation of 2**e steps of hydra
def hydra(n,e):
if e < 9: return simple(n,1<<e)
t = 1<<(e-1)
(p3t,m) = (mpz(3)**t,bit_mask(t))
n = p3t*(n>>t) + hydra(n&m,e-1)
return p3t*(n>>t) + hydra(n&m,e-1)

def elapsed():
(last,elapsed.mark) = (elapsed.mark,time.process_time())
return elapsed.mark-last
elapsed.mark = 0

(n,e) = (mpz(3),25)

elapsed()
print('hydra: steps=%d hash=%016x time=%.6fs'
% (1<<e,hash(hydra(n,e)),elapsed()))

# Quadratic time algorithm for comparison
# print('simple: steps=%d hash=%016x time=%.6fs'
# % (1<<e,hash(simple(n,1<<e)),elapsed()))
</syntaxhighlight>

==References==

[[Category:BB(6)]][[Category:Cryptids]]

5-state busy beaver winner

2025-10-07T21:55:10Z

MrSolis: :(

{{machine|1RB1LC_1RC1RB_1RD0LE_1LA1LD_1RZ0LA}}
The '''5-state busy beaver winner''' is the [[Turing machine]] whose step count determines [[BB(5)]]. Up to permutations, that machine is {{TM|1RB1LC_1RC1RB_1RD0LE_1LA1LD_1RZ0LA|halt}}, which halts after 47176870 steps with 4098 ones on the tape. It was first reported on by Heiner Marxen and Jürgen Buntrock in February 1990,<ref>H. Marxen and J. Buntrock. Attacking the Busy Beaver 5. Bulletin of the EATCS, 40, pages 247-251, February 1990. https://turbotm.de/~heiner/BB/mabu90.html</ref> and the high-level rules were first demonstrated by Michael Buro in November 1990.<ref>Buro, Michael (November 1990). "Ein Beitrag zur Bestimmung von Rados <math>\Sigma(5)</math> - oder - Wie fängt man fleißige Biber?" [A contribution to the determination of Rado's <math>\Sigma(5)</math> - or - How to catch busy beavers?]. ''Schriften zur Informatik und angewandten Mathematik'' (Report No. 146). Rheinisch-Westfälische Technische Hochschule Aachen. https://skatgame.net/mburo/ps/diploma.pdf</ref>
<div style="width: fit-content; text-align: center; margin-left: auto; margin-right: auto;">
{|class="wikitable" style="margin-left: auto; margin-right: auto;"
! !!0!!1
|-
!A
|1RB
|1LC
|-
!B
|1RC
|1RB
|-
!C
|1RD
|0LE
|-
!D
|1LA
|1LD
|-
!E
|1RZ
|0LA
|}
The transition table of the 5-state busy beaver winner.</div>
== Analysis ==
Let <math>g(x):=0^\infty\;\textrm{<}\textrm{A}\,1^x\;0^\infty</math>. Then,<ref>Pascal Michel. Behavior of busy beavers. https://bbchallenge.org/~pascal.michel/beh#tm52a</ref>
<math display="block">\begin{array}{|lll|}\hline
g(3x)&\xrightarrow{5x^2+19x+15}&g(5x+6),\\
g(3x+1)&\xrightarrow{5x^2+25x+27}&g(5x+9),\\
g(3x+2)&\xrightarrow{6x+12}&0^\infty\;1\;\textrm{Z}\textrm{>}\;01\;001^{x+1}\;1\;0^\infty.\\\hline
\end{array}</math>
<div class="toccolours mw-collapsible mw-collapsed">'''Proof'''<div class="mw-collapsible-content">
Consider the configuration <math>C(m,n):=0^\infty\;\textrm{<}\textrm{A}\;1^m\;001^n\;1\;0^\infty</math>. After one step this configuration becomes <math>0^\infty\;1\;\textrm{B}\textrm{>}\;1^m\;001^n\;1\;0^\infty</math>. We note the following shift rule:
<math display="block">\begin{array}{|c|}\hline\textrm{B}\textrm{>}\;1^a\xrightarrow{a}1^a\;\textrm{B}\textrm{>}\\\hline\end{array}</math>
Using this shift rule, we get <math>0^\infty\;1^{m+1}\;\textrm{B}\textrm{>}\;001^n\;1\;0^\infty</math> after <math>m</math> steps. If <math>n=0</math>, then we get <math>0^\infty\;1^{m+4}\;\textrm{<}\textrm{A}\;1\;0^\infty</math> four steps later. Another shift rule is needed here:
<math display="block">\begin{array}{|c|}\hline1^{3a}\;\textrm{<}\textrm{A}\xrightarrow{3a}\textrm{<}\textrm{A}\;001^a\\\hline\end{array}</math>
In this instance, <math display="inline">\Big\lfloor\frac{m+4}{3}\Big\rfloor</math> is substituted for <math>a</math>, which creates three different scenarios depending on the value of <math>m</math> modulo 3. They are as follows:
# If <math>m+4\equiv0\ (\operatorname{mod}3)</math>, then in <math>m+4</math> steps we arrive at <math>0^\infty\;\textrm{<}\textrm{A}\;001^{(m+4)/3}\;1\;0^\infty</math>, which is the same configuration as <math display="inline">C\Big(0,\frac{m+4}{3}\Big)</math>.
# If <math>m+4\equiv1\ (\operatorname{mod}3)</math>, then in <math>m+3</math> steps we arrive at <math>0^\infty\;1\;\textrm{<}\textrm{A}\;001^{(m+3)/3}\;1\;0^\infty</math>, which in five steps becomes <math>0^\infty\;\textrm{<}\textrm{A}\;111\;001^{(m+3)/3}\;1\;0^\infty</math>, equal to <math display="inline">C\Big(3,\frac{m+3}{3}\Big)</math>.
# If <math>m+4\equiv2\ (\operatorname{mod}3)</math>, then in <math>m+2</math> steps we arrive at <math>0^\infty\;11\;\textrm{<}\textrm{A}\;001^{(m+2)/3}\;1\;0^\infty</math>, which in three steps halts with the configuration <math>0^\infty\;1\;\textrm{Z}\textrm{>}\;01\;001^{(m+2)/3}\;1\;0^\infty</math>, for a total of <math>2m+10</math> steps from <math>C(m,0)</math>.
Returning to <math>0^\infty\;1^{m+1}\;\textrm{B}\textrm{>}\;001^n\;1\;0^\infty</math>, if <math>n\ge 1</math>, then in three steps it changes into <math>0^\infty\;1^{m+3}\;\textrm{<}\textrm{D}\;1\;001^{n-1}\;1\;0^\infty</math>. Here we can make use of one more shift rule:
<math display="block">\begin{array}{|c|}\hline1^a\;\textrm{<}\textrm{D}\xrightarrow{a}\textrm{<}\textrm{D}\;1^a\\\hline\end{array}</math>
Doing so takes us to <math>0^\infty\;\textrm{<}\textrm{D}\;1^{m+4}\;001^{n-1}\;1\;0^\infty</math> in <math>m+3</math> steps, which after one step becomes the configuration <math>0^\infty\;\textrm{<}\textrm{A}\;1^{m+5}\;001^{n-1}\;1\;0^\infty</math>, equal to <math>C(m+5,n-1)</math>. To summarize:
<math display="block">\begin{array}{|c|}\hline C(m,n)\xrightarrow{2m+8}C(m+5,n-1)\text{ if }n\ge 1.\\\hline\end{array}</math>
We have <math>g(x)=C(x-1,0)</math>. As a result, if <math>x\equiv0\ (\operatorname{mod}3)</math>, we then get <math display="inline">C\Big(0,\frac{1}{3}x+1\Big)</math> and the above rule is applied until we reach <math display="inline">C\Big(\frac{5}{3}x+5,0\Big)</math>, equal to <math display="inline">g\Big(\frac{5}{3}x+6\Big)</math>, in <math>\sum_{i=0}^{x/3}(2\times 5i+8)=\textstyle\frac{5}{9}x^2+\frac{13}{3}x+8</math> steps for a total of <math display="inline">\frac{5}{9}x^2+\frac{19}{3}x+15</math> steps from <math>g(x)</math> (with <math>g(0)</math> we see the impossible configuration <math>C(-1,0)</math>, but it reaches <math>g(6)</math> in 15 steps regardless). However, if <math>x\equiv1\ (\operatorname{mod}3)</math>, we then get <math display="inline">C\Big(3,\frac{x+2}{3}\Big)</math> which reaches <math display="inline">C\Big(3+\frac{5(x+2)}{3},0\Big)</math>, equal to <math display="inline">g\Big(\frac{5x+22}{3}\Big)</math>, in <math display="inline">\frac{5}{9}x^2+\frac{47}{9}x+\frac{74}{9}</math> steps (<math display="inline">\frac{5}{9}x^2+\frac{65}{9}x+\frac{173}{9}</math> steps total).

The information above can be summarized as<ref>Aaronson, S. (2020). The Busy Beaver Frontier. Page 10-11. https://www.scottaaronson.com/papers/bb.pdf</ref>
<math display="block">g(x)\rightarrow\begin{cases}g\Big(\frac{5}{3}x+6\Big)&\text{if }x\equiv0\pmod{3},\\g\Big(\frac{5x+22}{3}\Big)&\text{if }x\equiv1\pmod{3},\\0^\infty\;1\;\textrm{Z}\textrm{>}\;01\;001^{(x+1)/3}\;1\;0^\infty&\text{if }x\equiv2\pmod{3}.\end{cases}</math>
Substituting <math>x\leftarrow 3x</math>, <math>x\leftarrow 3x+1</math>, and <math>x\leftarrow 3x+2</math> to each of these cases respectively gives us our final result.
</div></div>
In effect, the halting problem for the 5-state busy beaver winner is about whether repeatedly applying the function <math display="inline">f(n)=3n+6-4\Big\lfloor\frac{n}{3}\Big\rfloor</math> eventually produces a value of <math>n</math> that is congruent to 2 modulo 3.
== Trajectory ==
The initial blank tape represents <math>g(0)</math>, and the [[Collatz-like]] rules are iterated 15 times before halting:
<math display="block">\begin{array}{|l|}\hline\begin{array}{lllllllllllllll}
g(0)&\xrightarrow{15}&g(6)&\xrightarrow{73} &g(16)&\xrightarrow{277}&g(34)&\xrightarrow{907}&g(64)&\xrightarrow{2757}\\
g(114)&\xrightarrow{7957}&g(196)&\xrightarrow{22777}&g(334)&\xrightarrow{64407}&g(564)&\xrightarrow{180307}&g(946)&\xrightarrow{504027}\\
g(1584)&\xrightarrow{1403967}&g(2646)&\xrightarrow{3906393}&g(4416)&\xrightarrow{10861903}&g(7366)&\xrightarrow{30196527}&g(12284)&\xrightarrow{24576}\end{array}\\0^\infty\;1\;\textrm{Z}\textrm{>}\;01\;001^{4095}\;1\;0^\infty\\\hline\end{array}</math>
== References ==
<references/>
[[Category:BB(5)]]

Antihydra

2025-08-21T03:06:10Z

MrSolis: /* Trajectory */

{{machine|1RB1RA_0LC1LE_1LD1LC_1LA0LB_1LF1RE_---0RA}}{{unsolved|Does Antihydra run forever?}}
{{TM|1RB1RA_0LC1LE_1LD1LC_1LA0LB_1LF1RE_---0RA|undecided}}, called '''Antihydra''', is a [[BB(6)]] [[Cryptid]]. Its pseudo-random behaviour was first reported [https://discord.com/channels/960643023006490684/1026577255754903572/1256223215206924318 on Discord] by mxdys on 28 June 2024, and Racheline discovered the high-level rules soon after. It was named after the 2-state, 5-symbol [[Turing machine]] called [[Hydra]] for sharing many similarities to it.<ref>[https://discord.com/channels/960643023006490684/960643023530762341/1257053002859286701 Discord conversation where the machine was named]</ref>

Antihydra is known to not generate Sturmian words<ref>DUBICKAS A. ON INTEGER SEQUENCES GENERATED BY LINEAR MAPS. ''Glasgow Mathematical Journal''. 2009;51(2):243-252. doi:[https://doi.org/10.1017/S0017089508004655 10.1017/S0017089508004655]</ref> (Corollary 4).
<table style="margin: auto; text-align: center;"><tr><td style="width: 200px;">[[File:Antihydra-depiction.png|200px]]<br>Artistic depiction of Antihydra by Jadeix</td><td>      </td><td>
{|class="wikitable" style="margin-left: auto; margin-right: auto;"
! !!0!!1
|-
!A
|1RB
|1RA
|-
!B
|0LC
|1LE
|-
!C
|1LD
|1LC
|-
!D
|1LA
|0LB
|-
!E
|1LF
|1RE
|-
!F
| ---
|0RA
|}
The transition table of Antihydra.
</td><td>      </td><td style="width: 220px;">[[File:Antihydra award.jpg|220px]]<br>A community trophy - to be awarded to the first person or group who solves the Antihydra problem
</td></tr></table></div>
== Analysis ==
Let <math>A(a,b):=0^\infty\;1^a\;0\;1^b\;\textrm{E>}\;0^\infty</math>. Then,<ref name="bl">S. Ligocki, "[https://www.sligocki.com/2024/07/06/bb-6-2-is-hard.html BB(6) is Hard (Antihydra)]" (2024). Accessed 22 July 2024.</ref>
<math display="block">\begin{array}{|lll|}\hline
A(a,2b)& \xrightarrow{2a+3b^2+12b+11}& A(a+2,3b+2),\\
A(0,2b+1)&\xrightarrow{3b^2+9b-1}& 0^\infty\;\textrm{<F}\;110\;1^{3b}\;0^\infty,\\
A(a+1,2b+1)&\xrightarrow{3b^2+12b+5}& A(a,3b+3).\\\hline
\end{array}</math>
<div class="toccolours mw-collapsible mw-collapsed">'''Proof'''<div class="mw-collapsible-content">
Consider the partial configuration <math>P(m,n):=0\;1^m\;\textrm{E>}\;0\;1^n\;0^\infty</math>. The configuration after two steps is <math>0\;1^{m-1}\;0\;\textrm{A>}\;1^{n+1}\;0^\infty</math>. We note the following shift rule:
<math display="block">\begin{array}{|c|}\hline\textrm{A>}\;1^s\xrightarrow{s}1^s\;\textrm{A>}\\\hline\end{array}</math>
As a result, we get <math>0\;1^{m-1}\;0\;1^{n+1}\;\textrm{A>}\;0^\infty</math> after <math>n+1</math> steps. Advancing two steps produces <math>0\;1^{m-1}\;0\;1^{n+2}\;\textrm{<C}\;0^\infty</math>. A second shift rule is useful here:
<math display="block">\begin{array}{|c|}\hline1^s\;\textrm{<C}\xrightarrow{s}\textrm{<C}\;1^s\\\hline\end{array}</math>
This allows us to reach <math>0\;1^{m-1}\;0\;\textrm{<C}\;1^{n+2}\;0^\infty</math> in <math>n+2</math> steps. Moving five more steps gets us to <math>0\;1^{m-2}\;\textrm{E>}\;0\;1^{n+3}\;0^\infty</math>, which is the same configuration as <math>P(m-2,n+3)</math>. Accounting for the head movement creates the condition that <math>m\ge 4</math>. In summary:
<math display="block">\begin{array}{|c|}\hline P(m,n)\xrightarrow{2n+12}P(m-2,n+3)\text{ if }m\ge 4.\\\hline\end{array}</math>
With <math>A(a,b)</math> we have <math>P(b,0)</math>. As a result, we can apply this rule <math display="inline>\big\lfloor\frac{1}{2}b\big\rfloor-1</math> times (assuming <math>b\ge 4</math>), which creates two possible scenarios:
#If <math>b\equiv0\ (\operatorname{mod}2)</math>, then in <math>\sum_{i=0}^{(b/2)-2}(2\times 3i+12)=\textstyle\frac{3}{4}b^2+\frac{3}{2}b-6</math> steps we arrive at <math display="inline">P\Big(2,\frac{3}{2}b-3\Big)</math>. The matching complete configuration is <math>0^\infty\;1^a\;011\;\textrm{E>}\;0\;1^{(3b)/2-3}\;0^\infty</math>. After <math>3b+4</math> steps this is <math>0^\infty\;1^a\;\textrm{<C}\;00\;1^{(3b)/2}\;0^\infty</math>, which then leads to <math>0^\infty\;\textrm{<C}\;1^a\;00\;1^{(3b)/2}\;0^\infty</math> in <math>a</math> steps. After five more steps, we reach <math>0^\infty\;1\;\textrm{E>}\;1^{a+2}\;00\;1^{(3b)/2}\;0^\infty</math>, from which another shift rule must be applied:<math display="block">\begin{array}{|c|}\hline\textrm{E>}\;1^s\xrightarrow{s}1^s\;\textrm{E>}\\\hline\end{array}</math>Doing so allows us to get the configuration <math>0^\infty\;1^{a+3}\;\textrm{E>}\;00\;1^{(3b)/2}\;0^\infty</math> in <math>a+2</math> steps. In six steps we have <math>0^\infty\;1^{a+2}\;011\;\textrm{E>}\;1^{(3b)/2}\;0^\infty</math>, so we use the shift rule again, ending at <math>0^\infty\;1^{a+2}\;0\;1^{(3b)/2+2}\;\textrm{E>}\;0^\infty</math>, equal to <math display="inline">A\Big(a+2,\frac{3}{2}b+2\Big)</math>, <math display="inline">\frac{3}{2}b</math> steps later. This gives a total of <math display="inline">2a+\frac{3}{4}b^2+6b+11</math> steps.
#If <math>b\equiv1\ (\operatorname{mod}2)</math>, then in <math display="inline">\frac{3}{4}b^2-\frac{27}{4}</math> steps we arrive at <math display="inline">P\Big(3,\frac{3b-9}{2}\Big)</math>. The matching complete configuration is <math>0^\infty\;1^a\;0111\;\textrm{E>}\;0\;1^{(3b-9)/2}\;0^\infty</math>. After <math>3b+2</math> steps this becomes <math>0^\infty\;1^a\;\textrm{<F}\;110\;1^{(3b-3)/2}\;0^\infty</math>. If <math>a=0</math> then we have reached the undefined <code>F0</code> transition with a total of <math display="inline">\frac{3}{4}b^2+3b-\frac{19}{4}</math> steps. Otherwise, continuing for six steps gives us <math>0^\infty\;1^{a-1}\;0111\;\textrm{E>}\;1^{(3b-3)/2}\;0^\infty</math>. We conclude with the configuration <math>0^\infty\;1^{a-1}\;0\;1^{(3b+3)/2}\;\textrm{E>}\;0^\infty</math>, equal to <math display="inline">A\Big(a-1,\frac{3b+3}{2}\Big)</math>, in <math display="inline">\frac{3b-3}{2}</math> steps. This gives a total of <math display="inline">\frac{3}{4}b^2+\frac{9}{2}b-\frac{1}{4}</math> steps.
The information above can be summarized as
<math display="block">A(a,b)\rightarrow\begin{cases}A\Big(a+2,\frac{3}{2}b+2\Big)&\text{if }b\ge 2,b\equiv0\pmod{2};\\0^\infty\;\textrm{<F}\;110\;1^{(3b-3)/2}\;0^\infty&\text{if }b\ge3,b\equiv1\pmod{2},\text{ and }a=0;\\A\Big(a-1,\frac{3b+3}{2}\Big)&\text{if }b\ge3,b\equiv1\pmod{2},\text{ and }a>0.\end{cases}</math>
Substituting <math>b\leftarrow 2b</math> for the first case and <math>b\leftarrow 2b+1</math> for the other two yields the final result.
</div></div>
In effect, the halting problem for Antihydra is about whether repeatedly applying the function <math display="inline">f(n)=\Big\lfloor\frac{3n}{2}\Big\rfloor+2</math> will at some point produce more odd values of <math>n</math> than twice the number of even values.

These rules can be modified to use the function <math display="inline">H(n)=\Big\lfloor\frac{3n}{2}\Big\rfloor</math>, or the [[Hydra function]], which strengthens Antihydra's similarities to Hydra.
== Trajectory ==
[[File:Antihydra Walk.png|thumb|Path of parity of repeated applications of Hydra map for Antihydra.]]
Starting from a blank tape, Antihydra reaches <math>A(0, 4)</math> in 11 steps and then the rules are repeatedly applied. So far, Antihydra has been simulated to <math>2^{38}</math> rule steps,<ref>https://discord.com/channels/960643023006490684/1026577255754903572/1271528180246773883</ref> at which point <math>a</math> exceeds <math>2^{37}</math>. Here are the first few:
<math display="block">\begin{array}{|c|}\hline A(0,4)\xrightarrow{47}A(2,8)\xrightarrow{111}A(4,14)\xrightarrow{250}A(6,23)\xrightarrow{500}A(5,36)\xrightarrow{1209}A(7,56)\xrightarrow{2713}A(9,86)\rightarrow\cdots\\\hline\end{array}</math>
The trajectory of <math>a</math> values resembles a random walk in which the walker can only move in step sizes +2 or -1 with equal probability, starting at position 0. If <math>P(n)</math> is the probability that the walker will reach position -1 from position <math>n</math>, then it can be seen that <math display="inline">P(n)=\frac{1}{2}P(n-1)+\frac{1}{2}P(n+2)</math>. Solutions to this recurrence relation come in the form <math display="inline"> P(n)=c_0{\left(\frac{\sqrt{5}-1}{2}\right)}^n+c_1+c_2{\left(-\frac{1+\sqrt{5}}{2}\right)}^n</math>, which after applying the appropriate boundary conditions reduces to <math display="inline">P(n)={\left(\frac{\sqrt{5}-1}{2}\right)}^{n+1}</math>. This means that if the walker were to get to the position of the current <math>a</math> value, then the probability of it ever reaching position -1 is less than <math display="inline">{\left( \frac{\sqrt{5}-1}{2} \right)}^{2^{37}}\approx 2.884\times 10^{-28723042565}</math>. This combined with the fact that the expected position of the walker after <math>k</math> steps is <math display="inline">\frac{1}{2}k</math> strongly suggests Antihydra [[probviously]] runs indefinitely.

== Code ==
The following Python program implements the abstracted behavior of the Antihydra. Proving whether it halts or not would also solve the Antihydra problem:<syntaxhighlight lang="python" line="1">
# Current value of the iterated Hydra function starting with initial value 8 (the values do not overflow)
h = 8
# (Collatz-like) condition counter that keeps track of how many odd and even numbers have been encountered
c = 0
# If c equals -1 there have been (strictly) more than twice as many odd as even numbers and the program halts
while c != -1:
# If h is even, add 2 to c so even numbers count twice
if h % 2 == 0:
c += 2
else:
c -= 1
# Add the current hydra value divided by two (integer division, rounding down) to itself (Hydra function)
# Note that integer division by 2 is equivalent to one bit shift to the right (h >> 1)
h += h//2
</syntaxhighlight>

The variable values of this iteration have been put into the On-Line Encyclopedia of Integer Sequences (OEIS):

* Hydra function values with Antihydra's starting value 8: https://oeis.org/A386792
* Antihydra's condition values: https://oeis.org/A385902

Fast [[Hydra]]/Antihydra simulation code by Greg Kuperberg (who said it could be made faster using FLINT):<syntaxhighlight lang="python2" line="1">
# Python script to demonstrate almost linear time hydra simulation
# using fast multiplication.
# by Greg Kuperberg

import time
from gmpy2 import mpz,bit_mask

# Straight computation of t steps of hydra
def simple(n,t):
for s in range(t): n += n>>1
return n

# Accelerated computation of 2**e steps of hydra
def hydra(n,e):
if e < 9: return simple(n,1<<e)
t = 1<<(e-1)
(p3t,m) = (mpz(3)**t,bit_mask(t))
n = p3t*(n>>t) + hydra(n&m,e-1)
return p3t*(n>>t) + hydra(n&m,e-1)

def elapsed():
(last,elapsed.mark) = (elapsed.mark,time.process_time())
return elapsed.mark-last
elapsed.mark = 0

(n,e) = (mpz(3),25)

elapsed()
print('hydra: steps=%d hash=%016x time=%.6fs'
% (1<<e,hash(hydra(n,e)),elapsed()))

# Quadratic time algorithm for comparison
# print('simple: steps=%d hash=%016x time=%.6fs'
# % (1<<e,hash(simple(n,1<<e)),elapsed()))
</syntaxhighlight>

==References==
[[Category:Individual machines]][[Category:Cryptids]]

Collatz-like

2025-06-17T11:18:02Z

MrSolis: ...

A '''Collatz-like function''' is a partial function defined piecewise depending on the remainder of an input modulo some number. The canonical example is the original Collatz function:<math display="block">\begin{array}{l}
c(2k) & = & k \\
c(2k+1) & = & 3k+2 \\
\end{array}</math>

A '''Collatz-like problem''' is a question about the behavior of iterating a Collatz-like function. Collatz-like problems are famously difficult.

Many [[Busy Beaver Champions]] have '''Collatz-like behavior''', meaning that their behavior can be concisely described via the iterated values of a Collatz-like function.

== Examples ==

=== 5-state busy beaver winner ===
Consider the [[5-state busy beaver winner]] and the generalized configuration:

<math display="block">M(n) = 0^\infty \; \textrm{<A} \; 1^n \; 0^\infty</math>Pascal Michel showed that:

<math display="block">\begin{array}{lcl}
0^\infty \; \textrm{<A} \; 0^\infty & = & M(0) \\
M(3k) & \xrightarrow{5 k^2 + 19 k + 15} & M(5k+6) \\
M(3k+1) & \xrightarrow{5 k^2 + 25 k + 27} & M(5k+9) \\
M(3k+2) & \xrightarrow{6k +12} & 0^\infty \;\; 1 \;\; \textrm{H>} \;\; 01 \;\; {(001)}^{k+1} \;\; 1 \;\; 0^\infty \\
\end{array}</math>

Starting on a blank tape <math>M(0)</math>, these rules iterate 15 times before reaching the halt config.<ref>[https://bbchallenge.org/~pascal.michel/beh#tm52a Pascal Michel's Analysis of the BB(5, 2) Champion]</ref>

=== Hydra ===
Consider [[Hydra]] (a [[Cryptid]]) and the generalized configuration:

<math display="block">C(a, b) = 0^\infty\;\textrm{<A}\;2\;0^{3(a-2)} \; 3^b \; 2 \; 0^\infty</math>
Daniel Yuan showed that:<math display="block">\begin{array}{l}
\\
0^\infty \; \textrm{A>} \; 0^\infty & & \xrightarrow{20} & C(3, 0) \\
C(2n, & 0) & \to & \text{Halt}(9n-6) \\
C(2n, & b+1) & \to & C(3n, & b) \\
C(2n+1, & b) & \to & C(3n+1, & b+2) \\
\end{array}</math>

Where <math>\textrm{Halt}(n)</math> is a halting configuration with <math>n</math> non-zero symbols on the tape.

Starting from <math>C(3, 0)</math>, this simulates a pseudo-random walk along the <math>b</math> parameter, increasing it by 2 every time <math>a</math> is odd, decreasing by 1 every time it's even. Deciding whether or not Hydra halts requires determining whether through the process of applying the Collatz-like function
<math display="block">\begin{array}{l}
H(2n) & = & 3n &\text{(even transition)} \\
H(2n+1) & = & 3n+1&\text{(odd transition)} \\
\end{array}</math>
to 3 recursively, there eventually comes a point where the amount of even transitions applied is more than twice the amount of odd transitions applied.<ref>Shawn Ligocki. [https://www.sligocki.com/2024/05/10/bb-2-5-is-hard.html BB(2, 5) is Hard (Hydra)]. 10 May 2024.</ref> The first few transitions are displayed below:
<math display="block">\begin{array}{l}
\vphantom{\frac{\frac{0}{.}}{.}}3 \xrightarrow{O} 4 \xrightarrow{E} 6\xrightarrow{E} 9 \xrightarrow{O} 13 \xrightarrow{O} 19 \xrightarrow{O} 28 \xrightarrow{E} 42 \xrightarrow{E} 63\xrightarrow{O} \cdots \\
\end{array}
</math>
=== Exponential Collatz ===
Consider the machine {{TM|1RB0LD_1RC0RF_1LC1LA_0LE1RZ_1LF0RB_0RC0RE|halt}}, discovered by Pavel Kropitz in May 2022, and the general configuration:<math display="block">K(n) = 0^\infty \; 1 \; 0^n \; 11 \; 0^5 \; \textrm{C>} \; 0^\infty</math>Shawn Ligocki showed that:
<math display="block">\begin{array}{l}
\\
0^\infty \; \textrm{A>} \; 0^\infty & \xrightarrow{45} & K(5) \\
K(4k) & \to & \text{Halt}\Bigl(\frac{3^{k+3} - 11}{2}\Bigr) \\
K(4k+1) & \to & K\Bigl(\frac{3^{k+3} - 11}{2}\Bigr) \\
K(4k+2) & \to & K\Bigl(\frac{3^{k+3} - 11}{2}\Bigr) \\
K(4k+3) & \to & K\Bigl(\frac{3^{k+3} + 1}{2}\Bigr) \\
\end{array}</math>

Demonstrating Collatz-like behavior with exponential piecewise component functions.

Starting from config <math>K(5)</math>, these rules iterate 15 times before reaching the halt config leaving over <math>10 \uparrow\uparrow 15</math> non-zero symbols on the tape.<ref>Shawn Ligocki. [https://www.sligocki.com/2022/06/21/bb-6-2-t15.html BB(6, 2) > 10↑↑15]. 21 Jun 2022.</ref>
== References ==
<references />
[[Category:Zoology]]

Champions

2025-06-17T10:37:58Z

MrSolis: ...

Busy Beaver '''Champions''' are the current record holding [[Turing machine|Turing machines]] who maximize a [[Busy Beaver function]]. In this article we focus specifically on the longest running TMs. Some have been proven to be the longest running of all (and so are the ultimate champion) while others are only current champions and may be usurped in the future. For smaller domains, Pascal Michel's website is the canonical source for [https://bbchallenge.org/~pascal.michel/bbc Busy Beaver champions] and the [https://bbchallenge.org/~pascal.michel/ha History of Previous Champions].

== 2-Symbol TMs ==
Rows are blank if no champion has been found which surpasses a smaller size problem. Take also note that the <math> f_{x}(n) </math> used in the lowerbounds represent the [[Fast-Growing Hierarchy]]. Note that most champions above 6 states are self-reported and have not been independently verified.

{| class="wikitable"
|+
!
!Runtime
!Champions
!Discovered By
!Verification
|-
|[[BB(2)]]
|<math> 6 </math>
|{{TM|1RB1LB_1LA1RZ|halt}} {{TM|1RB0LB_1LA1RZ|halt}} {{TM|1RB1RZ_1LB1LA|halt}} {{TM|1RB1RZ_0LB1LA|halt}} {{TM|0RB1RZ_1LA1RB|halt}}
|Tibor Radó
|Direct Simulation
|-
|[[BB(3)]]
|<math> 21 </math>
|{{TM|1RB1RZ_1LB0RC_1LC1LA|halt}}
|Proven by Shen Lin
|Direct Simulation
|-
|[[BB(4)]]
|<math> 107 </math>
|{{TM|1RB1LB_1LA0LC_1RZ1LD_1RD0RA|halt}}
|Allen Brady
|Direct Simulation
|-
|[[BB(5)]]
|<math> 47\,176\,870 </math>
|{{TM|1RB1LC_1RC1RB_1RD0LE_1LA1LD_1RZ0LA|halt}}
|Heiner Marxen & Jürgen Buntrock in 1989
|Direct Simulation
|-
|[[BB(6)]]
|<math> > 10\uparrow\uparrow11010000 </math>
|{{TM|1RB1LC_1LA1RE_0RD0LA_1RZ1LB_1LD0RF_0RD1RB|halt}}
|[https://discord.com/channels/960643023006490684/1384195691529633896/1384195691529633896 mxdys in 2025]
|See mxdys's analysis on the TM page
|-
|[[BB(7)]]
|<math>> 2 \uparrow^{11} 2 \uparrow^{11} 3</math>
|{{TM|1RB0RA_1LC1LF_1RD0LB_1RA1LE_1RZ0LC_1RG1LD_0RG0RF|halt}}
|[https://discord.com/channels/960643023006490684/1369339127652159509/1370678203395604562 Pavel Kropitz in 2025]
|Analyzed by Shawn Ligocki (see TM page)
|-
|BB(8)
|
|
|
|
|-
|BB(9)
|<math> > f_\omega(f_9(2)) </math>
|{{TM|1RB1RA_0LC0LF_0RD1LC_1RA1RG_1RZ0RA_1LB1LF_1LH1RE_0LI1LH_1LB0LH|halt}}
|Jacobzheng in 2024
|
|-
|BB(10)
|<math> > f_\omega^2(25) </math>
|{{TM|1RB1RA_0LC0LF_0RD1LC_1RA1RG_1RZ0RA_1LB1LF_1LH1RE_0LI1LH_0LF0LJ_1LH0LJ|halt}}
|Racheline in 2024
|
|-
|BB(11)
|<math> > f_\omega^2(2 \uparrow\uparrow 12) > f_\omega^2(f_3(9)) </math>
|{{TM|1LH1LA_1LI1RG_0RD1LC_0RF1RE_1LJ0RF_1RB1RF_0LC1LH_0LC0LA_1LK1LJ_1RZ0LI_0LD1LE|halt}}
|Racheline in 2024
|
|-
|BB(12)
|<math> > f_\omega^4(2 \uparrow\uparrow\uparrow 4-3) > f_\omega^4(f_4(2)) </math>
|{{TM|0LJ0RF_1LH1RC_0LD0LG_0RE1LD_1RF1RA_1RB1RF_1LC1LG_1LL1LI_1LK0LH_1RH1LJ_1RZ1LA_1RF1LL|halt}}
|Racheline in 2024
|
|-
|BB(13)
|
|
|
|
|-
|BB(14)
|<math> > f_{\omega + 1}(65\,536) > g_{64} </math>
|{{TM|1LH1LA_1LI1RG_0RD1LC_0RF1RE_1LJ0RF_1RB1RF_0LC1LH_0LC0LA_1LK1LJ_1RL0LI_0LL1LE_1LM1RZ_0LN1LF_0LJ---|halt}}
|[https://discord.com/channels/960643023006490684/960643023530762341/1274366178529120287 Racheline in 2024]
|
|-
|BB(15)
|
|
|
|
|-
|BB(16)
|<math> > f_{\omega + 1}(2 \uparrow\uparrow\uparrow\uparrow 2 \uparrow\uparrow\uparrow\uparrow 9) </math>
|
|Daniel Nagaj in 2021
|[https://www.sligocki.com/2022/07/11/bb-16-graham.html Analysis by Shawn Ligocki]
|-
|BB(17)
|<math> > f_{\omega + 1}(f_\omega(60)) </math>
|[[User:Jacobzheng/BB(17)]]
|Jacobzheng in 2024
|
|-
|BB(18)
|<math> > f_{\omega + 1}(f_\omega^2(60)) </math>
|[[User:Jacobzheng/BB(18)]]
|Jacobzheng in 2024
|
|-
|BB(19)
|<math> > f_{\omega + 1}^3(f_\omega(60)) </math>
|[[User:Jacobzheng/BB(19)]]
|Jacobzheng in 2024
|
|-
|BB(20)
|<math> > f_{\omega + 2}^2(21) </math>
|
|[https://discord.com/channels/960643023006490684/1026577255754903572/1274414683331366924 Racheline in 2024]
|
|-
|BB(21)
|<math> > f_{\omega^2}^2(4 \uparrow\uparrow 341) </math>
|
|[https://discord.com/channels/960643023006490684/1026577255754903572/1274471360206344213 Racheline in 2024]
|
|-
|BB(40)
|<math> > f_{\omega^\omega}(75\,500) </math>
|[[User:Jacobzheng/BB(40)]]
|Jacobzheng in 2024
|
|-
|BB(41)
|<math> > f_{\omega^\omega}^4(32) </math>
|[[User:Jacobzheng/BB(41)]]
|Jacobzheng in 2024
|
|-
|BB(51)
|<math> > f_{\varepsilon_0 + 1}(8) </math>
|
|[https://discord.com/channels/960643023006490684/1026577255754903572/1276881449685094495 Racheline in 2024]
|
|}

== 3-Symbol TMs ==

{| class="wikitable"
|+
!
!Runtime
!Champions
!Discovered By
!Verification
|-
|[[BB(2,3)]]
|<math> 38 </math>
|{{TM|1RB2LB1RZ_2LA2RB1LB|halt}}
|
|
|-
|[[BB(3,3)]]
|<math> > 10^{17} </math>
|{{TM|0RB2LA1RA_1LA2RB1RC_1RZ1LB1LC|halt}}
|
|
|-
|[[BB(4,3)]]
|<math> > 2 \uparrow\uparrow\uparrow 2^{2^{32}}</math>
|{{TM|0RB1RZ0RB_1RC1LB2LB_1LB2RD1LC_1RA2RC0LD|halt}}
|
|
|}

== 4-Symbol TMs ==
{| class="wikitable"
|+
!
!Runtime
!Champions
!Discovered By
!Verification
|-
|BB(2,4)
|<math> 3\,932\,964 </math>
|{{TM|1RB2LA1RA1RA_1LB1LA3RB1RZ|halt}}
|Shawn & Terry Ligocki in 2005
|Pascal Michel, Heiner Marxen, Allen Brady
|-
|BB(3,4)
|<math> > 2 \uparrow^{15} 5 </math>
|{{TM|1RB3LB1RZ2RA_2LC3RB1LC2RA_3RB1LB3LC2RC|halt}}
|
|
|}

== 5-Symbol TMs ==
{| class="wikitable"
!
!Runtime
!Champions
!Discovered By
!Verification
|-
|BB(2,5)
|<math> > 10^{10^{10^{3\,314\,360}}} </math>
|{{TM|1RB3LA4RB0RB2LA_1LB2LA3LA1RA1RZ|halt}}
|
|
|-
|BB(3,5)
|<math> > f_\omega(2 \uparrow^{15} 5) > f_\omega^2(15) </math>
|{{TM|1RB3LB4LC2RA4LB_2LC3RB1LC2RA1RZ_3RB1LB3LC2RC4LC|halt}}
|
|
|}

== 6-Symbol TMs ==
{| class="wikitable"
!
!Runtime
!Champions
!Discovered By
!Verification
|-
|BB(2,6)
|<math> > 10 \uparrow\uparrow 10 \uparrow\uparrow 10^{10^{115}} </math>
|{{TM|1RB3RB5RA1LB5LA2LB_2LA2RA4RB1RZ3LB2LA|halt}}
|
|
|}

BB(6)

2025-06-17T10:18:43Z

MrSolis: ...

The 6-state, 2-symbol Busy Beaver problem '''BB(6)''' is unsolved. With the discovery of [[Antihydra]] in 2024, we now know that we must solve a [[Collatz-like]] problem in order to solve BB(6).

The current BB(6) champion {{TM|1RB1LC_1LA1RE_0RD0LA_1RZ1LB_1LD0RF_0RD1RB|halt}} was discovered by mxdys on 16 June 2025, proving the lower bound:

<math display="block">S(6) > \Sigma(6) > 10 \uparrow\uparrow 10^7</math>

== Techniques ==
Simulating the machine {{TM|1RB0LD_1RC0RF_1LC1LA_0LE1RZ_1LF0RB_0RC0RE|halt}}, formerly the champion machine, requires [[Accelerated simulator|accelerated simulation]] that can handle Collatz Level 2 [[Inductive rule|inductive rules]]. In other words, it requires a simulator that can prove the rules:

<math display="block">\begin{array}{lcl}
C(4k) & \to & {\operatorname{Halt}}\Big(\frac{3^{k+3} - 11}{2}\Big) \\
C(4k+1) & \to & C\Big(\frac{3^{k+3} - 11}{2}\Big) \\
C(4k+2) & \to & C\Big(\frac{3^{k+3} - 11}{2}\Big) \\
C(4k+3) & \to & C\Big(\frac{3^{k+3} + 1}{2}\Big) \\
\end{array}</math>

and also compute the remainder mod 3 of numbers produced by applying these rules 15 times (which requires some fancy math related to [[wikipedia:Euler's_totient_function|Euler's totient function]]).

== Cryptids ==
Several [[Turing machines]] have been found that are [[Cryptids]], considered so because each of them have a [[Collatz-like]] halting problem, a type of problem that is generally difficult to solve. However, probabilistic arguments have allowed all but one of them to be categorized as [[probviously]] halting or probviously non-halting.

Probviously non-halting Cryptids:

* [[Antihydra]]
* {{TM|1RB1RC_1LC1LE_1RA1RD_0RF0RE_1LA0LB_---1RA|undecided}}, a variant of [[Hydra]] and Antihydra
* {{TM|1RB1LD_1RC1RE_0LA1LB_0LD1LC_1RF0RA_---0RC|undecided}}, similar to Antihydra
* {{TM|1RB0LD_1RC1RF_1LA0RA_0LA0LE_1LD1LA_0RB---|undecided}}, similar to Antihydra
* {{TM|1RB0LB_1LC0RE_1LA1LD_0LC---_0RB0RF_1RE1RB|undecided}}, similar to Antihydra

Probviously halting Cryptids:

* [[Lucy's Moonlight]]
* {{TM|1RB1RA_0RC1RC_1LD0LF_0LE1LE_1RA0LB_---0LC|undecided}}, a family of 16 related TMs
* {{TM|1RB1RE_1LC1LD_---1LA_1LB1LE_0RF0RA_1LD1RF}}
* {{TM|1RB0RE_1LC1LD_0RA0LD_1LB0LA_1RF1RA_---1LB}}
* {{TM|1RB0LC_0LC0RF_1RD1LC_0RA1LE_---0LD_1LF1LA}}
* {{TM|1RB0LC_1LC0RD_1LF1LA_1LB1RE_1RB1LE_---0LE}}
Although {{TM|1RB1LE_0LC0LB_1RD1LC_1RD1RA_1RF0LA_---1RE}} behaves similarly to the probviously halting Cryptids, it is estimated to have a 3/5 chance of becoming a [[translated cycler]] and a 2/5 chance of halting.

There are a few machines considered notable for their chaotic behaviour, but which have not been classified as Cryptids due to seemingly lacking a connection to any known open mathematical problems, such as Collatz-like problems.

Potential Cryptids:

* {{TM|1RB1RE_1LC0RA_0RD1LB_---1RC_1LF1RE_0LB0LE|undecided}}
* {{TM|1RB0LD_1LC0RA_1RA1LB_1LA1LE_1RF0LC_---0RE|undecided}}
* {{TM|1RB0RB_1LC1RE_1LF0LD_1RA1LD_1RC1RB_---1LC|undecided}}
* {{TM|1RB1LA_1LC0RE_1LF1LD_0RB0LA_1RC1RE_---0LD}}

== Top Halters ==
Below is a table of the machines with the 11 highest known runtimes.<ref>Shawn Ligocki's list of 6-state, 2-symbol machines with large runtimes ([https://github.com/sligocki/busy-beaver/blob/main/Machines/bb/6x2.txt Link])</ref> Their sigma scores are expressed using an extension of Knuth's up-arrow notation.<ref>Shawn Ligocki. 2022. [https://www.sligocki.com/2022/06/25/ext-up-notation.html "Extending Up-arrow Notation"]</ref>
{| class="wikitable"
|+Top Known BB(6) Halters
!TM
!approximate sigma score
|-
|{{TM|1RB1LC_1LA1RE_0RD0LA_1RZ1LB_1LD0RF_0RD1RB|halt}}
|<math>10\uparrow\uparrow 10^7</math>
|-
|{{TM|1RB0LD_1RC0RF_1LC1LA_0LE1RZ_1LF0RB_0RC0RE}}
|10 ↑↑ 15.60465
|-
|{{TM|1RB0LF_1RC1RB_1LD0RA_1LB0LE_1RZ0LC_1LA1LF}}
|10 ↑↑ 7.52390
|-
|{{TM|1RB0LF_1RC1RB_1LD0RA_1RF0LE_1RZ0LC_1LA1LF}}
|10 ↑↑ 7.52390
|-
|{{TM|1RB0LF_1RC1RB_1LD0RA_1LF0LE_1RZ0LC_1LA1LF}}
|10 ↑↑ 7.52390
|-
|{{TM|1RB1RC_1LC1RE_1LD0LB_1RE1LC_1LE0RF_1RZ1RA}}
|10 ↑↑ 7.23619
|-
|{{TM|1RB1RA_1LC1LE_1RE0LD_1LC0LF_1RZ0RA_0RA0LB}}
|10 ↑↑ 6.96745
|-
|{{TM|1RB0RF_1LC0RA_1RZ0LD_1LE1LD_1RB1RC_0LD0RE}}
|10 ↑↑ 5.77573
|-
|{{TM|1RB0LA_1LC1LF_0LD0LC_0LE0LB_1RE0RA_1RZ1LD}}
|10 ↑↑ 5.63534
|-
|{{TM|1RB1RE_1LC1LF_1RD0LB_1LE0RC_1RA0LD_1RZ1LC}}
|10 ↑↑ 5.56344
|-
|{{TM|1RB0LE_0RC1RA_0LD1RF_1RE0RB_1LA0LC_0RD1RZ}}
|10 ↑↑ 5.12468
|}
The runtimes are presumed to be about <math>\text{score}^2</math> which is roughly indistinguishable in tetration notation.

== Holdouts ==
@mxdys's informal [[Holdouts lists|holdouts list]] is down to 3571 machines as of February 2025.

== References ==
<references />
[[Category:BB Domain]]

Bigfoot

2025-05-16T19:51:16Z

MrSolis: ...

{{machine|1RB2RA1LC_2LC1RB2RB_---2LA1LA}}{{TM|1RB2RA1LC_2LC1RB2RB_---2LA1LA}}{{unsolved|Does Bigfoot run forever?}}
'''Bigfoot''' is a [[BB(3,3)]] [[Cryptids|Cryptid]]. Its low-level behaviour was first shared [https://discord.com/channels/960643023006490684/1084047886494470185/1163168233445130270 over Discord] by savask on 14 Oct 2023, and within two days, Shawn Ligocki described the high-level rules shown below, whose attributes inspired the [[Turing machine|Turing machine's]] name.<ref name="b">S. Ligocki, "[https://www.sligocki.com/2023/10/16/bb-3-3-is-hard.html BB(3, 3) is Hard (Bigfoot)] (2024). Accessed 22 July 2024.</ref>
<div style="width: fit-content; text-align: center; margin-left: auto; margin-right: auto;">
{|class="wikitable" style="margin-left: auto; margin-right: auto;"
! !!0!!1!!2
|-
!A
|1RB
|2RA
|1LC
|-
!B
|2LC
|1RB
|2RB
|-align="center"
!C
| ---
|2LA
|1LA
|}
The transition table of Bigfoot.</div>

Bigfoot was also [https://github.com/sligocki/sligocki.github.io/issues/8#issuecomment-2140887228 successfully compiled] to a 7-state 2-symbol machine by Iijil: {{TM|0RB1RB_1LC0RA_1RE1LF_1LF1RE_0RD1RD_1LG0LG_---1LB}} in May of 2024.

== Analysis ==
Let <math>A(a,b,c):=0^\infty\;12^a\;1^{2b}\;\textrm{<A}\;1^{2c}\;0^\infty</math>. Then,
<math display="block">\begin{array}{|l l l|}\hline A(a,6b,c)&\xrightarrow{4a+(2b+1)48b+(12b+1)2c+13}&A(a,8b+c-1,2),\\A(a,6b+1,c)&\xrightarrow{4a+(6b+5)16b+(4b+1)6c+29}&A(a+1,8b+c-1,3),\\A(0,6b+2,c)&\xrightarrow{(b+1)96b+(3b+1)8c+18}&0^\infty\;\textrm{<C}\;1^{16b+2c+5}\;2\;0^\infty,\\A(a,6b+2,c)&\xrightarrow{4a+(2b+3)48b+(12b+7)2c+51}&A(a-1,8b+c+3,2)\text{ if }a\ge1,\\A(a,6b+3,c)&\xrightarrow{4a+(6b+7)16b+(12b+5)2c+91}&A(a,8b+c+1,5),\\A(a,6b+4,c)&\xrightarrow{4a+(2b+3)48b+(12b+7)2c+63}&A(a+1,8b+c+3,2),\\A(a,6b+5,c)&\xrightarrow{4a+(6b+11)16b+(4b+3)6c+103}&A(a,8b+c+5,3).\\\hline\end{array}</math>
<div class="toccolours mw-collapsible mw-collapsed">'''Proof'''<div class="mw-collapsible-content">
For now, we will work with the slightly different configuration <math>A'(a,b,c):=0^\infty\;12^a\;1^b\;\textrm{<A}\;1^c\;0^\infty</math>. Consider the partial configuration <math>P(m,n):=1^m\;\textrm{<A}\;1^n\;0^\infty</math>. We first require the following shift rule:
<math display="block">\begin{array}{|l|}\hline\textrm{A>}\;1^s\xrightarrow{s}2^s\;\textrm{A>}\\\hline\end{array}</math>
Using this shift rule, we get <math>1^{m-1}\;2^{n+1}\;\textrm{A>}\;0^\infty</math> after <math>n+1</math> steps, followed by <math>1^{m-1}\;2^n\;\textrm{<C}\;122\;0^\infty</math> four steps later. Observing that <math>22\;\textrm{<C}</math> becomes <math>\textrm{<C}\;11</math> in two steps leads to another shift rule:
<math display="block">\begin{array}{|l|}\hline2^{2s}\;\textrm{<C}\xrightarrow{2s}\textrm{<C}\;1^{2s}\\\hline\end{array}</math>
From here, there are two different scenarios depending on if <math>n</math> is even or odd, given below as histories of transitions that use the aforementioned shift rules:
#If <math>n\equiv0\ (\operatorname{mod}2)</math>, then what follows is:<math display="block">\begin{array}{|l|}\hline 1^{m-1}\;2^n\;\textrm{<C}\;122\;0^\infty \xrightarrow{n} 1^{m-1}\;\textrm{<C}\;1^{n+1}\;22\;0^\infty\xrightarrow{4}1^{m-3}\;\textrm{<A}\;1^{n+3}\;22\;0^\infty\xrightarrow{n+4}\\
1^{m-4}\;2^{n+4}\;\textrm{A>}\;22\;0^\infty\xrightarrow{1}1^{m-4}\;2^{n+4}\;\textrm{<C}\;12\;0^\infty\xrightarrow{n+4}1^{m-4}\;\textrm{<C}\;1^{n+5}\;2\;0^\infty\xrightarrow{4}\\1^{m-6}\;\textrm{<A}\;1^{n+7}\;2\;0^\infty\xrightarrow{n+8}1^{m-7}\;2^{n+8}\;\textrm{A>}\;2\;0^\infty\xrightarrow{1}1^{m-7}\;2^{n+8}\;\textrm{<C}\;1\;0^\infty\xrightarrow{n+8}\\1^{m-7}\;\textrm{<C}\;1^{n+9}\;0^\infty\xrightarrow{4}1^{m-9}\;\textrm{<A}\;1^{n+11}\;0^\infty\\\hline\end{array}</math>Therefore, we have<math display="block">\begin{array}{|l|}\hline P(m,n)\xrightarrow{6n+43}P(m-9,n+11)\text{ if }m\ge9\text{ and }n\equiv0\ (\operatorname{mod}2).\\\hline\end{array}</math>
# If <math>n\equiv1\ (\operatorname{mod}2)</math>, then what follows is:<math display="block">\begin{array}{|l|}\hline 1^{m-1}\;2^n\;\textrm{<C}\;122\;0^\infty \xrightarrow{n-1} 1^{m-1}\;2\;\textrm{<C}\;1^n\;22\;0^\infty \xrightarrow{1}1^{m-1}\;\textrm{<A}\;1^{n+1}\;22\;0^\infty \xrightarrow{n+2}\\ 1^{m-2}\;2^{n+2}\;\textrm{A>}\;22\;0^\infty \xrightarrow{1} 1^{m-2}\;2^{n+2}\;\textrm{<C}\;12\;0^\infty \xrightarrow{n+1}1^{m-2}\;2\;\textrm{<C}\;1^{n+2}\;2\;0^\infty \xrightarrow{1}\\ 1^{m-2}\;\textrm{<A}\;1^{n+3}\;2\;0^\infty \xrightarrow{n+4} 1^{m-3}\;2^{n+4}\;\textrm{A>}\;2\;0^\infty\xrightarrow{1}1^{m-3}\;2^{n+4}\;\textrm{<C}\;1\;0^\infty\xrightarrow{n+3}\\1^{m-3}\;2\;\textrm{<C}\;1^{n+4}\;0^\infty\xrightarrow{1}1^{m-3}\;\textrm{<A}\;1^{n+5}\;0^\infty\\\hline\end{array}</math>Therefore, we have
<math display="block">\begin{array}{|l|}\hline P(m,n)\xrightarrow{6n+19}P(m-3,n+5)\text{ if }m\ge3\text{ and }n\equiv1\ (\operatorname{mod}2).\\\hline\end{array}</math>
From this we know that Bigfoot's behaviour depends on the value of <math>b</math> modulo 12, and with <math>A'(a,b,c)</math> we have <math>P(b,c)</math>. The following shift rules will be useful:
<math display="block">\begin{array}{|l|l|l|}\hline12^s\;\textrm{<A}\xrightarrow{2s}\textrm{<A}\;21^s&\textrm{B>}\;1^s\xrightarrow{s}1^s\;\textrm{B>}&\textrm{B>}\;2^s\xrightarrow{s}2^s\;\textrm{B>}\\\hline\end{array}</math>
Only even values of <math>b</math> and <math>c</math> are relevant, so there remain six possible scenarios:
#If <math>b\equiv0\ (\operatorname{mod}12)</math>, then in <math display="inline">{\displaystyle\sum_{i=0}^{b/12-1}}(6(16i+c)+43+6(16i+11+c)+19)={\displaystyle\sum_{i=0}^{b/12-1}}4(48i+3c+32)=\frac{2}{3}b^2+\frac{8}{3}b+bc</math> steps we arrive at <math display="inline">P\Big(0,16\times\frac{b}{12}+c\Big)</math>, or <math>0^\infty\;12^a\;\textrm{<A}\;1^{4b/3+c}\;0^\infty</math> when considering the complete configuration. What follows is:<math display="block">\begin{array}{|l|}\hline0^\infty\;12^a\;\textrm{<A}\;1^{4b/3+c}\;0^\infty\xrightarrow{2a}0^\infty\;\textrm{<A}\;21^a\;1^{4b/3+c}\;0^\infty\xrightarrow{1}0^\infty\;1\;\textrm{B>}\;21^a\;1^{4b/3+c}\;0^\infty\xrightarrow{2a+4b/3+c}\\0^\infty\;12^a\;1^{4b/3+c+1}\;\textrm{B>}\;0^\infty\xrightarrow{12}0^\infty\;12^a\;1^{4b/3+c-2}\;\textrm{<A}\;1^4\;0^\infty\\\hline\end{array}</math>This means that if <math display="inline">\frac{4}{3}b+c\ge2</math>, then we will reach <math display="inline">A'\Big(a,\frac{4}{3}b+c-2,4\Big)</math> in <math display="inline">4a+\frac{2}{3}b^2+4b+bc+c+13</math> steps.
#If <math>b\equiv2\ (\operatorname{mod}12)</math>, then in <math display="inline">{\displaystyle\sum_{i=0}^{(b-2)/12-1}}4(48i+3c+32)=\frac{2}{3}b^2+bc-2c-\frac{8}{3}</math> steps we arrive at <math display="inline">P\Big(2,\frac{4(b-2)}{3}+c\Big)</math>, or <math>0^\infty\;12^a\;11\;\textrm{<A}\;1^{(4b-2)/3+c}\;0^\infty</math>. What follows is:<math display="block">\begin{array}{|l|}\hline0^\infty\;12^a\;11\;\textrm{<A}\;1^{4(b-2)/3+c}\;0^\infty\xrightarrow{4(b-2)/3+c+1}0^\infty\;12^a\;1\;2^{4(b-2)/3+c+1}\;\textrm{A>}\;0^\infty\xrightarrow{4}\\0^\infty\;12^a\;1\;2^{4(b-2)/3+c}\;\textrm{<C}\;122\;0^\infty\xrightarrow{4(b-2)/3+c}0^\infty\;12^a\;1\;\textrm{<C}\;1^{4(b-2)/3+c+1}\;22\;0^\infty\xrightarrow{1}\\0^\infty\;12^a\;\textrm{<A}\;2\;1^{4(b-2)/3+c+1}\;22\;0^\infty\xrightarrow{2a}0^\infty\;\textrm{<A}\;21^a\;2\;1^{4(b-2)/3+c+1}\;22\;0^\infty\xrightarrow{1}\\0^\infty\;1\;\textrm{B>}\;21^a\;2\;1^{4(b-2)/3+c+1}\;22\;0^\infty\xrightarrow{4(b-2)/3+2a+c+4}0^\infty\;12^{a+1}\;1^{4(b-2)/3+c+1}\;22\;\textrm{B>}\;0^\infty\xrightarrow{18}\\0^\infty\;12^{a+1}\;1^{4(b-2)/3+c-2}\;\textrm{<A}\;1^6\;0^\infty\\\hline\end{array}</math>This means that if <math display="inline">\frac{4(b-2)}{3}+c\ge 2</math>, then we will reach <math display="inline">A'\Big(a+1,\frac{4b-14}{3}+c,6\Big)</math> in <math display="inline">4a+\frac{2}{3}b^2+4b+bc+c+\frac{55}{3}</math> steps.
#If <math>b\equiv4\ (\operatorname{mod}12)</math>, then in <math display="inline>\frac{2}{3}b^2-\frac{8}{3}b+bc-4c</math> steps we arrive at <math display="inline">P\Big(4,\frac{4(b-4)}{3}+c\Big)</math>, or <math>0^\infty\;12^a\;1111\;\textrm{<A}\;1^{4(b-4)/3+c}\;0^\infty</math>. What follows is:<math display="block">\begin{array}{|l|}\hline0^\infty\;12^a\;1111\;\textrm{<A}\;1^{4(b-4)/3+c}\;0^\infty\xrightarrow{(8b-14)/3+2c}0^\infty\;12^a\;11\;\textrm{<A}\;2\;1^{4(b-4)/3+c+1}\;22\;0^\infty\xrightarrow{3}\\0^\infty\;12^a\;1\;\textrm{<A}\;1^{4(b-4)/3+c+3}\;22\;0^\infty\xrightarrow{4(b-4)/3+c+4}0^\infty\;12^a\;2^{4(b-4)/3+c+4}\;\textrm{A>}\;22\;0^\infty\xrightarrow{1}\\0^\infty\;12^a\;2^{4(b-4)/3+c+4}\;\textrm{<C}\;12\;0^\infty\xrightarrow{4(b-4)/3+c+4}0^\infty\;12^a\;\textrm{<C}\;1^{4(b-4)/3+c+5}\;2\;0^\infty\xrightarrow{1}\\0^\infty\;12^{a-1}\;1\;\textrm{<A}\;1^{4(b-4)/3+c+6}\;2\;0^\infty\xrightarrow{4(b-4)/3+c+7}0^\infty\;12^{a-1}\;2^{4(b-4)/3+c+7}\;\textrm{A>}\;2\;0^\infty\xrightarrow{1}\\0^\infty\;12^{a-1}\;2^{4(b-4)/3+c+7}\;\textrm{<C}\;1\;0^\infty\xrightarrow{4(b-4)/3+c+6}0^\infty\;12^{a-1}\;2\;\textrm{<C}\;1^{4(b-4)/3+c+7}\;0^\infty\xrightarrow{1}\\0^\infty\;12^{a-1}\;\textrm{<A}\;1^{4(b-4)/3+c+8}\;0^\infty\xrightarrow{2(a-1)}0^\infty\;\textrm{<A}\;21^{a-1}\;1^{4(b-4)/3+c+8}\;0^\infty\xrightarrow{1}\\0^\infty\;1\;\textrm{B>}\;21^{a-1}\;1^{4(b-4)/3+c+8}\;0^\infty\xrightarrow{2a+4(b-4)/3+c+6}0^\infty\;12^{a-1}\;1^{4(b-4)/3+c+9}\;\textrm{B>}\;0^\infty\xrightarrow{12}\\0^\infty\;12^{a-1}\;1^{4(b-4)/3+c+6}\;\textrm{<A}\;1^4\;0^\infty\\\hline\end{array}</math>This means that if <math>a=0</math>, then Bigfoot will reach the undefined <code>C0</code> transition with the configuration <math>0^\infty\;\textrm{<C}\;1^{(4b-1)/3+c}\;2\;0^\infty</math> in <math display="inline">\frac{2}{3}b^2+\frac{8}{3}b+bc-\frac{10}{3}</math> steps. Otherwise, it will proceed to reach <math display="inline">A'\Big(a-1,\frac{4b+2}{3}+c,4\Big)</math> in <math display="inline">4a+\frac{2}{3}b^2+\frac{20}{3}b+bc+3c+\frac{41}{3}</math> steps.
#If <math>b\equiv6\ (\operatorname{mod}12)</math>, then in <math display="inline">\frac{2}{3}b^2-\frac{16}{3}b+bc-6c+8</math> steps we arrive at <math display="inline">P\Big(6,\frac{4(b-6)}{3}+c\Big)</math>, or <math>0^\infty\;12^a\;111111\;\textrm{<A}\;1^{4(b-6)/3+c}\;0^\infty</math>. What follows is:<math display="block">\begin{array}{|l|}\hline0^\infty\;12^a\;111111\;\textrm{<A}\;1^{4(b-6)/3+c}\;0^\infty\xrightarrow{16b/3+4c-14}0^\infty\;12^a\;11\;\textrm{<C}\;1^{4(b-6)/3+c+5}\;2\;0^\infty\xrightarrow{4}\\0^\infty\;12^a\;\textrm{<A}\;1^{4(b-6)/3+c+7}\;2\;0^\infty\xrightarrow{2a}0^\infty\;\textrm{<A}\;21^a\;1^{4(b-6)/3+c+7}\;2\;0^\infty\xrightarrow{1}\\0^\infty\;1\;\textrm{B>}\;21^a\;1^{4(b-6)/3+c+7}\;2\;0^\infty\xrightarrow{2a+4(b-6)/3+c+8}0^\infty\;12^a\;1^{4(b-6)/3+c+8}\;2\;\textrm{B>}\;0^\infty\xrightarrow{60}\\0^\infty\;12^a\;1^{4(b-6)/3+c+2}\;\textrm{<A}\;1^{10}\;0^\infty\\\hline\end{array}</math>This means that we will reach <math display="inline">A'\Big(a,\frac{4}{3}b+c-6,10\Big)</math> in <math display="inline">4a+\frac{2}{3}b^2+\frac{4}{3}b+bc-c+59</math> steps.
#If <math>b\equiv8\ (\operatorname{mod}12)</math>, then in <math display="inline>\frac{2}{3}b^2-8b+bc-8c+\frac{64}{3}</math> steps we arrive at <math display="inline">P\Big(8,\frac{4(b-8)}{3}+c\Big)</math>, or <math>0^\infty\;12^a\;1^8\;\textrm{<A}\;1^{4(b-8)/3+c}\;0^\infty</math>. What follows is:<math display="block">\begin{array}{|l|}\hline0^\infty\;12^a\;1^8\;\textrm{<A}\;1^{4(b-8)/3+c}\;0^\infty\xrightarrow{(16b-62)/3+4c}0^\infty\;12^a\;11\;\textrm{<A}\;1^{4(b-8)/3+c+7}\;2\;0^\infty\xrightarrow{4(b-8)/3+c+8}\\0^\infty\;12^a\;1\;2^{4(b-8)/3+c+8}\;\textrm{A>}\;2\;0^\infty\xrightarrow{1}0^\infty\;12^a\;1\;2^{4(b-8)/3+c+8}\;\textrm{<C}\;1\;0^\infty\xrightarrow{4(b-8)/3+c+8}\\0^\infty\;12^a\;1\;\textrm{<C}\;1^{4(b-8)/3+c+9}\;0^\infty\xrightarrow{1}0^\infty\;12^a\;\textrm{<A}\;2\;1^{4(b-8)/3+c+9}\;0^\infty\xrightarrow{2a}\\0^\infty\;\textrm{<A}\;21^a\;2\;1^{4(b-8)/3+c+9}\;0^\infty\xrightarrow{1}0^\infty\;1\;\textrm{B>}\;21^a\;2\;1^{4(b-8)/3+c+9}\;0^\infty\xrightarrow{2a+4(b-8)/3+c+10}\\0^\infty\;12^{a+1}\;1^{4(b-8)/3+c+9}\;\textrm{B>}\;0^\infty\xrightarrow{12}0^\infty\;12^{a+1}\;1^{4(b-8)/3+c+6}\;\textrm{<A}\;1^4\;0^\infty\\\hline\end{array}</math>This means that we will reach <math display="inline">A'\Big(a+1,\frac{4b-14}{3}+c,4\Big)</math> in <math display="inline">4a+\frac{2}{3}b^2+\frac{4}{3}b+bc-c+\frac{29}{3}</math> steps.
#If <math>b\equiv10\ (\operatorname{mod}12)</math>, then in <math display="inline">\frac{2}{3}b^2-\frac{32}{3}b+bc-10c+40</math> steps we arrive at <math display="inline">P\Big(10,\frac{4(b-10)}{3}+c\Big)</math>, or <math>0^\infty\;12^a\;1^{10}\;\textrm{<A}\;1^{4(b-10)/3+c}\;0^\infty</math>. What follows is:<math display="block">\begin{array}{|l|}\hline0^\infty\;12^a\;1^{10}\;\textrm{<A}\;1^{4(b- 10)/3+c}\;0^\infty\xrightarrow{8b+6c-37}0^\infty\;12^a\;1\;\textrm{<A}\;1^{4(b- 10)/3+c+11}\;0^\infty\xrightarrow{4(b- 10)/3+c+12}\\0^\infty\;12^a\;2^{4(b- 10)/3+c+12}\;\textrm{A>}\;0^\infty\xrightarrow{4}0^\infty\;12^a\;2^{4(b-10)/3+c+11}\;\textrm{<C}\;122\;0^\infty\xrightarrow{4(b-10)/3+c+10}\\0^\infty\;12^a\;2\;\textrm{<C}\;1^{4(b- 10)/3+c+11}\;22\;0^\infty\xrightarrow{1}0^\infty\;12^a\;\textrm{<A}\;1^{4(b-10)/3+c+12}\;22\;0^\infty\xrightarrow{2a}\\0^\infty\;\textrm{<A}\;12^a\;1^{4(b-10)/3+c+12}\;22\;0^\infty\xrightarrow{1}0^\infty\;1\;\textrm{B>}\;12^a\;1^{4(b-10)/3+c+12}\;22\;0^\infty\xrightarrow{2a+4(b-10)/3+c+14}\\0^\infty\;12^a\;1^{4(b-10)/3+c+13}\;22\;\textrm{B>}\;0^\infty\xrightarrow{18}0^\infty\;12^a\;1^{4(b-10)/3+c+10}\;\textrm{<A}\;1^6\;0^\infty\\\hline\end{array}</math>This means that we will reach <math display="inline">A'\Big(a,\frac{4b-10}{3}+c,6\Big)</math> in <math display="inline">4a+\frac{2}{3}b^2+\frac{4}{3}b+bc-c+23</math> steps.
The information above can be summarized as
<math display="block">A'(a,b,c)\rightarrow\begin{cases}A'\Big(a,\frac{4}{3}b+c-2,4\Big)&\text{if }b\equiv0\pmod{12}\text{ and }\frac{4}{3}b+c\ge2,\\A'\Big(a+1,\frac{4b-14}{3}+c,6\Big)&\text{if }b\equiv2\pmod{12}\text{ and }\frac{4(b-2)}{3}+c\ge2,\\0^\infty\;\textrm{<C}\;1^{(4b-1)/3+c}\;2\;0^\infty&\text{if }b\equiv4\pmod{12}\text{ and }a=0,\\A'\Big(a-1,\frac{4b+2}{3}+c,4\Big)&\text{if }b\equiv4\pmod{12}\text{ and }a>0,\\A'\Big(a,\frac{4}{3}b+c-6,10\Big)&\text{if }b\equiv6\pmod{12},\\A'\Big(a+1,\frac{4b-14}{3}+c,4\Big)&\text{if }b\equiv8\pmod{12},\\A'\Big(a,\frac{4b-10}{3}+c,6\Big)&\text{if }b\equiv10\pmod{12}.\end{cases}</math>
Using the definitions of <math>A'</math> and <math>A</math> to transform these rules produces this:
<math display="block">A(a,b,c)\rightarrow\begin{cases}A\Big(a,\frac{4}{3}b+c-1,2\Big)&\text{if }b\equiv0\pmod{6}\text{ and }\frac{4}{3}b+c\ge1,\\A\Big(a+1,\frac{4b-7}{3}+c,3\Big)&\text{if }b\equiv1\pmod{6}\text{ and }\frac{4(b-1)}{3}+c\ge1,\\0^\infty\;\textrm{<C}\;1^{(8b-1)/3+2c}\;2\;0^\infty&\text{if }b\equiv2\pmod{6}\text{ and }a=0,\\A\Big(a-1,\frac{4b+1}{3}+c,2\Big)&\text{if }b\equiv2\pmod{6}\text{ and }a>0,\\A\Big(a,\frac{4}{3}b+c-3,5\Big)&\text{if }b\equiv3\pmod{6},\\A\Big(a+1,\frac{4b-7}{3}+c,2\Big)&\text{if }b\equiv4\pmod{6},\\A\Big(a,\frac{4b-5}{3}+c,3\Big)&\text{if }b\equiv5\pmod{6}.\end{cases}</math>
Substituting <math>b\leftarrow6b+k</math> where <math>k</math> is the remainder for each case yields the final result.
</div></div>
Using the floor function, it is possible to describe the behaviour of <math>b</math> and <math>c</math> using a function that is not defined piecewise:
<math display="block">\textstyle\begin{array}{c}f(m,n)=\Big(\frac{4m-3-4(\delta_1(m)-\delta_2(m)+\delta_4(m))-2(3\delta_3(m)+\delta_5(m))}{3}+n,2+\delta_1(m)+3\delta_3(m)+\delta_5(m)\Big),\\\delta_i(m)=\Big\lfloor\frac{x-i}{6}\Big\rfloor-\Big\lfloor\frac{x-i-1}{6}\Big\rfloor=\begin{cases}1&\text{if }x\equiv i\pmod{6},\\0&\text{otherwise.}\end{cases}\end{array}</math>
In effect, the halting problem for Bigfoot is about whether through enough iterations of <math>f(m,n)</math> we encounter more <math>m</math> values that are congruent to 2 modulo 6 than ones that are congruent to 1 or 4 modulo 6.

An important insight is that if <math>b</math> is odd and <math>c=2</math>, then after four iterations of <math>A</math>, that will remain the case. This allows one to define a configuration that eliminates the <math>c</math> parameter and whose rules use a modulus of 81.<ref name="b"></ref>
== Trajectory ==
After 69 steps, Bigfoot will reach the configuration <math>A(2,1,2)</math> before the [[Collatz-like]] rules are repeatedly applied. Simulations of Bigfoot have shown that after 24000000 rule steps, we have <math>a=3999888</math>. Here are the first few:
<math display="block">\begin{array}{|l|}\hline A(2,1,2)\xrightarrow{49}A(3,1,3)\xrightarrow{59}A(4,2,3)\xrightarrow{109}A(3,6,2)\xrightarrow{221}A(3,9,2)\xrightarrow{379}A(3,11,5)\xrightarrow{597}A(3,18,3)\rightarrow\cdots\\\hline\end{array}</math>
There exists a heuristic argument for Bigfoot being [[probviously]] non-halting. By only considering the rules for which <math>a</math> changes, one may notice that the trajectory of <math>a</math> values can be approximated by a random walk in which at each step, the walker moves +1 with probability <math display="inline">\frac{2}{3}</math> or moves -1 with probability <math display="inline">\frac{1}{3}</math>, starting at position 2. If <math>P(n)</math> is the probability that the walker will reach position -1 from position <math>n</math>, then <math display="inline">P(n)=\frac{1}{3}P(n-1)+\frac{2}{3}P(n+1)</math>. Solutions to this recurrence relation come in the form <math display="inline"> P(n)=c_02^{-n}+c_1</math>, which after applying the appropriate boundary conditions reduces to <math display="inline">P(n)=2^{-(n+1)}</math>. As a result, if the walker gets to position 3999888, then the probability of it ever reaching position -1 would be <math display="inline">2^{-3999889}\approx 2.697\times 10^{-1204087}</math>.
==References==
<references/>
[[Category:Cryptids]]

User:MrSolis

2025-04-30T16:09:35Z

MrSolis:

== Discord Server ==
Hi MrSolis,
I like your contributions to the Hydra and Antihydra articles. Do you mind joining the bbchallenge discord server? It's easier to have a conversation there. https://discord.com/invite/3uqtPJA9Uv [[User:Peacemaker II|Peacemaker II]] ([[User talk:Peacemaker II|talk]]) 15:58, 30 April 2025 (UTC)

:I dont have a disc account and also dont feel like conversing rn but will prob join today/tmrw [[User:MrSolis|MrSolis]] ([[User:MrSolis|talk]]) 16:09, 30 April 2025 (UTC)

Talk:Antihydra

2025-04-30T15:49:59Z

MrSolis:

== Variable Naming Conventions ==
I noticed that the usage of the variables 'a' and 'b' in this article are opposite to how they are defined in other sources. Can we modify this article to make it more consistent? [[User:Peacemaker II|Peacemaker II]] ([[User talk:Peacemaker II|talk]]) 00:36, 30 April 2025 (UTC)

Agreeing to the above that renaming the variables in this article would align it to most other sources and also proposing naming these variables h (*h*ydra) and c ((*c*ollatz-like) *c*ondition *c*ounter) instead for easier remembering [[User:Coda|Coda]] ([[User talk:Coda|talk]]) 00:57, 30 April 2025 (UTC)

: I'll change the article to use the modified variable names. You are referring to *h* instead of *b* and *c* instead of *a*, right? [[User:MrSolis|MrSolis]] ([[User:MrSolis|talk]]) 15:02, 30 April 2025 (UTC)

:: Yes, a->c and b->h in this article. h being the always increasing current hydra function value. It would probably also be a good idea to agree on a standard order of these two (h first?) [[User:Coda|Coda]] ([[User talk:Coda|talk]]) 15:07, 30 April 2025 (UTC)

:::I chose the order I did simply bcuz its the same order as in the config but if u think swapping it truly helps, then idm doing it but thats yr call [[User:MrSolis|MrSolis]] ([[User:MrSolis|talk]]) 15:49, 30 April 2025 (UTC)

Talk:Antihydra

2025-04-30T15:12:35Z

MrSolis:

== Variable Naming Conventions ==
I noticed that the usage of the variables 'a' and 'b' in this article are opposite to how they are defined in other sources. Can we modify this article to make it more consistent? [[User:Peacemaker II|Peacemaker II]] ([[User talk:Peacemaker II|talk]]) 00:36, 30 April 2025 (UTC)

Agreeing to the above that renaming the variables in this article would align it to most other sources and also proposing naming these variables h (*h*ydra) and c ((*c*ollatz-like) *c*ondition *c*ounter) instead for easier remembering [[User:Coda|Coda]] ([[User talk:Coda|talk]]) 00:57, 30 April 2025 (UTC)

: I'll change the article to use the modified variable names. You are referring to *h* instead of *b* and *c* instead of *a*, right? [[User:MrSolis|MrSolis]] ([[User:MrSolis|talk]]) 15:02, 30 April 2025 (UTC)

:: Yes, a->c and b->h in this article. h being the always increasing current hydra function value. It would probably also be a good idea to agree on a standard order of these two (h first?) [[User:Coda|Coda]] ([[User talk:Coda|talk]]) 15:07, 30 April 2025 (UTC)
:::I chose the order I did simply bcuz its the same order as in the config but if swapping it is truly helpful that idm doing it but thats yr call [[User:MrSolis|MrSolis]] ([[User:MrSolis|talk]]) 15:12, 30 April 2025 (UTC)

Talk:Antihydra

2025-04-30T15:02:57Z

MrSolis:

Talk:Antihydra

2025-04-30T15:00:28Z

MrSolis:

Lucy's Moonlight

2025-04-22T11:18:36Z

MrSolis:

{{machine|1RB0RD_0RC1RE_1RD0LA_1LE1LC_1RF0LD_---0RA}}{{TM|1RB0RD_0RC1RE_1RD0LA_1LE1LC_1RF0LD_---0RA}}

'''Lucy's Moonlight''' is a [[probviously]] halting tetrational [[BB(6)]] [[Cryptid]]. This [[Turing machine]] was first mentioned [https://discord.com/channels/960643023006490684/1239205785913790465/1345551751016878272 on Discord] by Racheline on 1 Mar 2025, who afterward found a set of [https://discord.com/channels/960643023006490684/1345810396136865822/1345820781363597312 high-level rules] describing it. Shawn Ligocki later discovered and [https://discord.com/channels/960643023006490684/1345810396136865822/1346329322851401868 shared] a more refined set of rules, displayed below.
<div style="width: fit-content; text-align: center; margin-left: auto; margin-right: auto;">
{|class="wikitable" style="margin-left: auto; margin-right: auto;"
! !!0!!1
|-
!A
|1RB
|0RD
|-
!B
|0RC
|1RE
|-
!C
|1RD
|0LA
|-
!D
|1LE
|1LC
|-
!E
|1RF
|0LD
|-
!F
| ---
|0RA
|}
The transition table of Lucy's Moonlight.</div>
==Analysis==
Let <math>C(a,b):=0^\infty\;1011^a\;1^b\;10\;\textrm{C>}\;0^\infty</math>. Then,
<math display="block">\begin{array}{|lll|}\hline C(a+1,3b)&\xrightarrow{12b^2+53b+28}&C(a,8b+6),\\C(a+2,3b+1)&\xrightarrow{12b^2+77b+103}&C(a,8b+16),\\C(a+2,3b+2)&\xrightarrow{12b^2+101b+184}&C(a,8b+22),\\C(0,3b)&\xrightarrow{12b^2+29b+52}&C(2b,8),\\C(0,3b+1)&\xrightarrow{12b^2+53b+30}&C(0,8b+5),\\C(1,3b+1)&\xrightarrow{12b^2+53b+58}&0^\infty\;1011^{2b+4}\;1\;\textrm{F>}\;0^\infty,\\C(0,3b+2)&\xrightarrow{12b^2+53b+28}&C(0,8b+5),\\C(1,3b+2)&\xrightarrow{12b^2+77b+160}&C(2b+4,8).\\\hline\end{array}</math>
<div class="toccolours mw-collapsible mw-collapsed">'''Proof'''<div class="mw-collapsible-content">
Consider the partial configuration <math>P(m,n):=1^m\;10^n\;\textrm{C>}\;0^\infty</math>, which after three steps is <math>1^m\;10^n\;\textrm{<D}\;01\;0^\infty</math>. To advance, this shift rule is required:
<math display="block>\begin{array}{|l|}\hline10^s\;\textrm{<D}\xrightarrow{2s}\textrm{<D}\;01^s\\\hline\end{array}</math>
This means we have <math>1^m\;\textrm{<D}\;01^{n+1}\;0^\infty</math> after <math>2n</math> steps, with <math>1^{m-3}\;0\;\textrm{D>}\;01^{n+2}\;0^\infty</math> after three further steps. From here, we can use the fact that <math>0\;\textrm{D>}\;01^s</math> becomes <math>100\;\textrm{D>}\;01^{s-1}</math> in four steps if <math>s\ge1</math> to get this rule:
<math display="block>\begin{array}{|l|}\hline0\;\textrm{D>}\;01^s\xrightarrow{4s}10^s\;0\;\textrm{D>}\\\hline\end{array}</math>
Using this rule produces <math>1^{m-3}\;10^{n+2}\;0\;\textrm{D>}\;0^\infty</math> in <math>4n+8</math> steps. With five more steps, we get <math>1^{m-3}\;10^{n+4}\;\textrm{C>}\;0^\infty</math>, which is also <math>P(m-3,n+4)</math>. To summarize:
<math display="block>\begin{array}{|l|}\hline P(m,n)\xrightarrow{6n+19}P(m-3,n+4)\text{ if }m\ge3.\\\hline\end{array}</math>
With <math>C(a,b)</math> we have <math>P(b,1)</math> and are able to apply this rule <math display="inline">\Big\lfloor\frac{b}{3}\Big\rfloor</math> times, with three possible scenarios:
#If <math>b\equiv0\ (\operatorname{mod}3)</math>, then in <math display="inline">{\displaystyle\sum_{i=0}^{b/3-1}(6(1+4i)+19)}=\frac{4}{3}b^2+\frac{13}{3}b</math> steps we arrive at <math display="inline">P\Big(0,1+\frac{4b}{3}\Big)</math>. The matching complete configuration is <math>0^\infty\;1011^a\;10^{1+4b/3}\;\textrm{C>}\;0^\infty</math>. In <math display="inline">\frac{8}{3}b+5</math> steps we have <math>0^\infty\;1011^a\;\textrm{<D}\;01^{2+4b/3}\;0^\infty</math>, followed by <math>0^\infty\;1011^{a-1}\;11\;\textrm{B>}\;01^{3+4b/3}\;0^\infty</math> after three steps. We note that if <math>s\ge 2</math>, then <math>\textrm{B>}\;01^s</math> becomes <math>11\;\textrm{B>}\;01^{s-1}</math> in 8 steps, giving this transition rule:<math display="block>\begin{array}{|l|}\hline\textrm{B>}\;01^s \xrightarrow{8s-4}1^{2s-1}\;0\;\textrm{C>}\text{ if }s\ge1.\\\hline\end{array}</math>In this instance, the result is <math>0^\infty\;1011^{a-1}\;1^{7+8b/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(a-1,\frac{8}{3}b+6\Big)</math>, after <math display="inline">\frac{32}{3}b+20</math> steps. This gives a total of <math display="inline">\frac{4}{3}b^2+\frac{53}{3}b+28</math> steps.
#We can rewrite <math>C(a,b)</math> as <math>0^\infty\;1011^{a-1}\;10\;1^{b+2}\;10\;\textrm{C>}\;0^\infty</math> if <math>a\ge 1</math>. Given this, we have <math>P(b+2,1)</math>, and if <math>b\equiv1\ (\operatorname{mod}3)</math>, then in <math display="inline">\frac{4}{3}b^2+\frac{29}{3}b+14</math> steps we arrive at <math>0^\infty\;1011^{a-1}\;10^{(4b+14)/3}\;\textrm{C>}\;0^\infty</math>, which in <math display="inline">\frac{8b+37}{3}</math> steps becomes <math>0^\infty\;1011^{a-1}\;\textrm{<D}\;01^{(4b+17)/3}\;0^\infty</math>, and then <math>0^\infty\;1011^{a-2}\;11\;\textrm{B>}\;01^{(4b+20)/3}\;0^\infty</math> after three more steps. We end with <math display="inline">\frac{32b+148}{3}</math> steps to get <math>0^\infty\;1011^{a-2}\;1^{(8b+43)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(a-2,\frac{8b+40}{3}\Big)</math>. This gives a total of <math display="inline">\frac{4}{3}b^2+23b+\frac{236}{3}</math> steps.
#If <math>b\equiv2\ (\operatorname{mod}3)</math> and we reuse the technique of rewriting <math>C(a,b)</math>, then in <math display="inline">\frac{4}{3}b^2+7b+\frac{17}{3}</math> steps we arrive at <math>0^\infty\;1011^{a-1}\;101\;10^{(4b+7)/3}\;\textrm{C>}\;0^\infty</math>, which in <math display="inline">\frac{8b+23}{3}</math> steps becomes <math>0^\infty\;1011^{a-1}\;101\;\textrm{<D}\;01^{(4b+10)/3}\;0^\infty</math>, and then in five steps, <math>0^\infty\;1011^{a-1}\;0\;\textrm{D>}\;01^{(4b+13)/3}\;0^\infty</math>. Adding <math display="inline">\frac{16b+52}{3}</math> steps gives us <math>0^\infty\;1011^{a-1}\;10^{(4b+13)/3}\;0\;\textrm{D>}\;0^\infty</math>, and another eight gives us <math>0^\infty\;1011^{a-1}\;10^{(4b+19)/3}\;\textrm{<D}\;01\;0^\infty</math>. After <math display="inline">\frac{8b+38}{3}</math> steps, the configuration is <math>0^\infty\;1011^{a-1}\;\textrm{<D}\;01^{(4b+22)/3}\;0^\infty</math> and after three more, <math>0^\infty\;1011^{a-2}\;11\;\textrm{B>}\;01^{(4b+25)/3}\;0^\infty</math>. We conclude with <math>0^\infty\;1011^{a-2}\;1^{(8b+53)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(a-2,\frac{8b+50}{3}\Big)</math>, after <math display="inline">\frac{32b+188}{3}</math> steps, for a total of <math display="inline">\frac{4}{3}b^2+\frac{85}{3}b+122</math> steps.
The behaviour of Lucy's Moonlight changes at the boundary conditions: <math>a=0</math> or <math>a=1</math>. These changes are addressed below:
#If <math>a=0</math> and <math>b\equiv0\ (\operatorname{mod}3)</math>, then starting from <math>0^\infty\;\textrm{<D}\;01^{2+4b/3}\;0^\infty</math>, we take three steps to get <math>0^\infty\;10\;\textrm{A>}\;01^{2+4b/3}\;0^\infty</math>. It is here that another shift rule must come into use:<math display="block">\begin{array}{|l|}\hline\textrm{A>}\;01^{2s}\xrightarrow{4s}1110^s\;\textrm{A>}\\\hline\end{array}</math>Upon using this shift rule, we get <math>0^\infty\;10\;1110^{1+2b/3}\;\textrm{A>}\;0^\infty</math> in <math display="inline">\frac{8}{3}b+4</math> steps. This configuration is the same as <math>0^\infty\;1011^{1+2b/3}\;10\;\textrm{A>}\;0^\infty</math>. With 40 more steps, we end at <math>0^\infty\;1011^{2b/3}\;1^9\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(\frac{2}{3}b,8\Big)</math>, for a total of <math display="inline">\frac{4}{3}b^2+\frac{29}{3}b+52</math> steps.
#If <math>a=0</math> and <math>b\equiv1\ (\operatorname{mod}3)</math>, then in <math display="inline">\frac{4}{3}b^2+\frac{5}{3}b-3</math> steps we arrive at <math>0^\infty\;1\;10^{(4b-1)/3}\;\textrm{C>}\;0^\infty</math>. With <math display="inline">\frac{8b+7}{3}</math> more steps we now have <math>0^\infty\;1\;\textrm{<D}\;01^{(4b+2)/3}\;0^\infty</math>. Given five steps, the result is <math>0^\infty\;1\;\textrm{B>}\;01^{(4b+5)/3}\;0^\infty</math>, which turns into <math>0^\infty\;1^{(8b+10)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(0,\frac{8b+7}{3}\Big)</math> in <math display="inline">\frac{32b+28}{3}</math> steps for a total of <math display="inline">\frac{4}{3}b^2+15b+\frac{41}{3}</math> steps.
#If <math>a=1</math> and <math>b\equiv1\ (\operatorname{mod}3)</math>, then starting from <math>0^\infty\;\textrm{<D}\;01^{(4b+17)/3}\;0^\infty</math>, we get <math>0^\infty\;10\;\textrm{A>}\;01^{(4b+17)/3}\;0^\infty</math> in three steps. Since <math>01^{(4b+17)/3}</math> and <math>01^{(4b+14)/3}\;01</math> are the same, what follows is <math>0^\infty\;1011^{(2b+7)/3}\;10\;\textrm{A>}\;01\;0^\infty</math> in <math display="inline">\frac{8b+28}{3}</math> steps before finally reaching <math>0^\infty\;1011^{(2b+10)/3}\;1\;\textrm{F>}\;0^\infty</math>, and therefore the undefined <code>F0</code> transition, in three steps. This gives a total of <math display="inline">\frac{4}{3}b^2+15b+\frac{125}{3}</math> steps.
#If <math>a=0</math> and <math>b\equiv2\ (\operatorname{mod}3)</math>, then in <math display="inline">\frac{4}{3}b^2-b-\frac{10}{3}</math> steps we arrive at <math>0^\infty\;11\;10^{(4x-5)/3}\;\textrm{C>}\;0^\infty</math>. It takes a further <math display="inline">\frac{8b-1}{3}</math> steps to reach <math>0^\infty\;11\;\textrm{<D}\;01^{(4b-2)/3}\;0^\infty</math>, and adding three more gives us <math>0^\infty\;1\;\textrm{B>}\;01^{(4b+1)/3}\;0^\infty</math>. With <math display="inline">\frac{32b-4}{3}</math> more steps we end up with <math>0^\infty\;1^{(8b+2)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(0,\frac{8b-1}{3}\Big)</math>. This gives a total of <math display="inline">\frac{4}{3}b^2+\frac{37}{3}b-2</math> steps.
#If <math>a=1</math> and <math>b\equiv2\ (\operatorname{mod}3)</math>, then starting from <math>0^\infty\;\textrm{<D}\;01^{(4b+22)/3}\;0^\infty</math>, we take three steps to get <math>0^\infty\;10\;\textrm{A>}\;01^{(4b+22)/3}\;0^\infty</math>, and taking <math display="inline">\frac{8b+44}{3}</math> more steps produces <math>0^\infty\;1011^{(2b+11)/3}\;10\;\textrm{A>}\;0^\infty</math>. After 40 steps, we reach <math>0^\infty\;1011^{(2b+8)/3}\;1^9\;0\;\textrm{C>}\;0^\infty</math>, which is <math display="inline">C\Big(\frac{2b+8}{3},8\Big)</math>, for a total of <math display="inline">\frac{4}{3}b^2+\frac{61}{3}b+114</math> steps.
The information above can be summarized as
<math display="block">C(a,b)\rightarrow\begin{cases}C\Big(a-1,\frac{8}{3}b+6\Big)&\text{if }a\ge1\text{ and }b\equiv0\pmod{3},\\C\Big(a-2,\frac{8b+40}{3}\Big)&\text{if }a\ge2\text{ and }b\equiv1\pmod{3},\\C\Big(a-2,\frac{8b+50}{3}\Big)&\text{if }a\ge2\text{ and }b\equiv2\pmod{3},\\C\Big(\frac{2}{3}b,8\Big)&\text{if }a=0\text{ and }b\equiv0\pmod{3},\\C\Big(0,\frac{8b+7}{3}\Big)&\text{if }a=0\text{ and }b\equiv1\pmod{3},\\0^\infty\;1011^{(2b+10)/3}\;1\;\textrm{F>}\;0^\infty&\text{if }a=1\text{ and }b\equiv1\pmod{3},\\C\Big(0,\frac{8b-1}{3}\Big)&\text{if }a=0\text{ and }b\equiv2\pmod{3},\\C\Big(\frac{2b+8}{3},8\Big)&\text{if }a=1\text{ and }b\equiv2\pmod{3}.\end{cases}</math>
Substituting <math>b=3b+k</math>, where <math>k</math> is the remainder of <math>b</math> modulo 3, yields the final result.
</div></div>
These rules imply a sequence <math>G_n</math> that grows tetrationally in <math>n</math>, which Lucy's Moonlight iterates through one by one. For each <math>g\in G_n</math>, it reaches the configuration <math>C(g,8)</math> and then repeatedly applies the first three rules until meeting a configuration <math>C(g',q)</math> that satisfies the boundary conditions. If <math>g'=1</math> and <math>q</math> is congruent to 1 modulo 3, then Lucy's Moonlight will halt; otherwise, it moves on to the next term in <math>G_n</math>.
==Trajectory==
Starting with <math>C(0,0)</math> after two steps, Lucy's Moonlight repeatedly applies the [[Collatz-like]] rules. The first few steps are shown below:
<math display="block">\begin{array}{|l|}\hline C(0,0)\xrightarrow{52}C(0,8)\xrightarrow{182}C(0,21)\xrightarrow{843}C(14,8)\xrightarrow{434}C(12,38)\xrightarrow{3124}C(10,118)\xrightarrow{21358}C(8,328)\rightarrow\cdots\\\hline\end{array}</math>
From <math>C(0,0)</math>, it takes 11 rule steps to get <math>C(11292,8)</math> and 6811 more to get <math>C(G_3,8)</math>, where <math>G_3\approx 8.282\times10^{2901}</math>. Despite this rapid growth, Lucy's Moonlight appears to be [[probviously]] halting if one considers each instance of <math>C(g,8)</math> as the beginning of an independent round of a luck-based game, detailed below:
#A large number <math>n</math> is generated randomly.
#At each time unit, <math>n</math> will decrease by 1 with probability <math display="inline">\frac{1}{3}</math> or decrease by 2 with probability <math display="inline">\frac{2}{3}</math> provided that <math>n\ge2</math>.
#If <math>n=1</math>, then <math>n</math> will decrease to 0, the game is won, or a new round begins, each with probability <math display="inline>\frac{1}{3}</math>.
#If <math>n=0</math>, then a new round begins.
The probability of winning a round with starting value <math>n</math>, denoted <math>P(n)</math>, is described for <math>n\ge2</math> by the recurrence relation <math display="inline">P(n)=\frac{1}{3}P(n-1)+\frac{2}{3}P(n-2)</math>. The general solution to this equation is <math display="inline">P(n)=c_0+c_1{\Big({-\frac{2}{3}}\Big)}^n</math>, and by using the conditions <math>P(0)=0</math> and <math display="inline">P(1)=\frac{1}{3}</math> we get <math display="inline">P(n)=\frac{1}{5}\Big(1-{\Big({-\frac{2}{3}}\Big)}^n\Big)</math>. This approximately equals <math display="inline">\frac{1}{5}</math> for large <math>n</math>, so the probability of winning the game in <math>r</math> rounds is approximately <math display="inline">1-\Big(\frac{4}{5}\Big)^r</math>, which approaches 1 as <math>r</math> increases.
[[Category:Cryptids]]

Lucy's Moonlight

2025-04-22T11:18:19Z

MrSolis: added the adjectives back in (really not looking to argue, the edit was not meant as an attack, simply a criticism)

{{machine|1RB0RD_0RC1RE_1RD0LA_1LE1LC_1RF0LD_---0RA}}{{TM|1RB0RD_0RC1RE_1RD0LA_1LE1LC_1RF0LD_---0RA}}

'''Lucy's Moonlight''' is a [[probviously]] halting tetrational [[BB(6)]] [[Cryptid]].. This [[Turing machine]] was first mentioned [https://discord.com/channels/960643023006490684/1239205785913790465/1345551751016878272 on Discord] by Racheline on 1 Mar 2025, who afterward found a set of [https://discord.com/channels/960643023006490684/1345810396136865822/1345820781363597312 high-level rules] describing it. Shawn Ligocki later discovered and [https://discord.com/channels/960643023006490684/1345810396136865822/1346329322851401868 shared] a more refined set of rules, displayed below.
<div style="width: fit-content; text-align: center; margin-left: auto; margin-right: auto;">
{|class="wikitable" style="margin-left: auto; margin-right: auto;"
! !!0!!1
|-
!A
|1RB
|0RD
|-
!B
|0RC
|1RE
|-
!C
|1RD
|0LA
|-
!D
|1LE
|1LC
|-
!E
|1RF
|0LD
|-
!F
| ---
|0RA
|}
The transition table of Lucy's Moonlight.</div>
==Analysis==
Let <math>C(a,b):=0^\infty\;1011^a\;1^b\;10\;\textrm{C>}\;0^\infty</math>. Then,
<math display="block">\begin{array}{|lll|}\hline C(a+1,3b)&\xrightarrow{12b^2+53b+28}&C(a,8b+6),\\C(a+2,3b+1)&\xrightarrow{12b^2+77b+103}&C(a,8b+16),\\C(a+2,3b+2)&\xrightarrow{12b^2+101b+184}&C(a,8b+22),\\C(0,3b)&\xrightarrow{12b^2+29b+52}&C(2b,8),\\C(0,3b+1)&\xrightarrow{12b^2+53b+30}&C(0,8b+5),\\C(1,3b+1)&\xrightarrow{12b^2+53b+58}&0^\infty\;1011^{2b+4}\;1\;\textrm{F>}\;0^\infty,\\C(0,3b+2)&\xrightarrow{12b^2+53b+28}&C(0,8b+5),\\C(1,3b+2)&\xrightarrow{12b^2+77b+160}&C(2b+4,8).\\\hline\end{array}</math>
<div class="toccolours mw-collapsible mw-collapsed">'''Proof'''<div class="mw-collapsible-content">
Consider the partial configuration <math>P(m,n):=1^m\;10^n\;\textrm{C>}\;0^\infty</math>, which after three steps is <math>1^m\;10^n\;\textrm{<D}\;01\;0^\infty</math>. To advance, this shift rule is required:
<math display="block>\begin{array}{|l|}\hline10^s\;\textrm{<D}\xrightarrow{2s}\textrm{<D}\;01^s\\\hline\end{array}</math>
This means we have <math>1^m\;\textrm{<D}\;01^{n+1}\;0^\infty</math> after <math>2n</math> steps, with <math>1^{m-3}\;0\;\textrm{D>}\;01^{n+2}\;0^\infty</math> after three further steps. From here, we can use the fact that <math>0\;\textrm{D>}\;01^s</math> becomes <math>100\;\textrm{D>}\;01^{s-1}</math> in four steps if <math>s\ge1</math> to get this rule:
<math display="block>\begin{array}{|l|}\hline0\;\textrm{D>}\;01^s\xrightarrow{4s}10^s\;0\;\textrm{D>}\\\hline\end{array}</math>
Using this rule produces <math>1^{m-3}\;10^{n+2}\;0\;\textrm{D>}\;0^\infty</math> in <math>4n+8</math> steps. With five more steps, we get <math>1^{m-3}\;10^{n+4}\;\textrm{C>}\;0^\infty</math>, which is also <math>P(m-3,n+4)</math>. To summarize:
<math display="block>\begin{array}{|l|}\hline P(m,n)\xrightarrow{6n+19}P(m-3,n+4)\text{ if }m\ge3.\\\hline\end{array}</math>
With <math>C(a,b)</math> we have <math>P(b,1)</math> and are able to apply this rule <math display="inline">\Big\lfloor\frac{b}{3}\Big\rfloor</math> times, with three possible scenarios:
#If <math>b\equiv0\ (\operatorname{mod}3)</math>, then in <math display="inline">{\displaystyle\sum_{i=0}^{b/3-1}(6(1+4i)+19)}=\frac{4}{3}b^2+\frac{13}{3}b</math> steps we arrive at <math display="inline">P\Big(0,1+\frac{4b}{3}\Big)</math>. The matching complete configuration is <math>0^\infty\;1011^a\;10^{1+4b/3}\;\textrm{C>}\;0^\infty</math>. In <math display="inline">\frac{8}{3}b+5</math> steps we have <math>0^\infty\;1011^a\;\textrm{<D}\;01^{2+4b/3}\;0^\infty</math>, followed by <math>0^\infty\;1011^{a-1}\;11\;\textrm{B>}\;01^{3+4b/3}\;0^\infty</math> after three steps. We note that if <math>s\ge 2</math>, then <math>\textrm{B>}\;01^s</math> becomes <math>11\;\textrm{B>}\;01^{s-1}</math> in 8 steps, giving this transition rule:<math display="block>\begin{array}{|l|}\hline\textrm{B>}\;01^s \xrightarrow{8s-4}1^{2s-1}\;0\;\textrm{C>}\text{ if }s\ge1.\\\hline\end{array}</math>In this instance, the result is <math>0^\infty\;1011^{a-1}\;1^{7+8b/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(a-1,\frac{8}{3}b+6\Big)</math>, after <math display="inline">\frac{32}{3}b+20</math> steps. This gives a total of <math display="inline">\frac{4}{3}b^2+\frac{53}{3}b+28</math> steps.
#We can rewrite <math>C(a,b)</math> as <math>0^\infty\;1011^{a-1}\;10\;1^{b+2}\;10\;\textrm{C>}\;0^\infty</math> if <math>a\ge 1</math>. Given this, we have <math>P(b+2,1)</math>, and if <math>b\equiv1\ (\operatorname{mod}3)</math>, then in <math display="inline">\frac{4}{3}b^2+\frac{29}{3}b+14</math> steps we arrive at <math>0^\infty\;1011^{a-1}\;10^{(4b+14)/3}\;\textrm{C>}\;0^\infty</math>, which in <math display="inline">\frac{8b+37}{3}</math> steps becomes <math>0^\infty\;1011^{a-1}\;\textrm{<D}\;01^{(4b+17)/3}\;0^\infty</math>, and then <math>0^\infty\;1011^{a-2}\;11\;\textrm{B>}\;01^{(4b+20)/3}\;0^\infty</math> after three more steps. We end with <math display="inline">\frac{32b+148}{3}</math> steps to get <math>0^\infty\;1011^{a-2}\;1^{(8b+43)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(a-2,\frac{8b+40}{3}\Big)</math>. This gives a total of <math display="inline">\frac{4}{3}b^2+23b+\frac{236}{3}</math> steps.
#If <math>b\equiv2\ (\operatorname{mod}3)</math> and we reuse the technique of rewriting <math>C(a,b)</math>, then in <math display="inline">\frac{4}{3}b^2+7b+\frac{17}{3}</math> steps we arrive at <math>0^\infty\;1011^{a-1}\;101\;10^{(4b+7)/3}\;\textrm{C>}\;0^\infty</math>, which in <math display="inline">\frac{8b+23}{3}</math> steps becomes <math>0^\infty\;1011^{a-1}\;101\;\textrm{<D}\;01^{(4b+10)/3}\;0^\infty</math>, and then in five steps, <math>0^\infty\;1011^{a-1}\;0\;\textrm{D>}\;01^{(4b+13)/3}\;0^\infty</math>. Adding <math display="inline">\frac{16b+52}{3}</math> steps gives us <math>0^\infty\;1011^{a-1}\;10^{(4b+13)/3}\;0\;\textrm{D>}\;0^\infty</math>, and another eight gives us <math>0^\infty\;1011^{a-1}\;10^{(4b+19)/3}\;\textrm{<D}\;01\;0^\infty</math>. After <math display="inline">\frac{8b+38}{3}</math> steps, the configuration is <math>0^\infty\;1011^{a-1}\;\textrm{<D}\;01^{(4b+22)/3}\;0^\infty</math> and after three more, <math>0^\infty\;1011^{a-2}\;11\;\textrm{B>}\;01^{(4b+25)/3}\;0^\infty</math>. We conclude with <math>0^\infty\;1011^{a-2}\;1^{(8b+53)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(a-2,\frac{8b+50}{3}\Big)</math>, after <math display="inline">\frac{32b+188}{3}</math> steps, for a total of <math display="inline">\frac{4}{3}b^2+\frac{85}{3}b+122</math> steps.
The behaviour of Lucy's Moonlight changes at the boundary conditions: <math>a=0</math> or <math>a=1</math>. These changes are addressed below:
#If <math>a=0</math> and <math>b\equiv0\ (\operatorname{mod}3)</math>, then starting from <math>0^\infty\;\textrm{<D}\;01^{2+4b/3}\;0^\infty</math>, we take three steps to get <math>0^\infty\;10\;\textrm{A>}\;01^{2+4b/3}\;0^\infty</math>. It is here that another shift rule must come into use:<math display="block">\begin{array}{|l|}\hline\textrm{A>}\;01^{2s}\xrightarrow{4s}1110^s\;\textrm{A>}\\\hline\end{array}</math>Upon using this shift rule, we get <math>0^\infty\;10\;1110^{1+2b/3}\;\textrm{A>}\;0^\infty</math> in <math display="inline">\frac{8}{3}b+4</math> steps. This configuration is the same as <math>0^\infty\;1011^{1+2b/3}\;10\;\textrm{A>}\;0^\infty</math>. With 40 more steps, we end at <math>0^\infty\;1011^{2b/3}\;1^9\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(\frac{2}{3}b,8\Big)</math>, for a total of <math display="inline">\frac{4}{3}b^2+\frac{29}{3}b+52</math> steps.
#If <math>a=0</math> and <math>b\equiv1\ (\operatorname{mod}3)</math>, then in <math display="inline">\frac{4}{3}b^2+\frac{5}{3}b-3</math> steps we arrive at <math>0^\infty\;1\;10^{(4b-1)/3}\;\textrm{C>}\;0^\infty</math>. With <math display="inline">\frac{8b+7}{3}</math> more steps we now have <math>0^\infty\;1\;\textrm{<D}\;01^{(4b+2)/3}\;0^\infty</math>. Given five steps, the result is <math>0^\infty\;1\;\textrm{B>}\;01^{(4b+5)/3}\;0^\infty</math>, which turns into <math>0^\infty\;1^{(8b+10)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(0,\frac{8b+7}{3}\Big)</math> in <math display="inline">\frac{32b+28}{3}</math> steps for a total of <math display="inline">\frac{4}{3}b^2+15b+\frac{41}{3}</math> steps.
#If <math>a=1</math> and <math>b\equiv1\ (\operatorname{mod}3)</math>, then starting from <math>0^\infty\;\textrm{<D}\;01^{(4b+17)/3}\;0^\infty</math>, we get <math>0^\infty\;10\;\textrm{A>}\;01^{(4b+17)/3}\;0^\infty</math> in three steps. Since <math>01^{(4b+17)/3}</math> and <math>01^{(4b+14)/3}\;01</math> are the same, what follows is <math>0^\infty\;1011^{(2b+7)/3}\;10\;\textrm{A>}\;01\;0^\infty</math> in <math display="inline">\frac{8b+28}{3}</math> steps before finally reaching <math>0^\infty\;1011^{(2b+10)/3}\;1\;\textrm{F>}\;0^\infty</math>, and therefore the undefined <code>F0</code> transition, in three steps. This gives a total of <math display="inline">\frac{4}{3}b^2+15b+\frac{125}{3}</math> steps.
#If <math>a=0</math> and <math>b\equiv2\ (\operatorname{mod}3)</math>, then in <math display="inline">\frac{4}{3}b^2-b-\frac{10}{3}</math> steps we arrive at <math>0^\infty\;11\;10^{(4x-5)/3}\;\textrm{C>}\;0^\infty</math>. It takes a further <math display="inline">\frac{8b-1}{3}</math> steps to reach <math>0^\infty\;11\;\textrm{<D}\;01^{(4b-2)/3}\;0^\infty</math>, and adding three more gives us <math>0^\infty\;1\;\textrm{B>}\;01^{(4b+1)/3}\;0^\infty</math>. With <math display="inline">\frac{32b-4}{3}</math> more steps we end up with <math>0^\infty\;1^{(8b+2)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(0,\frac{8b-1}{3}\Big)</math>. This gives a total of <math display="inline">\frac{4}{3}b^2+\frac{37}{3}b-2</math> steps.
#If <math>a=1</math> and <math>b\equiv2\ (\operatorname{mod}3)</math>, then starting from <math>0^\infty\;\textrm{<D}\;01^{(4b+22)/3}\;0^\infty</math>, we take three steps to get <math>0^\infty\;10\;\textrm{A>}\;01^{(4b+22)/3}\;0^\infty</math>, and taking <math display="inline">\frac{8b+44}{3}</math> more steps produces <math>0^\infty\;1011^{(2b+11)/3}\;10\;\textrm{A>}\;0^\infty</math>. After 40 steps, we reach <math>0^\infty\;1011^{(2b+8)/3}\;1^9\;0\;\textrm{C>}\;0^\infty</math>, which is <math display="inline">C\Big(\frac{2b+8}{3},8\Big)</math>, for a total of <math display="inline">\frac{4}{3}b^2+\frac{61}{3}b+114</math> steps.
The information above can be summarized as
<math display="block">C(a,b)\rightarrow\begin{cases}C\Big(a-1,\frac{8}{3}b+6\Big)&\text{if }a\ge1\text{ and }b\equiv0\pmod{3},\\C\Big(a-2,\frac{8b+40}{3}\Big)&\text{if }a\ge2\text{ and }b\equiv1\pmod{3},\\C\Big(a-2,\frac{8b+50}{3}\Big)&\text{if }a\ge2\text{ and }b\equiv2\pmod{3},\\C\Big(\frac{2}{3}b,8\Big)&\text{if }a=0\text{ and }b\equiv0\pmod{3},\\C\Big(0,\frac{8b+7}{3}\Big)&\text{if }a=0\text{ and }b\equiv1\pmod{3},\\0^\infty\;1011^{(2b+10)/3}\;1\;\textrm{F>}\;0^\infty&\text{if }a=1\text{ and }b\equiv1\pmod{3},\\C\Big(0,\frac{8b-1}{3}\Big)&\text{if }a=0\text{ and }b\equiv2\pmod{3},\\C\Big(\frac{2b+8}{3},8\Big)&\text{if }a=1\text{ and }b\equiv2\pmod{3}.\end{cases}</math>
Substituting <math>b=3b+k</math>, where <math>k</math> is the remainder of <math>b</math> modulo 3, yields the final result.
</div></div>
These rules imply a sequence <math>G_n</math> that grows tetrationally in <math>n</math>, which Lucy's Moonlight iterates through one by one. For each <math>g\in G_n</math>, it reaches the configuration <math>C(g,8)</math> and then repeatedly applies the first three rules until meeting a configuration <math>C(g',q)</math> that satisfies the boundary conditions. If <math>g'=1</math> and <math>q</math> is congruent to 1 modulo 3, then Lucy's Moonlight will halt; otherwise, it moves on to the next term in <math>G_n</math>.
==Trajectory==
Starting with <math>C(0,0)</math> after two steps, Lucy's Moonlight repeatedly applies the [[Collatz-like]] rules. The first few steps are shown below:
<math display="block">\begin{array}{|l|}\hline C(0,0)\xrightarrow{52}C(0,8)\xrightarrow{182}C(0,21)\xrightarrow{843}C(14,8)\xrightarrow{434}C(12,38)\xrightarrow{3124}C(10,118)\xrightarrow{21358}C(8,328)\rightarrow\cdots\\\hline\end{array}</math>
From <math>C(0,0)</math>, it takes 11 rule steps to get <math>C(11292,8)</math> and 6811 more to get <math>C(G_3,8)</math>, where <math>G_3\approx 8.282\times10^{2901}</math>. Despite this rapid growth, Lucy's Moonlight appears to be [[probviously]] halting if one considers each instance of <math>C(g,8)</math> as the beginning of an independent round of a luck-based game, detailed below:
#A large number <math>n</math> is generated randomly.
#At each time unit, <math>n</math> will decrease by 1 with probability <math display="inline">\frac{1}{3}</math> or decrease by 2 with probability <math display="inline">\frac{2}{3}</math> provided that <math>n\ge2</math>.
#If <math>n=1</math>, then <math>n</math> will decrease to 0, the game is won, or a new round begins, each with probability <math display="inline>\frac{1}{3}</math>.
#If <math>n=0</math>, then a new round begins.
The probability of winning a round with starting value <math>n</math>, denoted <math>P(n)</math>, is described for <math>n\ge2</math> by the recurrence relation <math display="inline">P(n)=\frac{1}{3}P(n-1)+\frac{2}{3}P(n-2)</math>. The general solution to this equation is <math display="inline">P(n)=c_0+c_1{\Big({-\frac{2}{3}}\Big)}^n</math>, and by using the conditions <math>P(0)=0</math> and <math display="inline">P(1)=\frac{1}{3}</math> we get <math display="inline">P(n)=\frac{1}{5}\Big(1-{\Big({-\frac{2}{3}}\Big)}^n\Big)</math>. This approximately equals <math display="inline">\frac{1}{5}</math> for large <math>n</math>, so the probability of winning the game in <math>r</math> rounds is approximately <math display="inline">1-\Big(\frac{4}{5}\Big)^r</math>, which approaches 1 as <math>r</math> increases.
[[Category:Cryptids]]

Lucy's Moonlight

2025-04-22T11:16:29Z

MrSolis:

{{machine|1RB0RD_0RC1RE_1RD0LA_1LE1LC_1RF0LD_---0RA}}{{TM|1RB0RD_0RC1RE_1RD0LA_1LE1LC_1RF0LD_---0RA}}

'''Lucy's Moonlight''' is a [[BB(6)]] [[Cryptid]]. This [[Turing machine]] was first mentioned [https://discord.com/channels/960643023006490684/1239205785913790465/1345551751016878272 on Discord] by Racheline on 1 Mar 2025, who afterward found a set of [https://discord.com/channels/960643023006490684/1345810396136865822/1345820781363597312 high-level rules] describing it. Shawn Ligocki later discovered and [https://discord.com/channels/960643023006490684/1345810396136865822/1346329322851401868 shared] a more refined set of rules, displayed below.
<div style="width: fit-content; text-align: center; margin-left: auto; margin-right: auto;">
{|class="wikitable" style="margin-left: auto; margin-right: auto;"
! !!0!!1
|-
!A
|1RB
|0RD
|-
!B
|0RC
|1RE
|-
!C
|1RD
|0LA
|-
!D
|1LE
|1LC
|-
!E
|1RF
|0LD
|-
!F
| ---
|0RA
|}
The transition table of Lucy's Moonlight.</div>
==Analysis==
Let <math>C(a,b):=0^\infty\;1011^a\;1^b\;10\;\textrm{C>}\;0^\infty</math>. Then,
<math display="block">\begin{array}{|lll|}\hline C(a+1,3b)&\xrightarrow{12b^2+53b+28}&C(a,8b+6),\\C(a+2,3b+1)&\xrightarrow{12b^2+77b+103}&C(a,8b+16),\\C(a+2,3b+2)&\xrightarrow{12b^2+101b+184}&C(a,8b+22),\\C(0,3b)&\xrightarrow{12b^2+29b+52}&C(2b,8),\\C(0,3b+1)&\xrightarrow{12b^2+53b+30}&C(0,8b+5),\\C(1,3b+1)&\xrightarrow{12b^2+53b+58}&0^\infty\;1011^{2b+4}\;1\;\textrm{F>}\;0^\infty,\\C(0,3b+2)&\xrightarrow{12b^2+53b+28}&C(0,8b+5),\\C(1,3b+2)&\xrightarrow{12b^2+77b+160}&C(2b+4,8).\\\hline\end{array}</math>
<div class="toccolours mw-collapsible mw-collapsed">'''Proof'''<div class="mw-collapsible-content">
Consider the partial configuration <math>P(m,n):=1^m\;10^n\;\textrm{C>}\;0^\infty</math>, which after three steps is <math>1^m\;10^n\;\textrm{<D}\;01\;0^\infty</math>. To advance, this shift rule is required:
<math display="block>\begin{array}{|l|}\hline10^s\;\textrm{<D}\xrightarrow{2s}\textrm{<D}\;01^s\\\hline\end{array}</math>
This means we have <math>1^m\;\textrm{<D}\;01^{n+1}\;0^\infty</math> after <math>2n</math> steps, with <math>1^{m-3}\;0\;\textrm{D>}\;01^{n+2}\;0^\infty</math> after three further steps. From here, we can use the fact that <math>0\;\textrm{D>}\;01^s</math> becomes <math>100\;\textrm{D>}\;01^{s-1}</math> in four steps if <math>s\ge1</math> to get this rule:
<math display="block>\begin{array}{|l|}\hline0\;\textrm{D>}\;01^s\xrightarrow{4s}10^s\;0\;\textrm{D>}\\\hline\end{array}</math>
Using this rule produces <math>1^{m-3}\;10^{n+2}\;0\;\textrm{D>}\;0^\infty</math> in <math>4n+8</math> steps. With five more steps, we get <math>1^{m-3}\;10^{n+4}\;\textrm{C>}\;0^\infty</math>, which is also <math>P(m-3,n+4)</math>. To summarize:
<math display="block>\begin{array}{|l|}\hline P(m,n)\xrightarrow{6n+19}P(m-3,n+4)\text{ if }m\ge3.\\\hline\end{array}</math>
With <math>C(a,b)</math> we have <math>P(b,1)</math> and are able to apply this rule <math display="inline">\Big\lfloor\frac{b}{3}\Big\rfloor</math> times, with three possible scenarios:
#If <math>b\equiv0\ (\operatorname{mod}3)</math>, then in <math display="inline">{\displaystyle\sum_{i=0}^{b/3-1}(6(1+4i)+19)}=\frac{4}{3}b^2+\frac{13}{3}b</math> steps we arrive at <math display="inline">P\Big(0,1+\frac{4b}{3}\Big)</math>. The matching complete configuration is <math>0^\infty\;1011^a\;10^{1+4b/3}\;\textrm{C>}\;0^\infty</math>. In <math display="inline">\frac{8}{3}b+5</math> steps we have <math>0^\infty\;1011^a\;\textrm{<D}\;01^{2+4b/3}\;0^\infty</math>, followed by <math>0^\infty\;1011^{a-1}\;11\;\textrm{B>}\;01^{3+4b/3}\;0^\infty</math> after three steps. We note that if <math>s\ge 2</math>, then <math>\textrm{B>}\;01^s</math> becomes <math>11\;\textrm{B>}\;01^{s-1}</math> in 8 steps, giving this transition rule:<math display="block>\begin{array}{|l|}\hline\textrm{B>}\;01^s \xrightarrow{8s-4}1^{2s-1}\;0\;\textrm{C>}\text{ if }s\ge1.\\\hline\end{array}</math>In this instance, the result is <math>0^\infty\;1011^{a-1}\;1^{7+8b/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(a-1,\frac{8}{3}b+6\Big)</math>, after <math display="inline">\frac{32}{3}b+20</math> steps. This gives a total of <math display="inline">\frac{4}{3}b^2+\frac{53}{3}b+28</math> steps.
#We can rewrite <math>C(a,b)</math> as <math>0^\infty\;1011^{a-1}\;10\;1^{b+2}\;10\;\textrm{C>}\;0^\infty</math> if <math>a\ge 1</math>. Given this, we have <math>P(b+2,1)</math>, and if <math>b\equiv1\ (\operatorname{mod}3)</math>, then in <math display="inline">\frac{4}{3}b^2+\frac{29}{3}b+14</math> steps we arrive at <math>0^\infty\;1011^{a-1}\;10^{(4b+14)/3}\;\textrm{C>}\;0^\infty</math>, which in <math display="inline">\frac{8b+37}{3}</math> steps becomes <math>0^\infty\;1011^{a-1}\;\textrm{<D}\;01^{(4b+17)/3}\;0^\infty</math>, and then <math>0^\infty\;1011^{a-2}\;11\;\textrm{B>}\;01^{(4b+20)/3}\;0^\infty</math> after three more steps. We end with <math display="inline">\frac{32b+148}{3}</math> steps to get <math>0^\infty\;1011^{a-2}\;1^{(8b+43)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(a-2,\frac{8b+40}{3}\Big)</math>. This gives a total of <math display="inline">\frac{4}{3}b^2+23b+\frac{236}{3}</math> steps.
#If <math>b\equiv2\ (\operatorname{mod}3)</math> and we reuse the technique of rewriting <math>C(a,b)</math>, then in <math display="inline">\frac{4}{3}b^2+7b+\frac{17}{3}</math> steps we arrive at <math>0^\infty\;1011^{a-1}\;101\;10^{(4b+7)/3}\;\textrm{C>}\;0^\infty</math>, which in <math display="inline">\frac{8b+23}{3}</math> steps becomes <math>0^\infty\;1011^{a-1}\;101\;\textrm{<D}\;01^{(4b+10)/3}\;0^\infty</math>, and then in five steps, <math>0^\infty\;1011^{a-1}\;0\;\textrm{D>}\;01^{(4b+13)/3}\;0^\infty</math>. Adding <math display="inline">\frac{16b+52}{3}</math> steps gives us <math>0^\infty\;1011^{a-1}\;10^{(4b+13)/3}\;0\;\textrm{D>}\;0^\infty</math>, and another eight gives us <math>0^\infty\;1011^{a-1}\;10^{(4b+19)/3}\;\textrm{<D}\;01\;0^\infty</math>. After <math display="inline">\frac{8b+38}{3}</math> steps, the configuration is <math>0^\infty\;1011^{a-1}\;\textrm{<D}\;01^{(4b+22)/3}\;0^\infty</math> and after three more, <math>0^\infty\;1011^{a-2}\;11\;\textrm{B>}\;01^{(4b+25)/3}\;0^\infty</math>. We conclude with <math>0^\infty\;1011^{a-2}\;1^{(8b+53)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(a-2,\frac{8b+50}{3}\Big)</math>, after <math display="inline">\frac{32b+188}{3}</math> steps, for a total of <math display="inline">\frac{4}{3}b^2+\frac{85}{3}b+122</math> steps.
The behaviour of Lucy's Moonlight changes at the boundary conditions: <math>a=0</math> or <math>a=1</math>. These changes are addressed below:
#If <math>a=0</math> and <math>b\equiv0\ (\operatorname{mod}3)</math>, then starting from <math>0^\infty\;\textrm{<D}\;01^{2+4b/3}\;0^\infty</math>, we take three steps to get <math>0^\infty\;10\;\textrm{A>}\;01^{2+4b/3}\;0^\infty</math>. It is here that another shift rule must come into use:<math display="block">\begin{array}{|l|}\hline\textrm{A>}\;01^{2s}\xrightarrow{4s}1110^s\;\textrm{A>}\\\hline\end{array}</math>Upon using this shift rule, we get <math>0^\infty\;10\;1110^{1+2b/3}\;\textrm{A>}\;0^\infty</math> in <math display="inline">\frac{8}{3}b+4</math> steps. This configuration is the same as <math>0^\infty\;1011^{1+2b/3}\;10\;\textrm{A>}\;0^\infty</math>. With 40 more steps, we end at <math>0^\infty\;1011^{2b/3}\;1^9\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(\frac{2}{3}b,8\Big)</math>, for a total of <math display="inline">\frac{4}{3}b^2+\frac{29}{3}b+52</math> steps.
#If <math>a=0</math> and <math>b\equiv1\ (\operatorname{mod}3)</math>, then in <math display="inline">\frac{4}{3}b^2+\frac{5}{3}b-3</math> steps we arrive at <math>0^\infty\;1\;10^{(4b-1)/3}\;\textrm{C>}\;0^\infty</math>. With <math display="inline">\frac{8b+7}{3}</math> more steps we now have <math>0^\infty\;1\;\textrm{<D}\;01^{(4b+2)/3}\;0^\infty</math>. Given five steps, the result is <math>0^\infty\;1\;\textrm{B>}\;01^{(4b+5)/3}\;0^\infty</math>, which turns into <math>0^\infty\;1^{(8b+10)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(0,\frac{8b+7}{3}\Big)</math> in <math display="inline">\frac{32b+28}{3}</math> steps for a total of <math display="inline">\frac{4}{3}b^2+15b+\frac{41}{3}</math> steps.
#If <math>a=1</math> and <math>b\equiv1\ (\operatorname{mod}3)</math>, then starting from <math>0^\infty\;\textrm{<D}\;01^{(4b+17)/3}\;0^\infty</math>, we get <math>0^\infty\;10\;\textrm{A>}\;01^{(4b+17)/3}\;0^\infty</math> in three steps. Since <math>01^{(4b+17)/3}</math> and <math>01^{(4b+14)/3}\;01</math> are the same, what follows is <math>0^\infty\;1011^{(2b+7)/3}\;10\;\textrm{A>}\;01\;0^\infty</math> in <math display="inline">\frac{8b+28}{3}</math> steps before finally reaching <math>0^\infty\;1011^{(2b+10)/3}\;1\;\textrm{F>}\;0^\infty</math>, and therefore the undefined <code>F0</code> transition, in three steps. This gives a total of <math display="inline">\frac{4}{3}b^2+15b+\frac{125}{3}</math> steps.
#If <math>a=0</math> and <math>b\equiv2\ (\operatorname{mod}3)</math>, then in <math display="inline">\frac{4}{3}b^2-b-\frac{10}{3}</math> steps we arrive at <math>0^\infty\;11\;10^{(4x-5)/3}\;\textrm{C>}\;0^\infty</math>. It takes a further <math display="inline">\frac{8b-1}{3}</math> steps to reach <math>0^\infty\;11\;\textrm{<D}\;01^{(4b-2)/3}\;0^\infty</math>, and adding three more gives us <math>0^\infty\;1\;\textrm{B>}\;01^{(4b+1)/3}\;0^\infty</math>. With <math display="inline">\frac{32b-4}{3}</math> more steps we end up with <math>0^\infty\;1^{(8b+2)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(0,\frac{8b-1}{3}\Big)</math>. This gives a total of <math display="inline">\frac{4}{3}b^2+\frac{37}{3}b-2</math> steps.
#If <math>a=1</math> and <math>b\equiv2\ (\operatorname{mod}3)</math>, then starting from <math>0^\infty\;\textrm{<D}\;01^{(4b+22)/3}\;0^\infty</math>, we take three steps to get <math>0^\infty\;10\;\textrm{A>}\;01^{(4b+22)/3}\;0^\infty</math>, and taking <math display="inline">\frac{8b+44}{3}</math> more steps produces <math>0^\infty\;1011^{(2b+11)/3}\;10\;\textrm{A>}\;0^\infty</math>. After 40 steps, we reach <math>0^\infty\;1011^{(2b+8)/3}\;1^9\;0\;\textrm{C>}\;0^\infty</math>, which is <math display="inline">C\Big(\frac{2b+8}{3},8\Big)</math>, for a total of <math display="inline">\frac{4}{3}b^2+\frac{61}{3}b+114</math> steps.
The information above can be summarized as
<math display="block">C(a,b)\rightarrow\begin{cases}C\Big(a-1,\frac{8}{3}b+6\Big)&\text{if }a\ge1\text{ and }b\equiv0\pmod{3},\\C\Big(a-2,\frac{8b+40}{3}\Big)&\text{if }a\ge2\text{ and }b\equiv1\pmod{3},\\C\Big(a-2,\frac{8b+50}{3}\Big)&\text{if }a\ge2\text{ and }b\equiv2\pmod{3},\\C\Big(\frac{2}{3}b,8\Big)&\text{if }a=0\text{ and }b\equiv0\pmod{3},\\C\Big(0,\frac{8b+7}{3}\Big)&\text{if }a=0\text{ and }b\equiv1\pmod{3},\\0^\infty\;1011^{(2b+10)/3}\;1\;\textrm{F>}\;0^\infty&\text{if }a=1\text{ and }b\equiv1\pmod{3},\\C\Big(0,\frac{8b-1}{3}\Big)&\text{if }a=0\text{ and }b\equiv2\pmod{3},\\C\Big(\frac{2b+8}{3},8\Big)&\text{if }a=1\text{ and }b\equiv2\pmod{3}.\end{cases}</math>
Substituting <math>b=3b+k</math>, where <math>k</math> is the remainder of <math>b</math> modulo 3, yields the final result.
</div></div>
These rules imply a sequence <math>G_n</math> that grows tetrationally in <math>n</math>, which Lucy's Moonlight iterates through one by one. For each <math>g\in G_n</math>, it reaches the configuration <math>C(g,8)</math> and then repeatedly applies the first three rules until meeting a configuration <math>C(g',q)</math> that satisfies the boundary conditions. If <math>g'=1</math> and <math>q</math> is congruent to 1 modulo 3, then Lucy's Moonlight will halt; otherwise, it moves on to the next term in <math>G_n</math>.
==Trajectory==
Starting with <math>C(0,0)</math> after two steps, Lucy's Moonlight repeatedly applies the [[Collatz-like]] rules. The first few steps are shown below:
<math display="block">\begin{array}{|l|}\hline C(0,0)\xrightarrow{52}C(0,8)\xrightarrow{182}C(0,21)\xrightarrow{843}C(14,8)\xrightarrow{434}C(12,38)\xrightarrow{3124}C(10,118)\xrightarrow{21358}C(8,328)\rightarrow\cdots\\\hline\end{array}</math>
From <math>C(0,0)</math>, it takes 11 rule steps to get <math>C(11292,8)</math> and 6811 more to get <math>C(G_3,8)</math>, where <math>G_3\approx 8.282\times10^{2901}</math>. Despite this rapid growth, Lucy's Moonlight appears to be [[probviously]] halting if one considers each instance of <math>C(g,8)</math> as the beginning of an independent round of a luck-based game, detailed below:
#A large number <math>n</math> is generated randomly.
#At each time unit, <math>n</math> will decrease by 1 with probability <math display="inline">\frac{1}{3}</math> or decrease by 2 with probability <math display="inline">\frac{2}{3}</math> provided that <math>n\ge2</math>.
#If <math>n=1</math>, then <math>n</math> will decrease to 0, the game is won, or a new round begins, each with probability <math display="inline>\frac{1}{3}</math>.
#If <math>n=0</math>, then a new round begins.
The probability of winning a round with starting value <math>n</math>, denoted <math>P(n)</math>, is described for <math>n\ge2</math> by the recurrence relation <math display="inline">P(n)=\frac{1}{3}P(n-1)+\frac{2}{3}P(n-2)</math>. The general solution to this equation is <math display="inline">P(n)=c_0+c_1{\Big({-\frac{2}{3}}\Big)}^n</math>, and by using the conditions <math>P(0)=0</math> and <math display="inline">P(1)=\frac{1}{3}</math> we get <math display="inline">P(n)=\frac{1}{5}\Big(1-{\Big({-\frac{2}{3}}\Big)}^n\Big)</math>. This approximately equals <math display="inline">\frac{1}{5}</math> for large <math>n</math>, so the probability of winning the game in <math>r</math> rounds is approximately <math display="inline">1-\Big(\frac{4}{5}\Big)^r</math>, which approaches 1 as <math>r</math> increases.
[[Category:Cryptids]]

Lucy's Moonlight

2025-04-21T22:12:52Z

MrSolis: "tetrational" is an ambiguous term (there is no single exponentiation rule like f(x)=2^x that is repeated to cause tetrational growth); edited wording in the Analysis section to clarify meaning, also reworked Trajectory section

{{machine|1RB0RD_0RC1RE_1RD0LA_1LE1LC_1RF0LD_---0RA}}{{TM|1RB0RD_0RC1RE_1RD0LA_1LE1LC_1RF0LD_---0RA}}

'''Lucy's Moonlight''' is a [[BB(6)]] [[Cryptid]]. This [[Turing machine]] was first mentioned [https://discord.com/channels/960643023006490684/1239205785913790465/1345551751016878272 on Discord] by Racheline on 1 Mar 2025, who afterward found a set of [https://discord.com/channels/960643023006490684/1345810396136865822/1345820781363597312 high-level rules] describing it. Shawn Ligocki later discovered and [https://discord.com/channels/960643023006490684/1345810396136865822/1346329322851401868 shared] a more refined set of rules, displayed below.
<div style="width: fit-content; text-align: center; margin-left: auto; margin-right: auto;">
{|class="wikitable" style="margin-left: auto; margin-right: auto;"
! !!0!!1
|-
!A
|1RB
|0RD
|-
!B
|0RC
|1RE
|-
!C
|1RD
|0LA
|-
!D
|1LE
|1LC
|-
!E
|1RF
|0LD
|-
!F
| ---
|0RA
|}
The transition table of Lucy's Moonlight.</div>
==Analysis==
Let <math>C(a,b):=0^\infty\;1011^a\;1^b\;10\;\textrm{C>}\;0^\infty</math>. Then,
<math display="block">\begin{array}{|lll|}\hline C(a+1,3b)&\xrightarrow{12b^2+53b+28}&C(a,8b+6),\\C(a+2,3b+1)&\xrightarrow{12b^2+77b+103}&C(a,8b+16),\\C(a+2,3b+2)&\xrightarrow{12b^2+101b+184}&C(a,8b+22),\\C(0,3b)&\xrightarrow{12b^2+29b+52}&C(2b,8),\\C(0,3b+1)&\xrightarrow{12b^2+53b+30}&C(0,8b+5),\\C(1,3b+1)&\xrightarrow{12b^2+53b+58}&0^\infty\;1011^{2b+4}\;1\;\textrm{F>}\;0^\infty,\\C(0,3b+2)&\xrightarrow{12b^2+53b+28}&C(0,8b+5),\\C(1,3b+2)&\xrightarrow{12b^2+77b+160}&C(2b+4,8).\\\hline\end{array}</math>
<div class="toccolours mw-collapsible mw-collapsed">'''Proof'''<div class="mw-collapsible-content">
Consider the partial configuration <math>P(m,n):=1^m\;10^n\;\textrm{C>}\;0^\infty</math>, which after three steps is <math>1^m\;10^n\;\textrm{<D}\;01\;0^\infty</math>. To advance, this shift rule is required:
<math display="block>\begin{array}{|l|}\hline10^s\;\textrm{<D}\xrightarrow{2s}\textrm{<D}\;01^s\\\hline\end{array}</math>
This means we have <math>1^m\;\textrm{<D}\;01^{n+1}\;0^\infty</math> after <math>2n</math> steps, with <math>1^{m-3}\;0\;\textrm{D>}\;01^{n+2}\;0^\infty</math> after three further steps. From here, we can use the fact that <math>0\;\textrm{D>}\;01^s</math> becomes <math>100\;\textrm{D>}\;01^{s-1}</math> in four steps if <math>s\ge1</math> to get this rule:
<math display="block>\begin{array}{|l|}\hline0\;\textrm{D>}\;01^s\xrightarrow{4s}10^s\;0\;\textrm{D>}\\\hline\end{array}</math>
Using this rule produces <math>1^{m-3}\;10^{n+2}\;0\;\textrm{D>}\;0^\infty</math> in <math>4n+8</math> steps. With five more steps, we get <math>1^{m-3}\;10^{n+4}\;\textrm{C>}\;0^\infty</math>, which is also <math>P(m-3,n+4)</math>. To summarize:
<math display="block>\begin{array}{|l|}\hline P(m,n)\xrightarrow{6n+19}P(m-3,n+4)\text{ if }m\ge3.\\\hline\end{array}</math>
With <math>C(a,b)</math> we have <math>P(b,1)</math> and are able to apply this rule <math display="inline">\Big\lfloor\frac{b}{3}\Big\rfloor</math> times, with three possible scenarios:
#If <math>b\equiv0\ (\operatorname{mod}3)</math>, then in <math display="inline">{\displaystyle\sum_{i=0}^{b/3-1}(6(1+4i)+19)}=\frac{4}{3}b^2+\frac{13}{3}b</math> steps we arrive at <math display="inline">P\Big(0,1+\frac{4b}{3}\Big)</math>. The matching complete configuration is <math>0^\infty\;1011^a\;10^{1+4b/3}\;\textrm{C>}\;0^\infty</math>. In <math display="inline">\frac{8}{3}b+5</math> steps we have <math>0^\infty\;1011^a\;\textrm{<D}\;01^{2+4b/3}\;0^\infty</math>, followed by <math>0^\infty\;1011^{a-1}\;11\;\textrm{B>}\;01^{3+4b/3}\;0^\infty</math> after three steps. We note that if <math>s\ge 2</math>, then <math>\textrm{B>}\;01^s</math> becomes <math>11\;\textrm{B>}\;01^{s-1}</math> in 8 steps, giving this transition rule:<math display="block>\begin{array}{|l|}\hline\textrm{B>}\;01^s \xrightarrow{8s-4}1^{2s-1}\;0\;\textrm{C>}\text{ if }s\ge1.\\\hline\end{array}</math>In this instance, the result is <math>0^\infty\;1011^{a-1}\;1^{7+8b/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(a-1,\frac{8}{3}b+6\Big)</math>, after <math display="inline">\frac{32}{3}b+20</math> steps. This gives a total of <math display="inline">\frac{4}{3}b^2+\frac{53}{3}b+28</math> steps.
#We can rewrite <math>C(a,b)</math> as <math>0^\infty\;1011^{a-1}\;10\;1^{b+2}\;10\;\textrm{C>}\;0^\infty</math> if <math>a\ge 1</math>. Given this, we have <math>P(b+2,1)</math>, and if <math>b\equiv1\ (\operatorname{mod}3)</math>, then in <math display="inline">\frac{4}{3}b^2+\frac{29}{3}b+14</math> steps we arrive at <math>0^\infty\;1011^{a-1}\;10^{(4b+14)/3}\;\textrm{C>}\;0^\infty</math>, which in <math display="inline">\frac{8b+37}{3}</math> steps becomes <math>0^\infty\;1011^{a-1}\;\textrm{<D}\;01^{(4b+17)/3}\;0^\infty</math>, and then <math>0^\infty\;1011^{a-2}\;11\;\textrm{B>}\;01^{(4b+20)/3}\;0^\infty</math> after three more steps. We end with <math display="inline">\frac{32b+148}{3}</math> steps to get <math>0^\infty\;1011^{a-2}\;1^{(8b+43)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(a-2,\frac{8b+40}{3}\Big)</math>. This gives a total of <math display="inline">\frac{4}{3}b^2+23b+\frac{236}{3}</math> steps.
#If <math>b\equiv2\ (\operatorname{mod}3)</math> and we reuse the technique of rewriting <math>C(a,b)</math>, then in <math display="inline">\frac{4}{3}b^2+7b+\frac{17}{3}</math> steps we arrive at <math>0^\infty\;1011^{a-1}\;101\;10^{(4b+7)/3}\;\textrm{C>}\;0^\infty</math>, which in <math display="inline">\frac{8b+23}{3}</math> steps becomes <math>0^\infty\;1011^{a-1}\;101\;\textrm{<D}\;01^{(4b+10)/3}\;0^\infty</math>, and then in five steps, <math>0^\infty\;1011^{a-1}\;0\;\textrm{D>}\;01^{(4b+13)/3}\;0^\infty</math>. Adding <math display="inline">\frac{16b+52}{3}</math> steps gives us <math>0^\infty\;1011^{a-1}\;10^{(4b+13)/3}\;0\;\textrm{D>}\;0^\infty</math>, and another eight gives us <math>0^\infty\;1011^{a-1}\;10^{(4b+19)/3}\;\textrm{<D}\;01\;0^\infty</math>. After <math display="inline">\frac{8b+38}{3}</math> steps, the configuration is <math>0^\infty\;1011^{a-1}\;\textrm{<D}\;01^{(4b+22)/3}\;0^\infty</math> and after three more, <math>0^\infty\;1011^{a-2}\;11\;\textrm{B>}\;01^{(4b+25)/3}\;0^\infty</math>. We conclude with <math>0^\infty\;1011^{a-2}\;1^{(8b+53)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(a-2,\frac{8b+50}{3}\Big)</math>, after <math display="inline">\frac{32b+188}{3}</math> steps, for a total of <math display="inline">\frac{4}{3}b^2+\frac{85}{3}b+122</math> steps.
The behaviour of Lucy's Moonlight changes at the boundary conditions: <math>a=0</math> or <math>a=1</math>. These changes are addressed below:
#If <math>a=0</math> and <math>b\equiv0\ (\operatorname{mod}3)</math>, then starting from <math>0^\infty\;\textrm{<D}\;01^{2+4b/3}\;0^\infty</math>, we take three steps to get <math>0^\infty\;10\;\textrm{A>}\;01^{2+4b/3}\;0^\infty</math>. It is here that another shift rule must come into use:<math display="block">\begin{array}{|l|}\hline\textrm{A>}\;01^{2s}\xrightarrow{4s}1110^s\;\textrm{A>}\\\hline\end{array}</math>Upon using this shift rule, we get <math>0^\infty\;10\;1110^{1+2b/3}\;\textrm{A>}\;0^\infty</math> in <math display="inline">\frac{8}{3}b+4</math> steps. This configuration is the same as <math>0^\infty\;1011^{1+2b/3}\;10\;\textrm{A>}\;0^\infty</math>. With 40 more steps, we end at <math>0^\infty\;1011^{2b/3}\;1^9\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(\frac{2}{3}b,8\Big)</math>, for a total of <math display="inline">\frac{4}{3}b^2+\frac{29}{3}b+52</math> steps.
#If <math>a=0</math> and <math>b\equiv1\ (\operatorname{mod}3)</math>, then in <math display="inline">\frac{4}{3}b^2+\frac{5}{3}b-3</math> steps we arrive at <math>0^\infty\;1\;10^{(4b-1)/3}\;\textrm{C>}\;0^\infty</math>. With <math display="inline">\frac{8b+7}{3}</math> more steps we now have <math>0^\infty\;1\;\textrm{<D}\;01^{(4b+2)/3}\;0^\infty</math>. Given five steps, the result is <math>0^\infty\;1\;\textrm{B>}\;01^{(4b+5)/3}\;0^\infty</math>, which turns into <math>0^\infty\;1^{(8b+10)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(0,\frac{8b+7}{3}\Big)</math> in <math display="inline">\frac{32b+28}{3}</math> steps for a total of <math display="inline">\frac{4}{3}b^2+15b+\frac{41}{3}</math> steps.
#If <math>a=1</math> and <math>b\equiv1\ (\operatorname{mod}3)</math>, then starting from <math>0^\infty\;\textrm{<D}\;01^{(4b+17)/3}\;0^\infty</math>, we get <math>0^\infty\;10\;\textrm{A>}\;01^{(4b+17)/3}\;0^\infty</math> in three steps. Since <math>01^{(4b+17)/3}</math> and <math>01^{(4b+14)/3}\;01</math> are the same, what follows is <math>0^\infty\;1011^{(2b+7)/3}\;10\;\textrm{A>}\;01\;0^\infty</math> in <math display="inline">\frac{8b+28}{3}</math> steps before finally reaching <math>0^\infty\;1011^{(2b+10)/3}\;1\;\textrm{F>}\;0^\infty</math>, and therefore the undefined <code>F0</code> transition, in three steps. This gives a total of <math display="inline">\frac{4}{3}b^2+15b+\frac{125}{3}</math> steps.
#If <math>a=0</math> and <math>b\equiv2\ (\operatorname{mod}3)</math>, then in <math display="inline">\frac{4}{3}b^2-b-\frac{10}{3}</math> steps we arrive at <math>0^\infty\;11\;10^{(4x-5)/3}\;\textrm{C>}\;0^\infty</math>. It takes a further <math display="inline">\frac{8b-1}{3}</math> steps to reach <math>0^\infty\;11\;\textrm{<D}\;01^{(4b-2)/3}\;0^\infty</math>, and adding three more gives us <math>0^\infty\;1\;\textrm{B>}\;01^{(4b+1)/3}\;0^\infty</math>. With <math display="inline">\frac{32b-4}{3}</math> more steps we end up with <math>0^\infty\;1^{(8b+2)/3}\;0\;\textrm{C>}\;0^\infty</math>, equal to <math display="inline">C\Big(0,\frac{8b-1}{3}\Big)</math>. This gives a total of <math display="inline">\frac{4}{3}b^2+\frac{37}{3}b-2</math> steps.
#If <math>a=1</math> and <math>b\equiv2\ (\operatorname{mod}3)</math>, then starting from <math>0^\infty\;\textrm{<D}\;01^{(4b+22)/3}\;0^\infty</math>, we take three steps to get <math>0^\infty\;10\;\textrm{A>}\;01^{(4b+22)/3}\;0^\infty</math>, and taking <math display="inline">\frac{8b+44}{3}</math> more steps produces <math>0^\infty\;1011^{(2b+11)/3}\;10\;\textrm{A>}\;0^\infty</math>. After 40 steps, we reach <math>0^\infty\;1011^{(2b+8)/3}\;1^9\;0\;\textrm{C>}\;0^\infty</math>, which is <math display="inline">C\Big(\frac{2b+8}{3},8\Big)</math>, for a total of <math display="inline">\frac{4}{3}b^2+\frac{61}{3}b+114</math> steps.
The information above can be summarized as
<math display="block">C(a,b)\rightarrow\begin{cases}C\Big(a-1,\frac{8}{3}b+6\Big)&\text{if }a\ge1\text{ and }b\equiv0\pmod{3},\\C\Big(a-2,\frac{8b+40}{3}\Big)&\text{if }a\ge2\text{ and }b\equiv1\pmod{3},\\C\Big(a-2,\frac{8b+50}{3}\Big)&\text{if }a\ge2\text{ and }b\equiv2\pmod{3},\\C\Big(\frac{2}{3}b,8\Big)&\text{if }a=0\text{ and }b\equiv0\pmod{3},\\C\Big(0,\frac{8b+7}{3}\Big)&\text{if }a=0\text{ and }b\equiv1\pmod{3},\\0^\infty\;1011^{(2b+10)/3}\;1\;\textrm{F>}\;0^\infty&\text{if }a=1\text{ and }b\equiv1\pmod{3},\\C\Big(0,\frac{8b-1}{3}\Big)&\text{if }a=0\text{ and }b\equiv2\pmod{3},\\C\Big(\frac{2b+8}{3},8\Big)&\text{if }a=1\text{ and }b\equiv2\pmod{3}.\end{cases}</math>
Substituting <math>b=3b+k</math>, where <math>k</math> is the remainder of <math>b</math> modulo 3, yields the final result.
</div></div>
We can define these functions:
*<math display="inline">f(n)=10n+6-18\Big\lfloor\frac{n}{3}\Big\rfloor-4\Big\lfloor\frac{n+1}{3}\Big\rfloor</math> (the movement of <math>b</math> according to the first three rules)
*<math display="inline">S(n)={\displaystyle\sum_{i=0}^n}\bigg(1+\bigg\lfloor\frac{f^i(8)+1-3\lfloor f^{i}(8)/3\rfloor}{2}\bigg\rfloor\bigg)</math> (which imitates <math>a</math> decreasing, with <math>f^i(n)</math> representing function iteration)
*<math>M_f(n)=\min\{k\in \mathbb{N}:(f^k(8)\equiv0\ (\operatorname{mod}3)\land S(k-1)= n)\lor (f^k(8)\not\equiv 0\ (\operatorname{mod}3)\land S(k-1)\ge n-1)\}</math> (the number of iterations of <math>f(n)</math> needed to reach a boundary condition)
*<math display="inline">g(n)=8\Big\lfloor\frac{n-1}{3}\Big\rfloor+5</math> (representing rules 5 and 7)
*<math display="inline">M_g(n)=\min\{k\in\mathbb{N}:g^{k}(n)\equiv0\ (\operatorname{mod}3)\}</math> (the amount of times <math>g(n)</math> must be applied to reach a multiple of 3)
*<math>q(n)=f^{M_f(n)}(8)</math>
Using these functions, we can recursively describe a sequence that grows tetrationally, denoted <math>c_n</math>:
<math display="block">\textstyle c_0=0,\qquad c_{n+1}=(c_n-S(M_f(c_n)-1))\times\frac{2q(c_n)+8}{3}+(1-c_n+S(M_f(c_n)-1))\times\frac{2}{3}g^{M_g(q(c_n))}(q(c_n)).</math>
In effect, Lucy's Moonlight iterates through <math>c_n</math> one by one. For each <math>c\in c_n</math>, it reaches the configuration <math>C(c,8)</math> and tests whether <math>c-S(M_f(c)-1)=1</math> and <math>q(c_n)\equiv1\ (\operatorname{mod}3)</math>. If so, then Lucy's Moonlight will halt; otherwise, it moves on to the next term in <math>c_n</math>.
==Trajectory==
Starting with <math>C(0,0)</math> after two steps, Lucy's Moonlight repeatedly applies the [[Collatz-like]] rules. The first few steps are shown below:
<math display="block">\begin{array}{|l|}\hline C(0,0)\xrightarrow{52}C(0,8)\xrightarrow{182}C(0,21)\xrightarrow{843}C(14,8)\xrightarrow{434}C(12,38)\xrightarrow{3124}C(10,118)\xrightarrow{21358}C(8,328)\rightarrow\cdots\\\hline\end{array}</math>
From <math>C(0,0)</math>, it takes 11 rule steps to get <math>C(11292,8)</math> and 6811 more to get <math>C(c_3,8)</math>, where <math>c_3\approx 8.282\times10^{2901}</math>. Despite this rapid growth, Lucy's Moonlight appears to be [[probviously]] halting if one considers each instance of <math>C(c,8)</math> as the beginning of an independent round of a luck-based game, detailed below:
#A large number <math>n</math> is generated randomly.
#At each time unit, <math>n</math> will decrease by 1 with probability <math display="inline">\frac{1}{3}</math> or decrease by 2 with probability <math display="inline">\frac{2}{3}</math> provided that <math>n\ge2</math>.
#If <math>n=1</math>, then <math>n</math> will decrease to 0, the game is won, or a new round begins, each with probability <math display="inline>\frac{1}{3}</math>.
#If <math>n=0</math>, then a new round begins.
The probability of winning a round with starting value <math>n</math>, denoted <math>P(n)</math>, is described for <math>n\ge2</math> by the recurrence relation <math display="inline">P(n)=\frac{1}{3}P(n-1)+\frac{2}{3}P(n-2)</math>. The general solution to this equation is <math display="inline">P(n)=c_0+c_1{\Big({-\frac{2}{3}}\Big)}^n</math>, and by using the conditions <math>P(0)=0</math> and <math display="inline">P(1)=\frac{1}{3}</math> we get <math display="inline">P(n)=\frac{1}{5}\Big(1-{\Big({-\frac{2}{3}}\Big)}^n\Big)</math>. This approximately equals <math display="inline">\frac{1}{5}</math> for large <math>n</math>, so the probability of winning the game in <math>r</math> rounds is approximately <math display="inline">1-\Big(\frac{4}{5}\Big)^r</math>, which approaches 1 as <math>r</math> increases.
[[Category:Cryptids]]

Antihydra

2025-04-14T22:12:55Z

MrSolis: Changed the Antihydra page to be more in line with my other TM pages

{{machine|1RB1RA_0LC1LE_1LD1LC_1LA0LB_1LF1RE_---0RA}}{{unsolved|Does Antihydra run forever?}}{{TM|1RB1RA_0LC1LE_1LD1LC_1LA0LB_1LF1RE_---0RA|undecided}}
'''Antihydra''' is a [[BB(6)]] [[Cryptid]]. Its pseudo-random behaviour was first reported [https://discord.com/channels/960643023006490684/1026577255754903572/1256223215206924318 on Discord] by mxdys on 28 June 2024, and Racheline discovered the high-level rules soon after. It was named after the 2-state, 5-symbol [[Turing machine]] called [[Hydra]] for sharing many similarities to it.<ref>[https://discord.com/channels/960643023006490684/960643023530762341/1257053002859286701 Discord conversation where the machine was named]</ref>
<table style="margin: auto; text-align: center;"><tr><td style="width: 200px;">[[File:Antihydra-depiction.png|200px]]<br>Artistic depiction of Antihydra by Jadeix</td><td>      </td><td>
{|class="wikitable" style="margin-left: auto; margin-right: auto;"
! !!0!!1
|-
!A
|1RB
|1RA
|-
!B
|0LC
|1LE
|-
!C
|1LD
|1LC
|-
!D
|1LA
|0LB
|-
!E
|1LF
|1RE
|-
!F
| ---
|0RA
|}
The transition table of Antihydra.
</td><td>      </td><td style="width: 220px;">[[File:Antihydra award.jpg|220px]]<br>A community trophy - to be awarded to the first person or group who solves the Antihydra problem
</td></tr></table></div>
== Analysis ==
Let <math>A(a,b):=0^\infty\;1^a\;0\;1^b\;\textrm{E>}\;0^\infty</math>. Then,<ref name="bl">S. Ligocki, "[https://www.sligocki.com/2024/07/06/bb-6-2-is-hard.html BB(6) is Hard (Antihydra)]" (2024). Accessed 22 July 2024.</ref>
<math display="block">\begin{array}{|lll|}\hline
A(a,2b)& \xrightarrow{2a+3b^2+12b+11}& A(a+2,3b+2),\\
A(0,2b+1)&\xrightarrow{3b^2+9b-1}& 0^\infty\;\textrm{<F}\;110\;1^{3b}\;0^\infty,\\
A(a+1,2b+1)&\xrightarrow{3b^2+12b+5}& A(a,3b+3).\\\hline
\end{array}</math>
<div class="toccolours mw-collapsible mw-collapsed">'''Proof'''<div class="mw-collapsible-content">
Consider the partial configuration <math>P(m,n):=0\;1^m\;\textrm{E>}\;0\;1^n\;0^\infty</math>. The configuration after two steps is <math>0\;1^{m-1}\;0\;\textrm{A>}\;1^{n+1}\;0^\infty</math>. We note the following shift rule:
<math display="block">\begin{array}{|c|}\hline\textrm{A>}\;1^s\xrightarrow{s}1^s\;\textrm{A>}\\\hline\end{array}</math>
As a result, we get <math>0\;1^{m-1}\;0\;1^{n+1}\;\textrm{A>}\;0^\infty</math> after <math>n+1</math> steps. Advancing two steps produces <math>0\;1^{m-1}\;0\;1^{n+2}\;\textrm{<C}\;0^\infty</math>. A second shift rule is useful here:
<math display="block">\begin{array}{|c|}\hline1^s\;\textrm{<C}\xrightarrow{s}\textrm{<C}\;1^s\\\hline\end{array}</math>
This allows us to reach <math>0\;1^{m-1}\;0\;\textrm{<C}\;1^{n+2}\;0^\infty</math> in <math>n+2</math> steps. Moving five more steps gets us to <math>0\;1^{m-2}\;\textrm{E>}\;0\;1^{n+3}\;0^\infty</math>, which is the same configuration as <math>P(m-2,n+3)</math>. Accounting for the head movement creates the condition that <math>m\ge 4</math>. In summary:
<math display="block">\begin{array}{|c|}\hline P(m,n)\xrightarrow{2n+12}P(m-2,n+3)\text{ if }m\ge 4.\\\hline\end{array}</math>
With <math>A(a,b)</math> we have <math>P(b,0)</math>. As a result, we can apply this rule <math display="inline>\big\lfloor\frac{1}{2}b\big\rfloor-1</math> times (assuming <math>b\ge 4</math>), which creates two possible scenarios:
#If <math>b\equiv0\ (\operatorname{mod}2)</math>, then in <math>\sum_{i=0}^{(b/2)-2}(2\times 3i+12)=\textstyle\frac{3}{4}b^2+\frac{3}{2}b-6</math> steps we arrive at <math display="inline">P\Big(2,\frac{3}{2}b-3\Big)</math>. The matching complete configuration is <math>0^\infty\;1^a\;011\;\textrm{E>}\;0\;1^{(3b)/2-3}\;0^\infty</math>. After <math>3b+4</math> steps this is <math>0^\infty\;1^a\;\textrm{<C}\;00\;1^{(3b)/2}\;0^\infty</math>, which then leads to <math>0^\infty\;\textrm{<C}\;1^a\;00\;1^{(3b)/2}\;0^\infty</math> in <math>a</math> steps. After five more steps, we reach <math>0^\infty\;1\;\textrm{E>}\;1^{a+2}\;00\;1^{(3b)/2}\;0^\infty</math>, from which another shift rule must be applied:<math display="block">\begin{array}{|c|}\hline\textrm{E>}\;1^s\xrightarrow{s}1^s\;\textrm{E>}\\\hline\end{array}</math>Doing so allows us to get the configuration <math>0^\infty\;1^{a+3}\;\textrm{E>}\;00\;1^{(3b)/2}\;0^\infty</math> in <math>a+2</math> steps. In six steps we have <math>0^\infty\;1^{a+2}\;011\;\textrm{E>}\;1^{(3b)/2}\;0^\infty</math>, so we use the shift rule again, ending at <math>0^\infty\;1^{a+2}\;0\;1^{(3b)/2+2}\;\textrm{E>}\;0^\infty</math>, equal to <math display="inline">A\Big(a+2,\frac{3}{2}b+2\Big)</math>, <math display="inline">\frac{3}{2}b</math> steps later. This gives a total of <math display="inline">2a+\frac{3}{4}b^2+6b+11</math> steps.
#If <math>b\equiv1\ (\operatorname{mod}2)</math>, then in <math display="inline">\frac{3}{4}b^2-\frac{27}{4}</math> steps we arrive at <math display="inline">P\Big(3,\frac{3b-9}{2}\Big)</math>. The matching complete configuration is <math>0^\infty\;1^a\;0111\;\textrm{E>}\;0\;1^{(3b-9)/2}\;0^\infty</math>. After <math>3b+2</math> steps this becomes <math>0^\infty\;1^a\;\textrm{<F}\;110\;1^{(3b-3)/2}\;0^\infty</math>. If <math>a=0</math> then we have reached the undefined <code>F0</code> transition with a total of <math display="inline">\frac{3}{4}b^2+3b-\frac{19}{4}</math> steps. Otherwise, continuing for six steps gives us <math>0^\infty\;1^{a-1}\;0111\;\textrm{E>}\;1^{(3b-3)/2}\;0^\infty</math>. We conclude with the configuration <math>0^\infty\;1^{a-1}\;0\;1^{(3b+3)/2}\;\textrm{E>}\;0^\infty</math>, equal to <math display="inline">A\Big(a-1,\frac{3b+3}{2}\Big)</math>, in <math display="inline">\frac{3b-3}{2}</math> steps. This gives a total of <math display="inline">\frac{3}{4}b^2+\frac{9}{2}b-\frac{1}{4}</math> steps.
The information above can be summarized as
<math display="block">A(a,b)\rightarrow\begin{cases}A\Big(a+2,\frac{3}{2}b+2\Big)&\text{if }b\ge 2,b\equiv0\pmod{2};\\0^\infty\;\textrm{<F}\;110\;1^{(3b-3)/2}\;0^\infty&\text{if }b\ge3,b\equiv1\pmod{2},\text{ and }a=0;\\A\Big(a-1,\frac{3b+3}{2}\Big)&\text{if }b\ge3,b\equiv1\pmod{2},\text{ and }a>0.\end{cases}</math>
Substituting <math>b\leftarrow 2b</math> for the first case and <math>b\leftarrow 2b+1</math> for the other two yields the final result.
</div></div>
In effect, the halting problem for Antihydra is about whether repeatedly applying the function <math display="inline">f(n)=\Big\lfloor\frac{3n}{2}\Big\rfloor+2</math> will at some point produce more odd values of <math>n</math> than twice the number of even values.

These rules can be modified to use the function <math display="inline">H(n)=\Big\lfloor\frac{3n}{2}\Big\rfloor</math>, or the Hydra function, which strengthens Antihydra's similarities to Hydra.
== Trajectory ==
11 steps are required to enter the configuration <math>A(0, 4)</math> before the rules are repeatedly applied. So far, Antihydra has been simulated to <math>2^{31}</math> rule steps, at which point <math>b=1073720884</math>. Here are the first few:
<math display="block">\begin{array}{|c|}\hline A(0,4)\xrightarrow{47}A(2,8)\xrightarrow{111}A(4,14)\xrightarrow{250}A(6,23)\xrightarrow{500}A(5,36)\xrightarrow{1209}A(7,56)\xrightarrow{2713}A(9,86)\rightarrow\cdots\\\hline\end{array}</math>
The trajectory of <math>b</math> values resembles a random walk in which the walker can only move in step sizes +2 or -1 with equal probability, starting at position 0. If <math>P(n)</math> is the probability that the walker will reach position -1 from position <math>n</math>, then it can be seen that <math display="inline">P(n)=\frac{1}{2}P(n-1)+\frac{1}{2}P(n+2)</math>. Solutions to this recurrence relation come in the form <math display="inline"> P(n)=c_0{\left(\frac{\sqrt{5}-1}{2}\right)}^n+c_1+c_2{\left(-\frac{1+\sqrt{5}}{2}\right)}^n</math>, which after applying the appropriate boundary conditions reduces to <math display="inline">P(n)={\left(\frac{\sqrt{5}-1}{2}\right)}^{n+1}</math>. This means that if the walker were to get to position 1073720884 then the probability of it ever reaching position -1 is <math display="inline">{\left(\frac{\sqrt{5}-1}{2}\right)}^{1073720885}\approx 4.841\times 10^{-224394395}</math>. This combined with the fact that the expected position of the walker after <math>k</math> steps is <math display="inline">\frac{1}{2}k</math> strongly suggests Antihydra [[probviously]] runs indefinitely.
==References==
[[Category:Individual machines]][[Category:Cryptids]]

Hydra function

2025-04-14T22:12:13Z

MrSolis: Rewrote Properties Section, added material from the Antihydra page that is better suited here

[[File:Hydra Spiral.png|thumb|185px|A spiral-like figure that gives the first few terms of the Hydra sequences with initial values 2, 5, 8, 11, 14, and 17.]]
The '''Hydra function''' is a [[Collatz-like]] function defined as:
<math display="block">\textstyle H(n)\equiv n+\big\lfloor\frac{1}{2}n\big\rfloor=\Big\lfloor\frac{3}{2}n\Big\rfloor=\begin{cases}
\frac{3n}{2}&\text{if }n\equiv0\pmod{2},\\
\frac{3n-1}{2}&\text{if }n\equiv1\pmod{2}.\\
\end{cases}</math>
It is named as such because of its connection to the unsolved halting problems for the [[Cryptids]] [[Hydra]] and [[Antihydra]]. Due to its simplicity, simulations for both of these [[Turing machines]] utilize this function instead of what can initially be proven.
== Relationship to Hydra and Antihydra==
Using the Hydra function, we can obtain simplified rules for Hydra and Antihydra:
{|class="wikitable"
! Hydra !! Antihydra
|-align="center"
|Let <math>C_H(a,b):=0^\infty\;\textrm{<A}\;2\;0^{3(a-2)}\;3^b\;2\;0^\infty</math>:<math display="block">\begin{array}{|lll|}\hline
0^\infty\;\textrm{A>}\;0^\infty&\xrightarrow{20}&C_H(3,0),\\
C_H(2a,0)&\xrightarrow{54a^2-48a-2}&0^\infty\;3^{9a-8}\;1\;\textrm{A>}\;2\;0^\infty,\\
C_H(2a,b+1)&\xrightarrow{54a^2-39a-5}&C_H(3a,b),\\
C_H(2a+1,b)&\xrightarrow{4b+54a^2-3a+4}&C_H(3a+1,b+2).\\\hline
\end{array}</math>
|Let <math>A_H(a,b):=0^\infty\;1^a\;0\;1^{b-4}\;\textrm{E>}\;0^\infty</math>:<math display="block">\begin{array}{|lll|}\hline
0^\infty\;\textrm{A>}\;0^\infty&\xrightarrow{11}&A_H(0,8),\\
A_H(a,2b)& \xrightarrow{2a+3b^2-1}& A_H(a+2,3b),\\
A_H(0,2b+1)&\xrightarrow{3b^2-3b-7}& 0^\infty\;\textrm{<F}\;110\;1^{3b-6}\;0^\infty,\\
A_H(a+1,2b+1)&\xrightarrow{3b^2-7}& A_H(a,3b+1).\\\hline
\end{array}</math>
|}
<div class="toccolours mw-collapsible mw-collapsed">'''Proof'''<div class="mw-collapsible-content">
Recall the high-level rules for Hydra and Antihydra:
{|class="wikitable"
! Hydra !! Antihydra
|-align="center"
|Let <math>C(a,b):=0^\infty\;\textrm{<A}\;2\;0^a\;3^b\;2\;0^\infty</math>:<math display="block">\begin{array}{|lll|}\hline
0^\infty\;\textrm{A>}\;0^\infty&\xrightarrow{20}&C(3,0),\\
C(2a,0)&\xrightarrow{6a^2+20a+4}&0^\infty\;3^{3a+1}\;1\;\textrm{A>}\;2\;0^\infty,\\
C(2a,b+1)&\xrightarrow{6a^2+23a+10}&C(3a+3,b),\\
C(2a+1,b)&\xrightarrow{4b+6a^2+23a+26}&C(3a+3,b+2).\\\hline
\end{array}</math>
|Let <math>A(a,b):=0^\infty\;1^a\;0\;1^b\;\textrm{E>}\;0^\infty</math>:<math display="block">\begin{array}{|lll|}\hline
0^\infty\;\textrm{A>}\;0^\infty&\xrightarrow{11}&A(0,4),\\
A(a,2b)& \xrightarrow{2a+3b^2+12b+11}& A(a+2,3b+2),\\
A(0,2b+1)&\xrightarrow{3b^2+9b-1}& 0^\infty\;\textrm{<F}\;110\;1^{3b}\;0^\infty,\\
A(a+1,2b+1)&\xrightarrow{3b^2+12b+5}& A(a,3b+3).\\\hline
\end{array}</math>
|}
Already, both machines appear to be very similar. They have one parameter that increases exponentially with growth factor <math display="inline">\frac{3}{2}</math> and another that takes a pseudo-random walk. Below, the exponentially increasing variables are described by integer sequences:
{|class="wikitable"
! Hydra !! Antihydra
|-align="center"
|<math display="block">a_0=3,a_{n+1}=\begin{cases}\frac{3a_n+6}{2}&\text{if }a_n\equiv0\pmod{2}\\\frac{3a_n+3}{2}&\text{if }a_n\equiv1\pmod{2}\end{cases}</math>
|<math display="block">a_0=4,a_{n+1}=\begin{cases}\frac{3a_n+4}{2}&\text{if }a_n\equiv0\pmod{2}\\\frac{3a_n+3}{2}&\text{if }a_n\equiv1\pmod{2}\end{cases}</math>
|}
This will make demonstrating the transformation easier. Now we will define a new integer sequence based on the old one and discover the recursive rules for that sequence. This new sequence is <math display="inline">b_n=\frac{1}{3}a_n+2</math> and <math>b_n=a_n+4</math> for Hydra and Antihydra respectively. We start by using <math>b_{n+1}</math> instead and substituting <math>a_{n+1}</math> for its recursive formula. By doing so, we get:
{|class="wikitable"
! Hydra !! Antihydra
|-align="center"
|<math display="block">b_0=3,b_{n+1}=\begin{cases}\frac{a_n+6}{2}&\text{if }a_n\equiv0\pmod{2}\\\frac{a_n+5}{2}&\text{if }a_n\equiv1\pmod{2}\end{cases}</math>
|<math display="block">b_0=8,b_{n+1}=\begin{cases}\frac{3a_n+12}{2}&\text{if }a_n\equiv0\pmod{2}\\\frac{3a_n+11}{2}&\text{if }a_n\equiv1\pmod{2}\end{cases}</math>
|}
After that, we can substitute <math>a_n</math> for its solution in terms of <math>b_n</math>. What results is the following:
{|class="wikitable"
! Hydra !! Antihydra
|-align="center"
|<math display="block">b_0=3,b_{n+1}=\begin{cases}\frac{3(b_n-2)+6}{2}&\text{if }3(b_n-2)\equiv0\pmod{2}\\\frac{3(b_n-2)+5}{2}&\text{if }3(b_n-2)\equiv1\pmod{2}\end{cases}</math>
|<math display="block">b_0=8,b_{n+1}=\begin{cases}\frac{3(b_n-4)+12}{2}&\text{if }b_n-4\equiv0\pmod{2}\\\frac{3(b_n-4)+11}{2}&\text{if }b_n-4\equiv1\pmod{2}\end{cases}</math>
|}
The <math>\text{if}</math> statements amount to checking if <math>b_n</math> is even or odd. After simplifying, we are done:
{|class="wikitable"
! Hydra !! Antihydra
|-align="center"
|<math display="block">b_0=3,b_{n+1}=\begin{cases}\frac{3b_n}{2}&\text{if }b_n\equiv0\pmod{2}\\\frac{3b_n-1}{2}&\text{if }b_n\equiv1\pmod{2}\end{cases}</math>
|<math display="block">b_0=8,b_{n+1}=\begin{cases}\frac{3b_n}{2}&\text{if }b_n\equiv0\pmod{2}\\\frac{3b_n-1}{2}&\text{if }b_n\equiv1\pmod{2}\end{cases}</math>
|}
Now that we have demonstrated a strong similarity in the behaviour of both Turing machines, we can return to using the high-level rules. Doing that while considering the step counts yields the final result.
</div></div>
Under these rules, the halting problem for Hydra is about whether repeatedly applying the function <math>H(n)</math>, starting with <math>n=3</math>, will eventually generate more even terms than twice the number of odd terms. Similarly, Antihydra halts if and only if repeatedly applying <math>H(n)</math>, starting with <math>n=8</math>, will eventually generate more odd terms than twice the number of even terms.
== Coding the Hydra function ==
The Hydra function's simple definition allows one to write computer programs that simulate Hydra and Antihydra. The following Python program is a straightforward Hydra simulator based on the Hydra function:
<syntaxhighlight lang="python" line="1">
# 'a' and 'b' fulfill the same purpose as in the Hydra rules.
a = 3
b = 0
# As long as Hydra has not halted, 'b' remains greater than -1.
while b != -1:
# If 'a' is even, decrement 'b', otherwise increase 'b' by 2.
if a % 2 == 0:
b -= 1
else:
b += 2
# This performs H(a) = a + floor(a/2).
a += a//2
</syntaxhighlight>
Replacing <code>a = 3</code> with <code>a = 8</code> and swapping <code>b -= 1</code> for <code>b += 2</code> turns this program into an Antihydra simulator.
==Properties==
The Hydra function can be rewritten as follows:
<math display="block">\begin{array}{l}
H(2n)&=&3n,\\
H(2n+1)&=&3n+1.\\
\end{array}</math>
Now assume that for some positive integer <math>s</math> and every odd integer <math>t</math>, <math>H^s(2^st)=3^st</math> and <math>H^s(2^st+1)=3^st+1</math>, where <math>H^i(n)</math> is function iteration. Notice that we can write <math>2^{s+1}t=2\cdot2^st</math> and <math>2^{s+1}t+1=2\cdot2^st+1</math>, so if we apply <math>H</math> to these numbers, we get <math>H(2\cdot2^st)=3\cdot 2^st</math> and <math>H(2\cdot2^st+1)=3\cdot2^st+1</math>. Now, if we apply <math>H</math> to these numbers <math>s</math> times, we get <math>H^{s+1}\big(2^{s+1}t\big)=H^s(2^s\cdot3t)=3^{s+1}t</math> and <math>H^{s+1}\big(2^{s+1}t+1\big)=H^s(2^s\cdot3t+1)=3^{s+1}t+1</math>. Therefore, by mathematical induction we have proved the following formulas:
<math display="block">\begin{array}{l}
H^s(2^st)&=&3^st,\\
H^s(2^st+1)&=&3^st+1.\\
\end{array}</math>
This optimization can be directly applied to the high-level rules for Hydra and Antihydra, producing this result:
{|class="wikitable"
! Hydra !! Antihydra
|-align="center"
|Let <math>C_H(a,b):=0^\infty\;\textrm{<A}\;2\;0^{3(a-2)}\;3^b\;2\;0^\infty</math>:
<math display="block">\begin{array}{|lll|}\hline
C_H(2^st,b+s)&\xrightarrow{f_1(s,t)}&C_H(3^st,b),\\
C_H(2^st+1,b)&\xrightarrow{f_2(s,t,b)}&C_H(3^st+1,b+2s),\\\hline
\end{array}</math>
where <math display="inline">f_1(s,t)=\frac{3t(3^s-2^s)(18(3^s+2^s)t-65)}{5}-5s</math> and <math display="inline">f_2(s,t,b)=(b+s)4s+\frac{3t(3^s-2^s)(18(3^s+2^s)t-5)}{5}</math>.
|Let <math>A_H(a,b):=0^\infty\;1^a\;0\;1^{b-4}\;\textrm{E>}\;0^\infty</math>:<math display="block">\begin{array}{|lll|}\hline
A_H(a,2^st)& \xrightarrow{f_3(s,t,a)}& A_H(a+2s,3^st),\\
A_H(a+s,2^st+1)&\xrightarrow{f_4(s,t)}& A_H(a,3^st+1),\\\hline
\end{array}</math>
where <math display="inline">f_3(s,t,a)=(2a-3+2s)s+\frac{3t^2(9^s-4^s)}{5}</math> and <math display="inline">f_4(s,t)=\frac{3t^2(9^s-4^s)}{5}-7s</math>.
|}
== Visualizations ==
The four images below depict the first 1000 values of four Hydra sequences with different initial values. Each row of pixels shows a number in binary on the right and its parity on the left (blue for even, red for odd):
<gallery mode=packed heights="250">
File:HydraFunction-StartingValue2.png|Starting value 2. There are 492 even numbers and 508 odd numbers.
File:HydraFunction-StartingValue5.png|Starting value 5. There are 497 even numbers and 503 odd numbers.
File:Antihydra increasing value.png|Starting value 8. There are 499 even numbers and 501 odd numbers.
File:HydraFunction-StartingValue11.png|Starting value 11. There are 481 even numbers and 519 odd numbers.
</gallery>

File:HydraFunction-StartingValue11.png

2025-04-14T22:09:08Z

MrSolis: The first 1000 iterates of the Hydra function, with starting value 11.

== Summary ==
The first 1000 iterates of the Hydra function, with starting value 11.

File:HydraFunction-StartingValue5.png

2025-04-14T22:08:51Z

MrSolis: The first 1000 iterates of the Hydra function, with starting value 5.

== Summary ==
The first 1000 iterates of the Hydra function, with starting value 5.

File:HydraFunction-StartingValue2.png

2025-04-14T22:08:12Z

MrSolis: The first 1000 iterates of the Hydra function, with starting value 2.

== Summary ==
The first 1000 iterates of the Hydra function, with starting value 2.

BB(6)

2025-04-14T14:03:08Z

MrSolis:

The 6-state, 2-symbol Busy Beaver problem '''BB(6)''' is unsolved. With the discovery of [[Antihydra]] in 2024, we now know that we must solve a [[Collatz-like]] problem in order to solve BB(6).

The current BB(6) champion {{TM|1RB0LD_1RC0RF_1LC1LA_0LE1RZ_1LF0RB_0RC0RE|halt}} was discovered by Pavel Kropitz in 2022 proving the lower bound:<ref>Shawn Ligocki. 2022. [https://www.sligocki.com/2022/06/21/bb-6-2-t15.html "BB(6, 2) > 10↑↑15"]</ref><ref>Pascal Michel. [https://bbchallenge.org/~pascal.michel/ha#tm62 Historical survey of Busy Beavers]</ref>

<math display="block">S(6) > \Sigma(6) > 10 \uparrow\uparrow 15</math>

== Techniques ==
In order to simulate the current BB(6) champion requires [[Accelerated simulator|accelerated simulation]] that can handle Collatz Level 2 [[Inductive rule|inductive rules]]. In other words, it requires a simulator that can prove the rules:

<math display="block">\begin{array}{lcl}
C(4k) & \to & {\operatorname{Halt}}\Big(\frac{3^{k+3} - 11}{2}\Big) \\
C(4k+1) & \to & C\Big(\frac{3^{k+3} - 11}{2}\Big) \\
C(4k+2) & \to & C\Big(\frac{3^{k+3} - 11}{2}\Big) \\
C(4k+3) & \to & C\Big(\frac{3^{k+3} + 1}{2}\Big) \\
\end{array}</math>

and also compute the remainder mod 3 of numbers produced by applying these rules 15 times (which requires some fancy math related to [[wikipedia:Euler's_totient_function|Euler's totient function]]).

== Cryptids ==
Several [[Turing machines]] have been found that are [[Cryptids]], considered so because each of them have a [[Collatz-like]] halting problem, a type of problem that is generally difficult to solve. However, probabilistic arguments have allowed all but one of them to be categorized as [[probviously]] halting or probviously non-halting.

Probviously non-halting Cryptids:

* [[Antihydra]]
* {{TM|1RB1RC_1LC1LE_1RA1RD_0RF0RE_1LA0LB_---1RA|undecided}}, a variant of [[Hydra]] and Antihydra
* {{TM|1RB1LD_1RC1RE_0LA1LB_0LD1LC_1RF0RA_---0RC|undecided}}, similar to Antihydra
* {{TM|1RB0LD_1RC1RF_1LA0RA_0LA0LE_1LD1LA_0RB---|undecided}}, similar to Antihydra
* {{TM|1RB0LB_1LC0RE_1LA1LD_0LC---_0RB0RF_1RE1RB|undecided}}, similar to Antihydra

Probviously halting Cryptids:

* [[Lucy's Moonlight]]
* {{TM|1RB1RA_0RC1RC_1LD0LF_0LE1LE_1RA0LB_---0LC|undecided}}, a family of 16 related TMs
* {{TM|1RB1RE_1LC1LD_---1LA_1LB1LE_0RF0RA_1LD1RF}}
* {{TM|1RB0RE_1LC1LD_0RA0LD_1LB0LA_1RF1RA_---1LB}}
* {{TM|1RB0LC_0LC0RF_1RD1LC_0RA1LE_---0LD_1LF1LA}}
* {{TM|1RB0LC_1LC0RD_1LF1LA_1LB1RE_1RB1LE_---0LE}}
Although {{TM|1RB1LE_0LC0LB_1RD1LC_1RD1RA_1RF0LA_---1RE}} behaves similarly to the probviously halting Cryptids, it is estimated to have a 3/5 chance of becoming a [[translated cycler]] and a 2/5 chance of halting.

There are a few machines considered notable for their chaotic behaviour, but which have not been classified as Cryptids due to seemingly lacking a connection to any known open mathematical problems, such as Collatz-like problems.

Potential Cryptids:

* {{TM|1RB1RE_1LC0RA_0RD1LB_---1RC_1LF1RE_0LB0LE|undecided}}
* {{TM|1RB0LD_1LC0RA_1RA1LB_1LA1LE_1RF0LC_---0RE|undecided}}
* {{TM|1RB0RB_1LC1RE_1LF0LD_1RA1LD_1RC1RB_---1LC|undecided}}
* {{TM|1RB1LA_1LC0RE_1LF1LD_0RB0LA_1RC1RE_---0LD}}

== Top Halters ==
Below is a table of the machines with the 10 highest known runtimes.<ref>Shawn Ligocki's list of 6-state, 2-symbol machines with large runtimes ([https://github.com/sligocki/busy-beaver/blob/main/Machines/bb/6x2.txt Link])</ref> Their sigma scores are expressed using an extension of Knuth's up-arrow notation.<ref>Shawn Ligocki. 2022. [https://www.sligocki.com/2022/06/25/ext-up-notation.html "Extending Up-arrow Notation"]</ref>
{| class="wikitable"
|+Top Known BB(6) Halters
!TM
!approximate sigma score
|-
|{{TM|1RB0LD_1RC0RF_1LC1LA_0LE1RZ_1LF0RB_0RC0RE}}
|10 ↑↑ 15.60465
|-
|{{TM|1RB1RC_1LC1RE_1LD0LB_1RE1LC_1LE0RF_1RZ1RA}}
|10 ↑↑ 7.23619
|-
|{{TM|1RB0LA_1LC1LF_0LD0LC_0LE0LB_1RE0RA_1RZ1LD}}
|10 ↑↑ 5.63534
|-
|{{TM|1RB1RE_1LC1LF_1RD0LB_1LE0RC_1RA0LD_1RZ1LC}}
|10 ↑↑ 5.56344
|-
|{{TM|1RB0LE_0RC1RA_0LD1RF_1RE0RB_1LA0LC_0RD1RZ}}
|10 ↑↑ 5.12468
|-
|{{TM|1RB0RF_1LC1LB_0RE0LD_0LC0LB_0RA1RE_0RD1RZ}}
|10 ↑↑ 5.03230
|-
|{{TM|1RB1LA_1LC0RF_1LD1LC_1LE0RE_0RB0LC_1RZ1RA}}
|10 ↑↑ 4.91072
|-
|{{TM|1RB0LE_1LC1RA_1RE0LD_1LC1LF_1LA0RC_1RZ1LC}}
|10 ↑↑ 3.33186
|-
|{{TM|1RB1RF_1LC1RE_0LD1LB_1LA0RA_0RA0RB_1RZ0RD}}
|10 ↑↑ 3.31128
|-
|{{TM|1RB0LF_1LC0RA_1RD0LB_1LE1RC_1RZ1LA_1LA1LE}}
|10 ↑↑ 3.18855
|}
The runtimes are presumed to be about <math>\text{score}^2</math> which is roughly indistinguishable in tetration notation.

== Holdouts ==
@mxdys's informal [[Holdouts lists|holdouts list]] is down to 4408 machines as of 8 Nov 2024.

== References ==
<references />
[[Category:BB Domain]]

Probvious

2025-04-14T13:05:56Z

MrSolis:

"'''Probvious'''" (a portmanteau of the words ''probabilistic'' and ''obvious'') is an adjective used to express a high degree of confidence about a mathematical statement that is not known to be true. It was introduced by John Conway in an article discussing possibly unprovable statements.<ref>Conway, J. H. (2013). On Unsettleable Arithmetical Problems. The American Mathematical Monthly, 120(3), 192–198. https://doi.org/10.4169/amer.math.monthly.120.03.192</ref> The term has been used by [https://www.bbchallenge.org bbchallenge] contributors to describe the solutions to halting problems for [[Cryptids]] such as [[Bigfoot]] and [[Hydra]].
==Usage==
[[File:ProbviousExcerpt.png|right|300px|thumb|The excerpt from John Conway's article where "probvious" is introduced.]]
The word appears in Conway's article a few times as a way of forming conjectures about a known [[Collatz-like]] function.<ref>Atkin, A. O. L. “Problem 63-13.” SIAM Review, vol. 8, no. 2, 1966, pp. 234–36. JSTOR, http://www.jstor.org/stable/2028281</ref><ref>Guy, R. K. (1983). Don’t Try to Solve These Problems! The American Mathematical Monthly, 90(1), 35–41. https://doi.org/10.1080/00029890.1983.11971148</ref> This function, denoted <math>\mu(n)</math>, is defined as:
<math display="block">\begin{array}{lll}\mu(2n)&=&3n\\ \mu(4n+1)&=&3n+1\\ \mu(4n+3)&=&3n+2\end{array}\Rightarrow\begin{array}{lll}\mu^{-1}(3n)&=&2n\\ \mu^{-1}(3n+1)&=&4n+1\\ \mu^{-1}(3n+2)&=&4n+3\end{array}</math>
Conway first uses "probvious" to describe the idea that the sequences of iterates <math>(\cdots,8,\mu(8),\mu^2(8),\cdots)</math> and <math>(\cdots,14,\mu(14),\mu^2(14),\cdots)</math> diverge to infinity.

Likewise, there exist Turing machines for which determining whether they halt requires solving a mathematical problem believed to be difficult, oftentimes a Collatz-like problem, but arguments using probabilistic versions of their behaviour suggest a clear solution. For example, Bigfoot and Hydra are probviously non-halting because they simulate biased random walks that drift towards infinity yet must reach zero for these machines to halt. Alternatively, [[Lucy's Moonlight]] is probviously halting because it simulates a sequence of independent random trials for which it has a fixed probability of halting each time.
== References ==
<references />

Probvious

2025-04-14T13:03:40Z

MrSolis:

"'''Probvious'''" (a portmanteau of the words ''probabilistic'' and ''obvious'') is an adjective used to express a high degree of confidence about a mathematical statement that is not known to be true. It was introduced by John Conway in an article discussing possibly unprovable statements.<ref>Conway, J. H. (2013). On Unsettleable Arithmetical Problems. The American Mathematical Monthly, 120(3), 192–198. https://doi.org/10.4169/amer.math.monthly.120.03.192</ref> The term has been used by [https://www.bbchallenge.org bbchallenge] contributors to describe the solutions to halting problems for [[Cryptids]] such as [[Bigfoot]] and [[Hydra]].
==Usage==
[[File:ProbviousExcerpt.png|right|300px|thumb|The excerpt from the article by John Conway where "probvious" is introduced.]]
The word appears in Conway's article a few times as a way of forming conjectures about a known [[Collatz-like]] function.<ref>Atkin, A. O. L. “Problem 63-13.” SIAM Review, vol. 8, no. 2, 1966, pp. 234–36. JSTOR, http://www.jstor.org/stable/2028281</ref><ref>Guy, R. K. (1983). Don’t Try to Solve These Problems! The American Mathematical Monthly, 90(1), 35–41. https://doi.org/10.1080/00029890.1983.11971148</ref> This function, denoted <math>\mu(n)</math>, is defined as:
<math display="block">\begin{array}{lll}\mu(2n)&=&3n\\ \mu(4n+1)&=&3n+1\\ \mu(4n+3)&=&3n+2\end{array}\Rightarrow\begin{array}{lll}\mu^{-1}(3n)&=&2n\\ \mu^{-1}(3n+1)&=&4n+1\\ \mu^{-1}(3n+2)&=&4n+3\end{array}</math>
Conway first uses "probvious" to describe the idea that the sequences of iterates <math>(\cdots,8,\mu(8),\mu^2(8),\cdots)</math> and <math>(\cdots,14,\mu(14),\mu^2(14),\cdots)</math> diverge to infinity.

Likewise, there exist Turing machines for which determining whether they halt requires solving a mathematical problem believed to be difficult, oftentimes a Collatz-like problem, but arguments using probabilistic versions of their behaviour suggest a clear solution. For example, Bigfoot and Hydra are probviously non-halting because they simulate biased random walks that drift towards infinity yet must reach zero for these machines to halt. Alternatively, [[Lucy's Moonlight]] is probviously halting because it simulates a sequence of independent random trials for which it has a fixed probability of halting each time.
== References ==
<references />

BB(6)

2025-04-14T12:22:47Z

MrSolis:

The 6-state, 2-symbol Busy Beaver problem '''BB(6)''' is unsolved. With the discovery of [[Antihydra]] in 2024, we now know that we must solve a [[Collatz-like]] problem in order to solve BB(6).

The current BB(6) champion {{TM|1RB0LD_1RC0RF_1LC1LA_0LE1RZ_1LF0RB_0RC0RE|halt}} was discovered by Pavel Kropitz in 2022 proving the lower bound:<ref>Shawn Ligocki. 2022. [https://www.sligocki.com/2022/06/21/bb-6-2-t15.html "BB(6, 2) > 10↑↑15"]</ref><ref>Pascal Michel. [https://bbchallenge.org/~pascal.michel/ha#tm62 Historical survey of Busy Beavers]</ref>

<math display="block">S(6) > \Sigma(6) > 10 \uparrow\uparrow 15</math>

== Techniques ==
In order to simulate the current BB(6) champion requires [[Accelerated simulator|accelerated simulation]] that can handle Collatz Level 2 [[Inductive rule|inductive rules]]. In other words, it requires a simulator that can prove the rules:

<math display="block">\begin{array}{lcl}
C(4k) & \to & {\operatorname{Halt}}\Big(\frac{3^{k+3} - 11}{2}\Big) \\
C(4k+1) & \to & C\Big(\frac{3^{k+3} - 11}{2}\Big) \\
C(4k+2) & \to & C\Big(\frac{3^{k+3} - 11}{2}\Big) \\
C(4k+3) & \to & C\Big(\frac{3^{k+3} + 1}{2}\Big) \\
\end{array}</math>

and also compute the remainder mod 3 of numbers produced by applying these rules 15 times (which requires some fancy math related to [[wikipedia:Euler's_totient_function|Euler's totient function]]).

== Cryptids ==
Several [[Turing machines]] have been found that are [[Cryptids]], considered so because each of them have a [[Collatz-like]] halting problem, a type of problem that is generally difficult to solve. However, probabilistic arguments have allowed all but one of them to be categorized as [[probviously]] halting or probviously non-halting.

Probviously non-halting Cryptids:

* [[Antihydra]]
* {{TM|1RB1RC_1LC1LE_1RA1RD_0RF0RE_1LA0LB_---1RA|undecided}}, a variant of [[Hydra]] and Antihydra
* {{TM|1RB1LD_1RC1RE_0LA1LB_0LD1LC_1RF0RA_---0RC|undecided}}, similar to Antihydra
* {{TM|1RB0LD_1RC1RF_1LA0RA_0LA0LE_1LD1LA_0RB---|undecided}}, similar to Antihydra
* {{TM|1RB0LB_1LC0RE_1LA1LD_0LC---_0RB0RF_1RE1RB|undecided}}, similar to Antihydra

Probviously halting (or translated cycling) Cryptids:

* [[Lucy's Moonlight]]
* {{TM|1RB1RA_0RC1RC_1LD0LF_0LE1LE_1RA0LB_---0LC|undecided}}, a family of 16 related TMs
* {{TM|1RB1RE_1LC1LD_---1LA_1LB1LE_0RF0RA_1LD1RF}}
* {{TM|1RB0RE_1LC1LD_0RA0LD_1LB0LA_1RF1RA_---1LB}}
* {{TM|1RB0LC_0LC0RF_1RD1LC_0RA1LE_---0LD_1LF1LA}}
* {{TM|1RB0LC_1LC0RD_1LF1LA_1LB1RE_1RB1LE_---0LE}}
Although {{TM|1RB1LE_0LC0LB_1RD1LC_1RD1RA_1RF0LA_---1RE}} behaves similarly to the probviously halting Cryptids, it is estimated to have a 3/5 chance of becoming a [[translated cycler]] and a 2/5 chance of halting.

There are a few machines considered notable for their chaotic behaviour, but which have not been classified as Cryptids due to seemingly lacking a connection to any known open mathematical problems, such as Collatz-like problems.

Potential Cryptids:

* {{TM|1RB1RE_1LC0RA_0RD1LB_---1RC_1LF1RE_0LB0LE|undecided}}
* {{TM|1RB0LD_1LC0RA_1RA1LB_1LA1LE_1RF0LC_---0RE|undecided}}
* {{TM|1RB0RB_1LC1RE_1LF0LD_1RA1LD_1RC1RB_---1LC|undecided}}
* {{TM|1RB1LA_1LC0RE_1LF1LD_0RB0LA_1RC1RE_---0LD}}

== Top Halters ==
Below is a table of the machines with the 10 highest known runtimes.<ref>Shawn Ligocki's list of 6-state, 2-symbol machines with large runtimes ([https://github.com/sligocki/busy-beaver/blob/main/Machines/bb/6x2.txt Link])</ref> Their sigma scores are expressed using an extension of Knuth's up-arrow notation.<ref>Shawn Ligocki. 2022. [https://www.sligocki.com/2022/06/25/ext-up-notation.html "Extending Up-arrow Notation"]</ref>
{| class="wikitable"
|+Top Known BB(6) Halters
!TM
!approximate sigma score
|-
|{{TM|1RB0LD_1RC0RF_1LC1LA_0LE1RZ_1LF0RB_0RC0RE}}
|10 ↑↑ 15.60465
|-
|{{TM|1RB1RC_1LC1RE_1LD0LB_1RE1LC_1LE0RF_1RZ1RA}}
|10 ↑↑ 7.23619
|-
|{{TM|1RB0LA_1LC1LF_0LD0LC_0LE0LB_1RE0RA_1RZ1LD}}
|10 ↑↑ 5.63534
|-
|{{TM|1RB1RE_1LC1LF_1RD0LB_1LE0RC_1RA0LD_1RZ1LC}}
|10 ↑↑ 5.56344
|-
|{{TM|1RB0LE_0RC1RA_0LD1RF_1RE0RB_1LA0LC_0RD1RZ}}
|10 ↑↑ 5.12468
|-
|{{TM|1RB0RF_1LC1LB_0RE0LD_0LC0LB_0RA1RE_0RD1RZ}}
|10 ↑↑ 5.03230
|-
|{{TM|1RB1LA_1LC0RF_1LD1LC_1LE0RE_0RB0LC_1RZ1RA}}
|10 ↑↑ 4.91072
|-
|{{TM|1RB0LE_1LC1RA_1RE0LD_1LC1LF_1LA0RC_1RZ1LC}}
|10 ↑↑ 3.33186
|-
|{{TM|1RB1RF_1LC1RE_0LD1LB_1LA0RA_0RA0RB_1RZ0RD}}
|10 ↑↑ 3.31128
|-
|{{TM|1RB0LF_1LC0RA_1RD0LB_1LE1RC_1RZ1LA_1LA1LE}}
|10 ↑↑ 3.18855
|}
The runtimes are presumed to be about <math>\text{score}^2</math> which is roughly indistinguishable in tetration notation.

== Holdouts ==
@mxdys's informal [[Holdouts lists|holdouts list]] is down to 4408 machines as of 8 Nov 2024.

== References ==
<references />
[[Category:BB Domain]]