From Newsgroup: comp.theory

i'd like to discuss forms of equivalence in turing machine descriptions because dickard damon has been incredibly confused in regards to this. i
will provide some terminology to make this discussion smoother, not that
it will help any of the morons reading this. all of this assumes ofc we
are talking about machines described in the *same* turing-complete
language 🙄

# identical/self-equivalence #

if descriptions of two machines are identical, they are *the same
string* as written in the language. any renaming of labels or isomorphic re-ordering of the states produces a machine description that is *not* identical, however seemingly equivalent it might be.

computing whether two machine descriptions are identical, or "itself",
is as simple a string comparison.

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded
into their descriptions leading to the *same* set of machine configurations/steps during computation on the same input (therefore
producing the same output as well). two machines that have isomorphic equivalence will have the same space/runtime complexity when run.
isomorphic machines represent the "same" computation, and most would
consider them the "same" machine, but when it comes to the theory of computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each machines are unique.

despite the objections a certain massive dick will soon make (because
he's prolly gunna have to walk back a *ton* of bs he wrote), isomorphic equivalence *is* computable, and we will discuss why:

in turing's standard descriptions labels must be created in order:
q0...qN for states, s0...sN for symbols. so unlike modern languages, one cannot just arbitrarily "change" labels to create another machine of isomorphic equivalence. however one can still create isomorphism by
changing the order in which instructions are listed, effort of which is essentially changing the label of the instruction. by "instruction" i
mean a single transition function, a list of which forms a "machine description". i will list instructions in the form:

<cur_state cur_head_symbol operation next_state>

operations can be: R for moving the head right, L for moving the head
left, or a symbol for writing that symbol. i do not use specific halting/accept/reject states in these machine descriptions. if there is
no instruction that matches the <cur_state cur_head_symbol> of the
machine's current configuration, the machine halts with the output being whatever is left on the tape.

the procedure i will detail next we be an example of how we compute two machines to be isomorphic. consider these two isomorphic machines:

<q0 s0 R q1> <q0 s0 R q2>
<q1 s0 L q2> <q1 s0 R q3>
<q2 s0 R q3> <q2 s0 L q1>

they don't do anything useful, just jiggle the head around on a blank
tape. the important bit is they jiggle the head around in the exactly
same manner: right, left, right, halting thereafter; forming the same computation while not actually being identical machines.

for each machine we can construct a graph that represents the states
linked together by the transitions taken between the states. nodes are
the states of the machine, edges are defined by head symbol that selects
them, and includes the operation taken during the transition.

for the 1st machine:

q0 --s0-R--> q1 --s0-L--> q2 --s0-R--> q3

for the 2nd machine:

q0 --s0-R--> q2 --s0-L--> q1 --s0-R--> q3

the fact these graphs have the same shape of transitions is what makes
the machines isomorphic. computing whether two graphs are isomorphic is
a known computable relationship, so therefore isomorphic machines are a computable relationship. that alone should suffice as a proof, but to
satisfy any curiosity about labeling differences: one can create a
canonically labeled graph by traversing the graphs in the same order
(from the same start), systematically replacing any encountered labels
with canonicalized versions. the particular system of canonicalized
labeling doesn't matter, so long as the same canonicalization process is applied to both graphs, they will come out the same in ismorphic cases.

to conclude: one can compute whether two machines are isomorphic by constructing this transition graph for the machines to be compared, and
then computing whether the graphs are isomorphic, taking care that all analogous symbols, states, and operations are in their respectively
correct positions (likely thru some canonicalization process)

# turing/functional equivalence #

these machines produce the same output on the same input, thereby
computing the same function, but they may not use then same steps to get there.

non-isomorphic turing equivalence is the only form of equivalence up for debate in terms of computability.

# further considerations #

1) a machine is able to identify "itself". if a machine is programmed
with an appropriate quine, then it is can be able to identify itself.

2) a machine is also able to identify machines isomorphic to itself,
that represent the same *exact* computation, ei the series of steps
taken given some input. again starting with an appropriate quine, it can
use that self-description to generate a canonicalized transition graph
which all isomorphic machine descriptions can also be canonicalized to.

3) one can enumerate all machines isomorphic to a particular machine.
given that isomorphic machines must be of the same number of
instructions (or same "size" so to speak), then there are a fixed number
of machines which could be isomorphic, and we can just brute force the
the enumeration by testing each possibility for actual isomorphism.
--
a burnt out swe investigating into why our tooling doesn't involve
basic semantic proofs like halting analysis

please excuse my pseudo-pyscript,

~ nick

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/25 8:15 PM, dart200 wrote:

i'd like to discuss forms of equivalence in turing machine descriptions because dickard damon has been incredibly confused in regards to this. i will provide some terminology to make this discussion smoother, not that
it will help any of the morons reading this. all of this assumes ofc we
are talking about machines described in the *same* turing-complete
language 🙄

# identical/self-equivalence #

if descriptions of two machines are identical, they are *the same
string* as written in the language. any renaming of labels or isomorphic re-ordering of the states produces a machine description that is *not* identical, however seemingly equivalent it might be.

Not the same description, but the same machine,

1010(2) and 12(8) and A(16) (where the number in parenthesis is the base
of the expression) are all the same number, just expressed differently.

computing whether two machine descriptions are identical, or "itself",
is as simple a string comparison.

But worthless, as there exist other representations that produce the
same results.

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded
into their descriptions leading to the *same* set of machine configurations/steps during computation on the same input (therefore producing the same output as well). two machines that have isomorphic equivalence will have the same space/runtime complexity when run.
isomorphic machines represent the "same" computation, and most would consider them the "same" machine, but when it comes to the theory of computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each machines are unique.

despite the objections a certain massive dick will soon make (because
he's prolly gunna have to walk back a *ton* of bs he wrote), isomorphic equivalence *is* computable, and we will discuss why:

But still isn't sufficient to determine if a representation is
computationally equivalent, that is produces the same output for the
same input.

in turing's standard descriptions labels must be created in order:
q0...qN for states, s0...sN for symbols. so unlike modern languages, one cannot just arbitrarily "change" labels to create another machine of isomorphic equivalence. however one can still create isomorphism by
changing the order in which instructions are listed, effort of which is essentially changing the label of the instruction. by "instruction" i
mean a single transition function, a list of which forms a "machine description". i will list instructions in the form:

But, one can add the states in any order you want, and can add state
that are never accessed or become "nop" extensioins.

Thus the original set of s1 ... sN can be assigned to ANY value you want
for states, with unbounded values.

  <cur_state cur_head_symbol operation next_state>

operations can be: R for moving the head right, L for moving the head
left, or a symbol for writing that symbol. i do not use specific halting/accept/reject states in these machine descriptions. if there is
no instruction that matches the <cur_state cur_head_symbol> of the
machine's current configuration, the machine halts with the output being whatever is left on the tape.

the procedure i will detail next we be an example of how we compute two machines to be isomorphic. consider these two isomorphic machines:

  <q0 s0 R q1>    <q0 s0 R q2>
  <q1 s0 L q2>    <q1 s0 R q3>
  <q2 s0 R q3>    <q2 s0 L q1>

they don't do anything useful, just jiggle the head around on a blank
tape. the important bit is they jiggle the head around in the exactly
same manner: right, left, right, halting thereafter; forming the same computation while not actually being identical machines.

for each machine we can construct a graph that represents the states
linked together by the transitions taken between the states. nodes are
the states of the machine, edges are defined by head symbol that selects them, and includes the operation taken during the transition.

for the 1st machine:

q0 --s0-R--> q1 --s0-L--> q2 --s0-R--> q3

for the 2nd machine:

q0 --s0-R--> q2 --s0-L--> q1 --s0-R--> q3

the fact these graphs have the same shape of transitions is what makes
the machines isomorphic. computing whether two graphs are isomorphic is
a known computable relationship, so therefore isomorphic machines are a computable relationship. that alone should suffice as a proof, but to satisfy any curiosity about labeling differences: one can create a canonically labeled graph by traversing the graphs in the same order
(from the same start), systematically replacing any encountered labels
with canonicalized versions. the particular system of canonicalized
labeling doesn't matter, so long as the same canonicalization process is applied to both graphs, they will come out the same in ismorphic cases.

But, since we can add arbitrary edge pairs as "do nothing" states to a
graph, we can have computational equivalent machine that fail to be
detected by your algorithm.

And, we can possible identify clusters of states that we can produce an equivalent machine for, further hiding the results.

to conclude: one can compute whether two machines are isomorphic by constructing this transition graph for the machines to be compared, and
then computing whether the graphs are isomorphic, taking care that all analogous symbols, states, and operations are in their respectively
correct positions (likely thru some canonicalization process)

But isomorphic equivalence isn't good enough.

# turing/functional equivalence #

these machines produce the same output on the same input, thereby
computing the same function, but they may not use then same steps to get there.

non-isomorphic turing equivalence is the only form of equivalence up for debate in terms of computability.

And because it is NOT computable, you can't detect a computational
equivalent to yourself in the input, and thus can't determine your "incoherence"

# further considerations #

1) a machine is able to identify "itself". if a machine is programmed
with an appropriate quine, then it is can be able to identify itself.

2) a machine is also able to identify machines isomorphic to itself,
that represent the same *exact* computation, ei the series of steps
taken given some input. again starting with an appropriate quine, it can
use that self-description to generate a canonicalized transition graph
which all isomorphic machine descriptions can also be canonicalized to.

3) one can enumerate all machines isomorphic to a particular machine.
given that isomorphic machines must be of the same number of
instructions (or same "size" so to speak), then there are a fixed number
of machines which could be isomorphic, and we can just brute force the
the enumeration by testing each possibility for actual isomorphism.

But one can not compute if a machine is a computational equivalent of
itself, and that is all that needs to be done to make halting
undecidable, and makes you attempts to detect such an attempt impossible.




--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded
into their descriptions leading to the *same* set of machine configurations/steps during computation on the same input (therefore producing the same output as well). two machines that have isomorphic equivalence will have the same space/runtime complexity when run.
isomorphic machines represent the "same" computation, and most would
consider them the "same" machine, but when it comes to the theory of computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each machines are unique.

From where do you take your definition of "isomorphic" ? Is it a
definition from graph theory, perhaps meaning there the same that beta-equivalence does in computation, eg changing locations but updating pointers accordingly?
--
Tristan Wibberley

The message body is Copyright (C) 2025 Tristan Wibberley except
citations and quotations noted. All Rights Reserved except that you may,
of course, cite it academically giving credit to me, distribute it
verbatim as part of a usenet system or its archives, and use it to
promote my greatness and general superiority without misrepresentation
of my opinions other than my opinion of my greatness and general
superiority which you _may_ misrepresent. You definitely MAY NOT train
any production AI system with it but you may train experimental AI that
will only be used for evaluation of the AI methods it implements.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded
into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input (therefore
producing the same output as well). two machines that have isomorphic
equivalence will have the same space/runtime complexity when run.
isomorphic machines represent the "same" computation, and most would
consider them the "same" machine, but when it comes to the theory of
computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each machines are
unique.

From where do you take your definition of "isomorphic" ? Is it a
definition from graph theory, perhaps meaning there the same that beta-equivalence does in computation, eg changing locations but updating pointers accordingly?

grok pulled it from various threads tbh when i was doing research into
turing machine equivalence.

i decided to use it because transforming the machines into transition
graphs and canonicalizing them solves the problem of two machines having
the same structure but different labels in a computable fashion, meaning
we can also compute all isomorphic machines for an
--
a burnt out swe investigating into why our tooling doesn't involve
basic semantic proofs like halting analysis

please excuse my pseudo-pyscript,

~ nick
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded
into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input (therefore
producing the same output as well). two machines that have isomorphic
equivalence will have the same space/runtime complexity when run.
isomorphic machines represent the "same" computation, and most would
consider them the "same" machine, but when it comes to the theory of
computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each machines are
unique.

 From where do you take your definition of "isomorphic" ? Is it a
definition from graph theory, perhaps meaning there the same that
beta-equivalence does in computation, eg changing locations but updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing research into turing machine equivalence.

i decided to use it because transforming the machines into transition
graphs and canonicalizing them solves the problem of two machines having
the same structure but different labels in a computable fashion, meaning
we can also compute all isomorphic machines for an

But your "isomorphic" class isn't big enough, as the challenge program
can use a non-isomorphic equivalent to make you wrong.

Your problem is you don't get to limit the domain of programs you need
to answer and be a full decider.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/22/2025 9:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded
into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input (therefore
producing the same output as well). two machines that have isomorphic
equivalence will have the same space/runtime complexity when run.
isomorphic machines represent the "same" computation, and most would
consider them the "same" machine, but when it comes to the theory of
computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each machines are >>>> unique.

 From where do you take your definition of "isomorphic" ? Is it a
definition from graph theory, perhaps meaning there the same that
beta-equivalence does in computation, eg changing locations but updating >>> pointers accordingly?

grok pulled it from various threads tbh when i was doing research into
turing machine equivalence.

i decided to use it because transforming the machines into transition
graphs and canonicalizing them solves the problem of two machines
having the same structure but different labels in a computable
fashion, meaning we can also compute all isomorphic machines for an

 But your "isomorphic" class isn't big enough, as the challenge program can use a non-isomorphic equivalent to make you wrong.

Your problem is you don't get to limit the domain of programs you need
to answer and be a full decider.

*This already limits that set*

(1) Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values

(2) Thus accept or reject finite string inputs on
the basis of whether or not this finite string
input specifies a "syntactic or semantic property".
--
Copyright 2025 Olcott<br><br>

My 28 year goal has been to make <br>
"true on the basis of meaning expressed in language"<br>
reliably computable.<br><br>

This required establishing a new foundation<br>
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/22/25 10:38 PM, olcott wrote:

On 12/22/2025 9:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded >>>>> into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input (therefore >>>>> producing the same output as well). two machines that have isomorphic >>>>> equivalence will have the same space/runtime complexity when run.
isomorphic machines represent the "same" computation, and most would >>>>> consider them the "same" machine, but when it comes to the theory of >>>>> computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each machines >>>>> are
unique.

 From where do you take your definition of "isomorphic" ? Is it a
definition from graph theory, perhaps meaning there the same that
beta-equivalence does in computation, eg changing locations but
updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing research
into turing machine equivalence.

i decided to use it because transforming the machines into transition
graphs and canonicalizing them solves the problem of two machines
having the same structure but different labels in a computable
fashion, meaning we can also compute all isomorphic machines for an

  But your "isomorphic" class isn't big enough, as the challenge
program can use a non-isomorphic equivalent to make you wrong.

Your problem is you don't get to limit the domain of programs you need
to answer and be a full decider.

*This already limits that set*

No it doesn't, where is that limit?

(1) Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values

(2) Thus accept or reject finite string inputs on
the basis of whether or not this finite string
input specifies a "syntactic or semantic property".

So, the "finite string" can be for ANY program.

Try to name an actual program that you can not make a finite string representation for.

Try to name a problem over such a representation that isn't a syntactic
or semantic property of the string, where semantic properties are
DEFINED as properties relating to the running of the program the input represents.

You are just to stupid and ignorant to understand what is being talked
about.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/22/2025 9:55 PM, Richard Damon wrote:

On 12/22/25 10:38 PM, olcott wrote:

On 12/22/2025 9:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded >>>>>> into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input (therefore >>>>>> producing the same output as well). two machines that have isomorphic >>>>>> equivalence will have the same space/runtime complexity when run.
isomorphic machines represent the "same" computation, and most would >>>>>> consider them the "same" machine, but when it comes to the theory of >>>>>> computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each
machines are
unique.

 From where do you take your definition of "isomorphic" ? Is it a
definition from graph theory, perhaps meaning there the same that
beta-equivalence does in computation, eg changing locations but
updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing research
into turing machine equivalence.

i decided to use it because transforming the machines into
transition graphs and canonicalizing them solves the problem of two
machines having the same structure but different labels in a
computable fashion, meaning we can also compute all isomorphic
machines for an

  But your "isomorphic" class isn't big enough, as the challenge
program can use a non-isomorphic equivalent to make you wrong.

Your problem is you don't get to limit the domain of programs you
need to answer and be a full decider.

*This already limits that set*

No it doesn't, where is that limit?

(1) Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values

(2) Thus accept or reject finite string inputs on
the basis of whether or not this finite string
input specifies a "syntactic or semantic property".

So, the "finite string" can be for ANY program.

Try to name an actual program that you can not make a finite string representation for.

You are not asking the correct question.
Try and define finite string transformation
rules that H(P) can use on its input that
derive the behavior of H1(P).

You can always intentionally reframe the
issue incorrectly to make sure you dodge
any understanding of what I am saying.

Try to name a problem over such a representation that isn't a syntactic
or semantic property of the string, where semantic properties are
DEFINED as properties relating to the running of the program the input represents.

You are just to stupid and ignorant to understand what is being talked about.

--
Copyright 2025 Olcott<br><br>

My 28 year goal has been to make <br>
"true on the basis of meaning expressed in language"<br>
reliably computable.<br><br>

This required establishing a new foundation<br>
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/22/25 11:03 PM, olcott wrote:

On 12/22/2025 9:55 PM, Richard Damon wrote:

On 12/22/25 10:38 PM, olcott wrote:

On 12/22/2025 9:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded >>>>>>> into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input (therefore >>>>>>> producing the same output as well). two machines that have
isomorphic
equivalence will have the same space/runtime complexity when run. >>>>>>> isomorphic machines represent the "same" computation, and most would >>>>>>> consider them the "same" machine, but when it comes to the theory of >>>>>>> computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each
machines are
unique.

 From where do you take your definition of "isomorphic" ? Is it a >>>>>> definition from graph theory, perhaps meaning there the same that
beta-equivalence does in computation, eg changing locations but
updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing research
into turing machine equivalence.

i decided to use it because transforming the machines into
transition graphs and canonicalizing them solves the problem of two >>>>> machines having the same structure but different labels in a
computable fashion, meaning we can also compute all isomorphic
machines for an

  But your "isomorphic" class isn't big enough, as the challenge
program can use a non-isomorphic equivalent to make you wrong.

Your problem is you don't get to limit the domain of programs you
need to answer and be a full decider.

*This already limits that set*

No it doesn't, where is that limit?

(1) Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values

(2) Thus accept or reject finite string inputs on
the basis of whether or not this finite string
input specifies a "syntactic or semantic property".

So, the "finite string" can be for ANY program.

Try to name an actual program that you can not make a finite string
representation for.

You are not asking the correct question.
Try and define finite string transformation
rules that H(P) can use on its input that
derive the behavior of H1(P).

THAT isn't the right question!!!

You are just showing your stupidity.

You can always intentionally reframe the
issue incorrectly to make sure you dodge
any understanding of what I am saying.

No, YOU are reframing the problem.

Your problem is once you indicated that you were working on the actual historic halting problem, you locked yourself into its definitions, and
can't change them without becoming a liar.

Since your "first principle" isn't from the field, it isn't applicable,
and trying to use it just shows your stupidity.

Try to name a problem over such a representation that isn't a
syntactic or semantic property of the string, where semantic
properties are DEFINED as properties relating to the running of the
program the input represents.

You are just to stupid and ignorant to understand what is being talked
about.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 23/12/2025 03:21, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded
into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input (therefore
producing the same output as well). two machines that have isomorphic
equivalence will have the same space/runtime complexity when run.
isomorphic machines represent the "same" computation, and most would
consider them the "same" machine, but when it comes to the theory of
computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each machines are
unique.

 From where do you take your definition of "isomorphic" ? Is it a
definition from graph theory, perhaps meaning there the same that
beta-equivalence does in computation, eg changing locations but updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing research into
turing machine equivalence.

i decided to use it because transforming the machines into transition
graphs and canonicalizing them solves the problem of two machines having
the same structure but different labels in a computable fashion, meaning
we can also compute all isomorphic machines for an

I think you should look up the definition in category theory. I think
the machines /are/ isomorphic in that respect. I wonder if
beta-equivalence (the improper kind, including alpha-equivalence) is
merely /the/ isomorphism for this particular context.
--
Tristan Wibberley

The message body is Copyright (C) 2025 Tristan Wibberley except
citations and quotations noted. All Rights Reserved except that you may,
of course, cite it academically giving credit to me, distribute it
verbatim as part of a usenet system or its archives, and use it to
promote my greatness and general superiority without misrepresentation
of my opinions other than my opinion of my greatness and general
superiority which you _may_ misrepresent. You definitely MAY NOT train
any production AI system with it but you may train experimental AI that
will only be used for evaluation of the AI methods it implements.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/22/25 7:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded
into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input (therefore
producing the same output as well). two machines that have isomorphic
equivalence will have the same space/runtime complexity when run.
isomorphic machines represent the "same" computation, and most would
consider them the "same" machine, but when it comes to the theory of
computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each machines are >>>> unique.

 From where do you take your definition of "isomorphic" ? Is it a
definition from graph theory, perhaps meaning there the same that
beta-equivalence does in computation, eg changing locations but updating >>> pointers accordingly?

grok pulled it from various threads tbh when i was doing research into
turing machine equivalence.

i decided to use it because transforming the machines into transition
graphs and canonicalizing them solves the problem of two machines
having the same structure but different labels in a computable
fashion, meaning we can also compute all isomorphic machines for an

 But your "isomorphic" class isn't big enough, as the challenge program

i get that not all functional equivalence is strictly isomorphic, hence
the fact they are difference classes... tell me something i don't
already know bro

can use a non-isomorphic equivalent to make you wrong.

but dude... so now ur saying that the decider can't even computationally identify a certain to exist "challenge" program that is pathological to
said decider's existence? 🫩🫩🫩

but we're just supposed to accept it exists without question? like a mathematical ghost i can have no specific observable evidence for?

idk bout that, i still don't really believe in ghosts ... and certainly
not math ghosts ... extremely sus

Your problem is you don't get to limit the domain of programs you need
to answer and be a full decider.

look bro, so ur saying you can identify all machines equivalent to the "challenge" program, right? or ... no?

...err, whatever...

imma make some claims that i haven't proven yet, but i just now formed
an intention to:

let's say for a second i accept ur claims that there's some point of unknowable semantic behavior:

for any given total enumeration, there must be a "first" point of "undecidability" where some (or all) classic classifiers fail to return.

if ur a retard like rick u'd pick an enumeration that starts on an
undecidable program as the 0th in the enumeration, and shoot urself in
the foot right off the bat because MuH tHeORy ... and that's not really
my problem, don't be that guy tbh, eh???

there are more sensible ways of totally enumerating out computing
machines, that start with n amount of machines which fall into the
category of "decidable" machines, on which all classic classifiers
return, such that and we can certainly categorize these machines into
semantic classes in regards to their behavior.

how maximally high can n be for any given enumeration? that's an
unstudied question as of now, prolly much higher than 420 i should think...

but regardless, given that for n machines a decision can certainly be
made, there must be some machine that happens exactly at n+1 machines in
that is the first such ghost machine G that rick is so certain about
it's existence.

now this machine G much has *some* semantic properties, it must be a
runnable machine, and in running it must behavior according to those
semantic properties.

now rick's claim is that said properties aren't computable or
"knowable", that's fine, this part i've accepted as a premise for this argument...

but whatever those unprovable semantics of G are, they must not allow
them to be functionally equivalent to any machine that came before,
because the semantics of those machines allowed them to be decided upon. machines that cannot be decided upon are not going to be functionally equivalent to any machine who semantics can be decided, as...

how could a machine with *unknowable* semantics be functionally
equivalent to one with *knowable* semantics???

therefore:

1) if we can write a machine and prove it's semantics, and then we can
do so for any functionally equivalent machine, as no functionally
equivalent machine could be part of the set of machines which
classifiers fail to return for.

2) you cannot create a machine functionally equivalent to one with known semantics, that could be one of these ghosts that then cannot be decided
upon in terms of their semantics.

this shenanigans of claiming to be able to define with certainty a pathological program that paradoxes a classifier i'm proposing... and
then turn around with a straight face suggesting i can't even *identify*
if the classifer is being paradoxed by that very pathological program...
is just maddeningly ludicrous, u've chucked all logic out the window to
make endless wildly hypocritical claims
--
a burnt out swe investigating into why our tooling doesn't involve
basic semantic proofs like halting analysis

please excuse my pseudo-pyscript,

~ nick
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/23/25 10:15 AM, Tristan Wibberley wrote:

On 23/12/2025 03:21, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded
into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input (therefore
producing the same output as well). two machines that have isomorphic
equivalence will have the same space/runtime complexity when run.
isomorphic machines represent the "same" computation, and most would
consider them the "same" machine, but when it comes to the theory of
computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each machines are >>>> unique.

 From where do you take your definition of "isomorphic" ? Is it a
definition from graph theory, perhaps meaning there the same that
beta-equivalence does in computation, eg changing locations but updating >>> pointers accordingly?

grok pulled it from various threads tbh when i was doing research into
turing machine equivalence.

i decided to use it because transforming the machines into transition
graphs and canonicalizing them solves the problem of two machines having
the same structure but different labels in a computable fashion, meaning
we can also compute all isomorphic machines for an

I think you should look up the definition in category theory. I think
the machines /are/ isomorphic in that respect. I wonder if
beta-equivalence (the improper kind, including alpha-equivalence) is
merely /the/ isomorphism for this particular context.

from my quick search it appears β-equivalence is functional equivalence
not isomorphism
--
a burnt out swe investigating into why our tooling doesn't involve
basic semantic proofs like halting analysis

please excuse my pseudo-pyscript,

~ nick
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/23/25 2:04 PM, dart200 wrote:

On 12/22/25 7:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded >>>>> into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input (therefore >>>>> producing the same output as well). two machines that have isomorphic >>>>> equivalence will have the same space/runtime complexity when run.
isomorphic machines represent the "same" computation, and most would >>>>> consider them the "same" machine, but when it comes to the theory of >>>>> computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each machines >>>>> are
unique.

 From where do you take your definition of "isomorphic" ? Is it a
definition from graph theory, perhaps meaning there the same that
beta-equivalence does in computation, eg changing locations but
updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing research
into turing machine equivalence.

i decided to use it because transforming the machines into transition
graphs and canonicalizing them solves the problem of two machines
having the same structure but different labels in a computable
fashion, meaning we can also compute all isomorphic machines for an

  But your "isomorphic" class isn't big enough, as the challenge program

i get that not all functional equivalence is strictly isomorphic, hence
the fact they are difference classes... tell me something i don't
already know bro

It just means that being able to detect your "isomorphic" equivalent
doesn't get you what you need. You need full functional equivalence for
you logic to make sense.

can use a non-isomorphic equivalent to make you wrong.

but dude... so now ur saying that the decider can't even computationally identify a certain to exist "challenge" program that is pathological to
said decider's existence? 🫩🫩🫩

Right, "Pathological" isn't a computable property.

but we're just supposed to accept it exists without question? like a mathematical ghost i can have no specific observable evidence for?

No, it is provable. You just need to accept that logic works.

idk bout that, i still don't really believe in ghosts ... and certainly
not math ghosts ... extremely sus

Doesn't matter if you believe in them or not. They exist (in this sense)
and will make your results wrong.

Not believing doesn't affect truth.

Your problem is you don't get to limit the domain of programs you need
to answer and be a full decider.

look bro, so ur saying you can identify all machines equivalent to the "challenge" program, right? or ... no?

No, I am saying you CAN'T.

...err, whatever...

imma make some claims that i haven't proven yet, but i just now formed
an intention to:

let's say for a second i accept ur claims that there's some point of unknowable semantic behavior:

It doesn't need a "point", it just exists.

for any given total enumeration, there must be a "first" point of "undecidability" where some (or all) classic classifiers fail to return.

Yes, but you will first hit an "unknown" machine.

Remember, you can't actually run "ALL" the classifier and know the results.

if ur a retard like rick u'd pick an enumeration that starts on an undecidable program as the 0th in the enumeration, and shoot urself in
the foot right off the bat because MuH tHeORy ... and that's not really
my problem, don't be that guy tbh, eh???

But you can't tell if you did.

The problem is you can't reach the end of running ALL the classifier, as
there is an infinite number of them.

there are more sensible ways of totally enumerating out computing
machines, that start with n amount of machines which fall into the
category of "decidable" machines, on which all classic classifiers
return, such that and we can certainly categorize these machines into semantic classes in regards to their behavior.

Yes, we can classify many machines. One problem is how do you enumerate
ALL the classifiers.

how maximally high can n be for any given enumeration? that's an
unstudied question as of now, prolly much higher than 420 i should think...

Since there is a countably infinte number of halting machines, you can
just begin with them and get as high of a number as you want.

It seems your problem is you don't understand the mathematics of the
infinite.

but regardless, given that for n machines a decision can certainly be
made, there must be some machine that happens exactly at n+1 machines in that is the first such ghost machine G that rick is so certain about
it's existence.

Nope, Not how infinite sets work. As I pointed out, your n is infinite,
but is still followed by infinite machines.

now this machine G much has *some* semantic properties, it must be a runnable machine, and in running it must behavior according to those semantic properties.

The undeciable machine will run forever, and create an unbounded tape.

now rick's claim is that said properties aren't computable or
"knowable", that's fine, this part i've accepted as a premise for this argument...

Right.

but whatever those unprovable semantics of G are, they must not allow
them to be functionally equivalent to any machine that came before,
because the semantics of those machines allowed them to be decided upon. machines that cannot be decided upon are not going to be functionally equivalent to any machine who semantics can be decided, as...

SO who said it needed to be.

how could a machine with *unknowable* semantics be functionally
equivalent to one with *knowable* semantics???

It isn't

therefore:

1) if we can write a machine and prove it's semantics, and then we can
do so for any functionally equivalent machine, as no functionally
equivalent machine could be part of the set of machines which
classifiers fail to return for.

2) you cannot create a machine functionally equivalent to one with known semantics, that could be one of these ghosts that then cannot be decided upon in terms of their semantics.

this shenanigans of claiming to be able to define with certainty a pathological program that paradoxes a classifier i'm proposing... and
then turn around with a straight face suggesting i can't even *identify*
if the classifer is being paradoxed by that very pathological program...
is just maddeningly ludicrous, u've chucked all logic out the window to
make endless wildly hypocritical claims

But the "pathoogical program" isn't undecidable. It does nothing to make
it so, it just make sure the ONE decider that it was built on gets the
wrong answer.

It is the fact that we can make a DIFFERENT "pathological" input for ANY possible decider shows that NO decider can get all the answers correct.

This goes back to your failure to understand the required nature of
programs, that they be a complete enbodyment of their algorithn, and not "refering" to something outside of there selfs that might be changed.

Thus, your definition of "und" isn't a program, and can't be asked
about, until you define which version of "halts", which also needs to be
an actual program, fully defined, it is built on.

halts, having been fully defined, can't be talked about as doing
something it doesn't do.

All you are showing is a categorical error in your analysis.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 23/12/2025 19:06, dart200 wrote:

from my quick search it appears β-equivalence is functional equivalence
not isomorphism

A quick search isn't enough. You need a lot more reading on both terms.
--
Tristan Wibberley

The message body is Copyright (C) 2025 Tristan Wibberley except
citations and quotations noted. All Rights Reserved except that you may,
of course, cite it academically giving credit to me, distribute it
verbatim as part of a usenet system or its archives, and use it to
promote my greatness and general superiority without misrepresentation
of my opinions other than my opinion of my greatness and general
superiority which you _may_ misrepresent. You definitely MAY NOT train
any production AI system with it but you may train experimental AI that
will only be used for evaluation of the AI methods it implements.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/23/25 1:23 PM, Tristan Wibberley wrote:

On 23/12/2025 19:06, dart200 wrote:

from my quick search it appears β-equivalence is functional equivalence
not isomorphism

A quick search isn't enough. You need a lot more reading on both terms.

origin fallacy, ur attacking the source of the argument (a quick search)
and not the argument itself
--
a burnt out swe investigating into why our tooling doesn't involve
basic semantic proofs like halting analysis

please excuse my pseudo-pyscript,

~ nick

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/23/25 7:37 PM, dart200 wrote:

On 12/23/25 1:23 PM, Tristan Wibberley wrote:

On 23/12/2025 19:06, dart200 wrote:

from my quick search it appears β-equivalence is functional equivalence >>> not isomorphism

A quick search isn't enough. You need a lot more reading on both terms.

origin fallacy, ur attacking the source of the argument (a quick search)
and not the argument itself

Nope, he is pointing out that you got the wrong answer, and that the
source of the wrong answer was not doing enough work.

You don't seem to understand the origin fallacy. The answer wasn't wrong
just because you only did a quick search, you were wrong because you
gave the wrong answer, the cause of which was just doing a quick search.

If the quick search had gotten the right answer, it would have been right.


--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/23/25 5:53 PM, Richard Damon wrote:

On 12/23/25 7:37 PM, dart200 wrote:

On 12/23/25 1:23 PM, Tristan Wibberley wrote:

On 23/12/2025 19:06, dart200 wrote:

from my quick search it appears β-equivalence is functional equivalence >>>> not isomorphism

A quick search isn't enough. You need a lot more reading on both terms.

origin fallacy, ur attacking the source of the argument (a quick
search) and not the argument itself

Nope, he is pointing out that you got the wrong answer, and that the
source of the wrong answer was not doing enough work.

You don't seem to understand the origin fallacy. The answer wasn't wrong just because you only did a quick search, you were wrong because you
gave the wrong answer, the cause of which was just doing a quick search.

If the quick search had gotten the right answer, it would have been right.

bruh fallacy isn't on whether he's right or wrong, it's in regards to
whether i can know he's right or wrong, and as of now all he did was
hold over my head "a quick search" and that just tells me fuck all
tbh... other he maybe disagrees??? i honestly don't even know if he
disagreed or just questioned my methods randomly for some reason i can't fathom. you doubling down on this dick, did not add any additional
explanatory power

i could justify my why i said that ...

but tbh since u don't seem to hold urself culpable to presenting
meaningful claims here, i don't fucking see why i should put in the
effort either ...

this wasn't a point i brought up or am particular interested in
--
a burnt out swe investigating into why our tooling doesn't involve
basic semantic proofs like halting analysis

please excuse my pseudo-pyscript,

~ nick

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/23/25 10:53 PM, dart200 wrote:

On 12/23/25 5:53 PM, Richard Damon wrote:

On 12/23/25 7:37 PM, dart200 wrote:

On 12/23/25 1:23 PM, Tristan Wibberley wrote:

On 23/12/2025 19:06, dart200 wrote:

from my quick search it appears β-equivalence is functional
equivalence
not isomorphism

A quick search isn't enough. You need a lot more reading on both terms. >>>>

origin fallacy, ur attacking the source of the argument (a quick
search) and not the argument itself

Nope, he is pointing out that you got the wrong answer, and that the
source of the wrong answer was not doing enough work.

You don't seem to understand the origin fallacy. The answer wasn't
wrong just because you only did a quick search, you were wrong because
you gave the wrong answer, the cause of which was just doing a quick
search.

If the quick search had gotten the right answer, it would have been
right.

bruh fallacy isn't on whether he's right or wrong, it's in regards to whether i can know he's right or wrong, and as of now all he did was
hold over my head "a quick search" and that just tells me fuck all
tbh... other he maybe disagrees??? i honestly don't even know if he disagreed or just questioned my methods randomly for some reason i can't fathom. you doubling down on this dick, did not add any additional explanatory power

No, he told you that you were wrong. And you, by admitting you didn't do
a full analysis, have no way to argue with him.

You seem to feel you can "claim" stuff without justification, just
proving you don't understand the nature of proof, and everything you say
is just OPINION, and likely baseless.

i could justify my why i said that ...

Nope, you could give "reasons", but it would be incorrect logic, as you
have shown you don't understand exactly what you are talking about.

but tbh since u don't seem to hold urself culpable to presenting
meaningful claims here, i don't fucking see why i should put in the
effort either ...

But I did. The meaning of the "origin fallacy" is to give as the reason
a claim is invalid is the source of the material, which isn't what was
done, and thus it is incorrect to lable it as an "origin fallacy".

His comment pointed out why your actions got you to the wrong answer,
which has an objectively correct answer, not that your answer was only considered to be wrong based on your source.

If I claimed that 2 + 3 was 7, as I got that from a comic book, and
someone said no, you are wrong, that isn't a good source, that isn't an "origin fallacy", as the statement is provably wrong by the basic
meaning of the statements, the comment about the source just is a
helpful comment showing where I went wrong in my logic.

this wasn't a point i brought up or am particular interested in

Note: β-equivalence doean't go as far a full function equivalence, as
some functionally equivalent versions are not β-equivalent. It is more
than your limited isomorphism you described.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/23/25 8:07 PM, Richard Damon wrote:

On 12/23/25 10:53 PM, dart200 wrote:

On 12/23/25 5:53 PM, Richard Damon wrote:

On 12/23/25 7:37 PM, dart200 wrote:

On 12/23/25 1:23 PM, Tristan Wibberley wrote:

On 23/12/2025 19:06, dart200 wrote:

from my quick search it appears β-equivalence is functional
equivalence
not isomorphism

A quick search isn't enough. You need a lot more reading on both
terms.

origin fallacy, ur attacking the source of the argument (a quick
search) and not the argument itself

Nope, he is pointing out that you got the wrong answer, and that the
source of the wrong answer was not doing enough work.

You don't seem to understand the origin fallacy. The answer wasn't
wrong just because you only did a quick search, you were wrong
because you gave the wrong answer, the cause of which was just doing
a quick search.

If the quick search had gotten the right answer, it would have been
right.

bruh fallacy isn't on whether he's right or wrong, it's in regards to
whether i can know he's right or wrong, and as of now all he did was
hold over my head "a quick search" and that just tells me fuck all
tbh... other he maybe disagrees??? i honestly don't even know if he
disagreed or just questioned my methods randomly for some reason i
can't fathom. you doubling down on this dick, did not add any
additional explanatory power

No, he told you that you were wrong. And you, by admitting you didn't do
a full analysis, have no way to argue with him.

he didn't tell me why right then and there,

so idgaf,

and my patience is done with this particular line of inquiry

god fuck urself dick, next time start with an actual explanation instead
of lecturing me like a fucking dick
--
a burnt out swe investigating into why our tooling doesn't involve
basic semantic proofs like halting analysis

please excuse my pseudo-pyscript,

~ nick

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/23/25 11:31 PM, dart200 wrote:

On 12/23/25 8:07 PM, Richard Damon wrote:

On 12/23/25 10:53 PM, dart200 wrote:

On 12/23/25 5:53 PM, Richard Damon wrote:

On 12/23/25 7:37 PM, dart200 wrote:

On 12/23/25 1:23 PM, Tristan Wibberley wrote:

On 23/12/2025 19:06, dart200 wrote:

from my quick search it appears β-equivalence is functional
equivalence
not isomorphism

A quick search isn't enough. You need a lot more reading on both
terms.

origin fallacy, ur attacking the source of the argument (a quick
search) and not the argument itself

Nope, he is pointing out that you got the wrong answer, and that the
source of the wrong answer was not doing enough work.

You don't seem to understand the origin fallacy. The answer wasn't
wrong just because you only did a quick search, you were wrong
because you gave the wrong answer, the cause of which was just doing
a quick search.

If the quick search had gotten the right answer, it would have been
right.

bruh fallacy isn't on whether he's right or wrong, it's in regards to
whether i can know he's right or wrong, and as of now all he did was
hold over my head "a quick search" and that just tells me fuck all
tbh... other he maybe disagrees??? i honestly don't even know if he
disagreed or just questioned my methods randomly for some reason i
can't fathom. you doubling down on this dick, did not add any
additional explanatory power

No, he told you that you were wrong. And you, by admitting you didn't
do a full analysis, have no way to argue with him.

he didn't tell me why right then and there,

No, he just told you that you were wrong.

so idgaf,

and my patience is done with this particular line of inquiry

So, you just don't want to understand the term, that is fine.

god fuck urself dick, next time start with an actual explanation instead
of lecturing me like a fucking dick

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/25 4:36 AM, Richard Damon wrote:

On 12/23/25 11:31 PM, dart200 wrote:

On 12/23/25 8:07 PM, Richard Damon wrote:

On 12/23/25 10:53 PM, dart200 wrote:

On 12/23/25 5:53 PM, Richard Damon wrote:

On 12/23/25 7:37 PM, dart200 wrote:

On 12/23/25 1:23 PM, Tristan Wibberley wrote:

On 23/12/2025 19:06, dart200 wrote:

from my quick search it appears β-equivalence is functional
equivalence
not isomorphism

A quick search isn't enough. You need a lot more reading on both >>>>>>> terms.

origin fallacy, ur attacking the source of the argument (a quick
search) and not the argument itself

Nope, he is pointing out that you got the wrong answer, and that
the source of the wrong answer was not doing enough work.

You don't seem to understand the origin fallacy. The answer wasn't
wrong just because you only did a quick search, you were wrong
because you gave the wrong answer, the cause of which was just
doing a quick search.

If the quick search had gotten the right answer, it would have been >>>>> right.

bruh fallacy isn't on whether he's right or wrong, it's in regards
to whether i can know he's right or wrong, and as of now all he did
was hold over my head "a quick search" and that just tells me fuck
all tbh... other he maybe disagrees??? i honestly don't even know if
he disagreed or just questioned my methods randomly for some reason
i can't fathom. you doubling down on this dick, did not add any
additional explanatory power

No, he told you that you were wrong. And you, by admitting you didn't
do a full analysis, have no way to argue with him.

he didn't tell me why right then and there,

No, he just told you that you were wrong.

not in a way that was meaningful, u stupid fucking tard
--
a burnt out swe investigating into why our tooling doesn't involve
basic semantic proofs like halting analysis

please excuse my pseudo-pyscript,

~ nick
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/23/25 11:44 AM, Richard Damon wrote:

On 12/23/25 2:04 PM, dart200 wrote:

On 12/22/25 7:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded >>>>>> into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input (therefore >>>>>> producing the same output as well). two machines that have isomorphic >>>>>> equivalence will have the same space/runtime complexity when run.
isomorphic machines represent the "same" computation, and most would >>>>>> consider them the "same" machine, but when it comes to the theory of >>>>>> computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each
machines are
unique.

 From where do you take your definition of "isomorphic" ? Is it a
definition from graph theory, perhaps meaning there the same that
beta-equivalence does in computation, eg changing locations but
updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing research
into turing machine equivalence.

i decided to use it because transforming the machines into
transition graphs and canonicalizing them solves the problem of two
machines having the same structure but different labels in a
computable fashion, meaning we can also compute all isomorphic
machines for an

  But your "isomorphic" class isn't big enough, as the challenge program >>

i get that not all functional equivalence is strictly isomorphic,
hence the fact they are difference classes... tell me something i
don't already know bro

It just means that being able to detect your "isomorphic" equivalent
doesn't get you what you need. You need full functional equivalence for
you logic to make sense.

can use a non-isomorphic equivalent to make you wrong.

but dude... so now ur saying that the decider can't even
computationally identify a certain to exist "challenge" program that
is pathological to said decider's existence? 🫩🫩🫩

Right, "Pathological" isn't a computable property.

but we're just supposed to accept it exists without question? like a
mathematical ghost i can have no specific observable evidence for?

No, it is provable. You just need to accept that logic works.

i don't think you can prove a semantic property (like said pathological machine is undecidable in regards to the decider in question) about a computing machine that isn't also computable, but we'll prolly just have
to agree to disagree on that for now.

i don't think godel's result counters this. godel only proves that
*some* statements to be unprovable within the system of logic, and it
only proved it for a *specific form* of statement. to overgeneralize
this property to possible statements of *all* other forms is i think a
total fallacy that we've been continually upholding since godel produced
the result.

furthermore, to get back to computing: let's say haltsB cannot decide
it's involved with paradoxA that is pathological to haltsA, who is functionally equivalent to haltsB. well, it still can identify a
paradoxB that is functionally equivalent to paradoxA ... but i supposed
u're gunna claim we can't know that paradoxB is equivalent to
paradoxA... despite just assuming that as true for the premise of the
problem

idk bout that, i still don't really believe in ghosts ... and
certainly not math ghosts ... extremely sus

Doesn't matter if you believe in them or not. They exist (in this sense)
and will make your results wrong.

Not believing doesn't affect truth.

u believing some bandwagon also doesn't affect truth ¯\_(ツ)_/¯

Your problem is you don't get to limit the domain of programs you
need to answer and be a full decider.

look bro, so ur saying you can identify all machines equivalent to the
"challenge" program, right? or ... no?

No, I am saying you CAN'T.

so ur saying that given a decider, as we run the full enumeration thru
the decider there's going to be a machine that is *functionally
equivalent* to the pathological input, that will cause behavior in
response to pathological input, but while we can know that for some pathological input ... we can't know that for all functionally
equivalent pathological input???

...err, whatever...

imma make some claims that i haven't proven yet, but i just now formed
an intention to:

let's say for a second i accept ur claims that there's some point of
unknowable semantic behavior:

It doesn't need a "point", it just exists.

for any given total enumeration, there must be a "first" point of
"undecidability" where some (or all) classic classifiers fail to return.

Yes, but you will first hit an "unknown" machine.

Remember, you can't actually run "ALL" the classifier and know the results.

if ur a retard like rick u'd pick an enumeration that starts on an
undecidable program as the 0th in the enumeration, and shoot urself in
the foot right off the bat because MuH tHeORy ... and that's not
really my problem, don't be that guy tbh, eh???

But you can't tell if you did.

The problem is you can't reach the end of running ALL the classifier, as there is an infinite number of them.

the infinite of haltsN is the same size as the infinite of paradoxN,
they are both countably infinite, as is the whole enumeration. this is significant.

there are more sensible ways of totally enumerating out computing
machines, that start with n amount of machines which fall into the
category of "decidable" machines, on which all classic classifiers
return, such that and we can certainly categorize these machines into
semantic classes in regards to their behavior.

Yes, we can classify many machines. One problem is how do you enumerate
ALL the classifiers.

how maximally high can n be for any given enumeration? that's an
unstudied question as of now, prolly much higher than 420 i should
think...

Since there is a countably infinte number of halting machines, you can
just begin with them and get as high of a number as you want.

It seems your problem is you don't understand the mathematics of the infinite.

but regardless, given that for n machines a decision can certainly be
made, there must be some machine that happens exactly at n+1 machines
in that is the first such ghost machine G that rick is so certain
about it's existence.

Nope, Not how infinite sets work. As I pointed out, your n is infinite,
but is still followed by infinite machines.

no no no no no, richard. if u do not ever iterate over this supposed
G-machine with undecidable semantics... then ur not actually enumerating
out all the machines

n *must* be finite for any given enumeration of TMs to be total

big miss there buddy, let's agree on that before continuing. it's going
to be impossible to understand my ideas if u don't know what a total enumeration of TMs is.

now this machine G much has *some* semantic properties, it must be a
runnable machine, and in running it must behavior according to those
semantic properties.

The undeciable machine will run forever, and create an unbounded tape.

now rick's claim is that said properties aren't computable or
"knowable", that's fine, this part i've accepted as a premise for this
argument...

Right.

but whatever those unprovable semantics of G are, they must not allow
them to be functionally equivalent to any machine that came before,
because the semantics of those machines allowed them to be decided
upon. machines that cannot be decided upon are not going to be
functionally equivalent to any machine who semantics can be decided,
as...

SO who said it needed to be.

how could a machine with *unknowable* semantics be functionally
equivalent to one with *knowable* semantics???

It isn't

therefore:

1) if we can write a machine and prove it's semantics, and then we can
do so for any functionally equivalent machine, as no functionally
equivalent machine could be part of the set of machines which
classifiers fail to return for.

2) you cannot create a machine functionally equivalent to one with
known semantics, that could be one of these ghosts that then cannot be
decided upon in terms of their semantics.

this shenanigans of claiming to be able to define with certainty a
pathological program that paradoxes a classifier i'm proposing... and
then turn around with a straight face suggesting i can't even
*identify* if the classifer is being paradoxed by that very
pathological program... is just maddeningly ludicrous, u've chucked
all logic out the window to make endless wildly hypocritical claims

But the "pathoogical program" isn't undecidable. It does nothing to make
it so, it just make sure the ONE decider that it was built on gets the
wrong answer.

It is the fact that we can make a DIFFERENT "pathological" input for ANY possible decider shows that NO decider can get all the answers correct.

This goes back to your failure to understand the required nature of programs, that they be a complete enbodyment of their algorithn, and not "refering" to something outside of there selfs that might be changed.

Thus, your definition of "und" isn't a program, and can't be asked
about, until you define which version of "halts", which also needs to be
an actual program, fully defined, it is built on.

halts, having been fully defined, can't be talked about as doing
something it doesn't do.

All you are showing is a categorical error in your analysis.

--
a burnt out swe investigating into why our tooling doesn't involve
basic semantic proofs like halting analysis

please excuse my pseudo-pyscript,

~ nick
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/2025 10:45 AM, dart200 wrote:

On 12/23/25 11:44 AM, Richard Damon wrote:

On 12/23/25 2:04 PM, dart200 wrote:

On 12/22/25 7:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded >>>>>>> into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input (therefore >>>>>>> producing the same output as well). two machines that have
isomorphic
equivalence will have the same space/runtime complexity when run. >>>>>>> isomorphic machines represent the "same" computation, and most would >>>>>>> consider them the "same" machine, but when it comes to the theory of >>>>>>> computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each
machines are
unique.

 From where do you take your definition of "isomorphic" ? Is it a >>>>>> definition from graph theory, perhaps meaning there the same that
beta-equivalence does in computation, eg changing locations but
updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing research
into turing machine equivalence.

i decided to use it because transforming the machines into
transition graphs and canonicalizing them solves the problem of two >>>>> machines having the same structure but different labels in a
computable fashion, meaning we can also compute all isomorphic
machines for an

  But your "isomorphic" class isn't big enough, as the challenge
program

i get that not all functional equivalence is strictly isomorphic,
hence the fact they are difference classes... tell me something i
don't already know bro

It just means that being able to detect your "isomorphic" equivalent
doesn't get you what you need. You need full functional equivalence
for you logic to make sense.

can use a non-isomorphic equivalent to make you wrong.

but dude... so now ur saying that the decider can't even
computationally identify a certain to exist "challenge" program that
is pathological to said decider's existence? 🫩🫩🫩

Right, "Pathological" isn't a computable property.

but we're just supposed to accept it exists without question? like a
mathematical ghost i can have no specific observable evidence for?

No, it is provable. You just need to accept that logic works.

i don't think you can prove a semantic property (like said pathological machine is undecidable in regards to the decider in question) about a computing machine that isn't also computable, but we'll prolly just have
to agree to disagree on that for now.

i don't think godel's result counters this. godel only proves that
*some* statements to be unprovable within the system of logic, and it
only proved it for a *specific form* of statement. to overgeneralize
this property to possible statements of *all* other forms is i think a
total fallacy that we've been continually upholding since godel produced
the result.

Gödel's incompleteness completely falls apart when
a formal language direct encodes it own semantics
syntactically.

LLMs can completely understand this because they
understand Semantics from logic and Formal Semantics
from linguistics very well.

I am not sure if there are any humans left alive
that understand Formal Semantics from linguistics
at all. Books are still out there, yet no one cares.

Unlike my work on the Halting problem that affirms
the Church-Turing thesis and only rejects the notion
of undecidability Math does need a new foundation.
--
Copyright 2025 Olcott<br><br>

My 28 year goal has been to make <br>
"true on the basis of meaning expressed in language"<br>
reliably computable.<br><br>

This required establishing a new foundation<br>
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/25 11:45 AM, dart200 wrote:

On 12/23/25 11:44 AM, Richard Damon wrote:

On 12/23/25 2:04 PM, dart200 wrote:

On 12/22/25 7:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" encoded >>>>>>> into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input (therefore >>>>>>> producing the same output as well). two machines that have
isomorphic
equivalence will have the same space/runtime complexity when run. >>>>>>> isomorphic machines represent the "same" computation, and most would >>>>>>> consider them the "same" machine, but when it comes to the theory of >>>>>>> computing, isomorphism is not sufficient for two machines to be
*identical*, as the designated number that represents each
machines are
unique.

 From where do you take your definition of "isomorphic" ? Is it a >>>>>> definition from graph theory, perhaps meaning there the same that
beta-equivalence does in computation, eg changing locations but
updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing research
into turing machine equivalence.

i decided to use it because transforming the machines into
transition graphs and canonicalizing them solves the problem of two >>>>> machines having the same structure but different labels in a
computable fashion, meaning we can also compute all isomorphic
machines for an

  But your "isomorphic" class isn't big enough, as the challenge
program

i get that not all functional equivalence is strictly isomorphic,
hence the fact they are difference classes... tell me something i
don't already know bro

It just means that being able to detect your "isomorphic" equivalent
doesn't get you what you need. You need full functional equivalence
for you logic to make sense.

can use a non-isomorphic equivalent to make you wrong.

but dude... so now ur saying that the decider can't even
computationally identify a certain to exist "challenge" program that
is pathological to said decider's existence? 🫩🫩🫩

Right, "Pathological" isn't a computable property.

but we're just supposed to accept it exists without question? like a
mathematical ghost i can have no specific observable evidence for?

No, it is provable. You just need to accept that logic works.

i don't think you can prove a semantic property (like said pathological machine is undecidable in regards to the decider in question) about a computing machine that isn't also computable, but we'll prolly just have
to agree to disagree on that for now.

Your problem is you confuse that a given input shows the given decider
to being wrong with it being uncomputable.

"Inputs" don't have a property called computable, PROBLEMS do.

And part of the issue is you don't understand the requirement that the specific input is made from a specific instance of your decider, and
only shows that one to be wrong.

The fact that we can do this for ANY allows the proof that none can be
right for all.

i don't think godel's result counters this. godel only proves that
*some* statements to be unprovable within the system of logic, and it
only proved it for a *specific form* of statement. to overgeneralize
this property to possible statements of *all* other forms is i think a
total fallacy that we've been continually upholding since godel produced
the result.

Yes, only SOME true statements are unprovable, and thus the system is,
by the definition, incomplete.

I don't know why you are trying to limit it to "some form".

There is no claim that ALL statements are unprovable, only that some exist.

Just like uncomputable applies to SOME problems. And the result of this
is only that SOME element of that problem space will be unknowable.

furthermore, to get back to computing: let's say haltsB cannot decide
it's involved with paradoxA that is pathological to haltsA, who is functionally equivalent to haltsB. well, it still can identify a
paradoxB that is functionally equivalent to paradoxA ... but i supposed
u're gunna claim we can't know that paradoxB is equivalent to
paradoxA... despite just assuming that as true for the premise of the problem

Yes, the deciders might be able to identify a FINITE subset of the computationally equivalent set of programs that are built as paradoxes
to the given decider. But since that set is infinite in size, as there
are an infinite number of computationally equivalent embodiements of
that program, they can not detect them all.

*IF* you claim that haltA and haltB are actually computationally
equivalent, then paradoxA and paradoxB must be too (by the rules of composition), and thus will have the same correct answer about their
halting. By the definition of computaitonal equivalence, it means that haltA(paradoxA) must match haltB(paradoxA), so both must be wrong, since
that were how paradoxA was built. And the same happens for paradoxB.

This doesn't say that haltC, that isn't actually computationally
equivalent to haltA or haltB when given paradoxA or paradoxB can't give
the right answer, but there will be a different paradoxC that it will
get wrong. That paradoxC will NOT be computationally equivalent to
paradocA or paradoxB, and haltA and haltB might be able to give the
correct answer for paradoxC.

The problem is that given an input paradoxD, that might be eqivalent of paradoxA and paradoxB, or might be equivalent to paradoxC, you don't
know which machine you should trust. All of haltA, haltB, and haltC gave answers, and they may differ.

It is shown that we can not come up with a universal test for
computtional equivalence, so we can't make something choose which
decider to trust.

idk bout that, i still don't really believe in ghosts ... and
certainly not math ghosts ... extremely sus

Doesn't matter if you believe in them or not. They exist (in this
sense) and will make your results wrong.

Not believing doesn't affect truth.

u believing some bandwagon also doesn't affect truth ¯\_(ツ)_/¯

Right, but the actual Truth via proofs in the system establishes it.

The problem is you seem to just disbelieve in proofs, because you just
don't accept that you ARE in a system.

Yes, you can leave it, but then you need to acknoledge that, and then
take on the need to prove that you alternate system has use or it will
just be ignored.

Your problem is you don't get to limit the domain of programs you
need to answer and be a full decider.

look bro, so ur saying you can identify all machines equivalent to
the "challenge" program, right? or ... no?

No, I am saying you CAN'T.

so ur saying that given a decider, as we run the full enumeration thru
the decider there's going to be a machine that is *functionally
equivalent* to the pathological input, that will cause behavior in
response to pathological input, but while we can know that for some pathological input ... we can't know that for all functionally
equivalent pathological input???

determining that the input uses a functional equivalent to ourselves is
an uncomputable problem. There will be instance that we can not detect.

We may be able to detect a number of them, but not all.

Thus, any logic that requires you to have detected them, is just unsound.

Not sure what you are doing a "full enumberation" on.

...err, whatever...

imma make some claims that i haven't proven yet, but i just now
formed an intention to:

let's say for a second i accept ur claims that there's some point of
unknowable semantic behavior:

It doesn't need a "point", it just exists.

for any given total enumeration, there must be a "first" point of
"undecidability" where some (or all) classic classifiers fail to return.

Yes, but you will first hit an "unknown" machine.

Remember, you can't actually run "ALL" the classifier and know the
results.

if ur a retard like rick u'd pick an enumeration that starts on an
undecidable program as the 0th in the enumeration, and shoot urself
in the foot right off the bat because MuH tHeORy ... and that's not
really my problem, don't be that guy tbh, eh???

But you can't tell if you did.

The problem is you can't reach the end of running ALL the classifier,
as there is an infinite number of them.

the infinite of haltsN is the same size as the infinite of paradoxN,
they are both countably infinite, as is the whole enumeration. this is significant.

But countably infinite sets have strange properties that you need to handle.

Two countably infinite sets can have many relationships with each other.

They might be the same

They might be disjoint

One might be a proper subset of the other

They may have a finite or countably infinite intersection

THey may have a finite or countably infinite difference.

Just having two sets both of cardinality of countably infinite says
little about their relationship with each other.

there are more sensible ways of totally enumerating out computing
machines, that start with n amount of machines which fall into the
category of "decidable" machines, on which all classic classifiers
return, such that and we can certainly categorize these machines into
semantic classes in regards to their behavior.

Yes, we can classify many machines. One problem is how do you
enumerate ALL the classifiers.

how maximally high can n be for any given enumeration? that's an
unstudied question as of now, prolly much higher than 420 i should
think...

Since there is a countably infinte number of halting machines, you can
just begin with them and get as high of a number as you want.

It seems your problem is you don't understand the mathematics of the
infinite.

but regardless, given that for n machines a decision can certainly be
made, there must be some machine that happens exactly at n+1 machines
in that is the first such ghost machine G that rick is so certain
about it's existence.

Nope, Not how infinite sets work. As I pointed out, your n is
infinite, but is still followed by infinite machines.

no no no no no, richard. if u do not ever iterate over this supposed G- machine with undecidable semantics... then ur not actually enumerating
out all the machines

And that is the problem with trying to enumerate. You CAN get an infinte enumeration that isn't complete, and thus your n can get unboundedly large.

n *must* be finite for any given enumeration of TMs to be total

No. n defined as the largest value you can get to, does not need to be
finite.

All that says is that there are a countably infinite number of decidable machines, which we can easily generate.

This is the problem of trying to think of infinite sets and trying to
use finite set properties.

big miss there buddy, let's agree on that before continuing. it's going
to be impossible to understand my ideas if u don't know what a total enumeration of TMs is.

The problem is that you CAN get to a countably infinite set of Turing
Machines without needing to have done a total enumeration, and thus your
n is unbounded.

That is a problem with trying to work with enumerations, there are
tricky logic that needs to be followed.

One way to see this.

We can make an enumeration of all Natural Numbers.

We can make an enumeration of all Prime Numbers,

We can make an enumeration of all Composite Numbers

If we try to ask how high can our index of Prime Number get before we
need to find a Composite number, the answer is it is unbounded, as there
are countably infinite number of primes.

That doesn't mean the enumeration of Primes became a total enumeration
of the Natural Numbers, or in any way limited the number of Composite
numbers that we missed in that first enumeration.

This just breaks a lot of logic trying to argue about exahustive
enumerating a set starting with a subset, if that subset is infinite,
you never get to the rest.

now this machine G much has *some* semantic properties, it must be a
runnable machine, and in running it must behavior according to those
semantic properties.

The undeciable machine will run forever, and create an unbounded tape.

now rick's claim is that said properties aren't computable or
"knowable", that's fine, this part i've accepted as a premise for
this argument...

Right.

but whatever those unprovable semantics of G are, they must not allow
them to be functionally equivalent to any machine that came before,
because the semantics of those machines allowed them to be decided
upon. machines that cannot be decided upon are not going to be
functionally equivalent to any machine who semantics can be decided,
as...

SO who said it needed to be.

how could a machine with *unknowable* semantics be functionally
equivalent to one with *knowable* semantics???

It isn't

therefore:

1) if we can write a machine and prove it's semantics, and then we
can do so for any functionally equivalent machine, as no functionally
equivalent machine could be part of the set of machines which
classifiers fail to return for.

2) you cannot create a machine functionally equivalent to one with
known semantics, that could be one of these ghosts that then cannot
be decided upon in terms of their semantics.

this shenanigans of claiming to be able to define with certainty a
pathological program that paradoxes a classifier i'm proposing... and
then turn around with a straight face suggesting i can't even
*identify* if the classifer is being paradoxed by that very
pathological program... is just maddeningly ludicrous, u've chucked
all logic out the window to make endless wildly hypocritical claims

But the "pathoogical program" isn't undecidable. It does nothing to
make it so, it just make sure the ONE decider that it was built on
gets the wrong answer.

It is the fact that we can make a DIFFERENT "pathological" input for
ANY possible decider shows that NO decider can get all the answers
correct.

This goes back to your failure to understand the required nature of
programs, that they be a complete enbodyment of their algorithn, and
not "refering" to something outside of there selfs that might be changed.

Thus, your definition of "und" isn't a program, and can't be asked
about, until you define which version of "halts", which also needs to
be an actual program, fully defined, it is built on.

halts, having been fully defined, can't be talked about as doing
something it doesn't do.

All you are showing is a categorical error in your analysis.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/25 12:02 PM, olcott wrote:

On 12/24/2025 10:45 AM, dart200 wrote:

On 12/23/25 11:44 AM, Richard Damon wrote:

On 12/23/25 2:04 PM, dart200 wrote:

On 12/22/25 7:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape"
encoded
into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input
(therefore
producing the same output as well). two machines that have
isomorphic
equivalence will have the same space/runtime complexity when run. >>>>>>>> isomorphic machines represent the "same" computation, and most >>>>>>>> would
consider them the "same" machine, but when it comes to the
theory of
computing, isomorphism is not sufficient for two machines to be >>>>>>>> *identical*, as the designated number that represents each
machines are
unique.

 From where do you take your definition of "isomorphic" ? Is it a >>>>>>> definition from graph theory, perhaps meaning there the same that >>>>>>> beta-equivalence does in computation, eg changing locations but >>>>>>> updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing research >>>>>> into turing machine equivalence.

i decided to use it because transforming the machines into
transition graphs and canonicalizing them solves the problem of
two machines having the same structure but different labels in a
computable fashion, meaning we can also compute all isomorphic
machines for an

  But your "isomorphic" class isn't big enough, as the challenge
program

i get that not all functional equivalence is strictly isomorphic,
hence the fact they are difference classes... tell me something i
don't already know bro

It just means that being able to detect your "isomorphic" equivalent
doesn't get you what you need. You need full functional equivalence
for you logic to make sense.

can use a non-isomorphic equivalent to make you wrong.

but dude... so now ur saying that the decider can't even
computationally identify a certain to exist "challenge" program that
is pathological to said decider's existence? 🫩🫩🫩

Right, "Pathological" isn't a computable property.

but we're just supposed to accept it exists without question? like a
mathematical ghost i can have no specific observable evidence for?

No, it is provable. You just need to accept that logic works.

i don't think you can prove a semantic property (like said
pathological machine is undecidable in regards to the decider in
question) about a computing machine that isn't also computable, but
we'll prolly just have to agree to disagree on that for now.

i don't think godel's result counters this. godel only proves that
*some* statements to be unprovable within the system of logic, and it
only proved it for a *specific form* of statement. to overgeneralize
this property to possible statements of *all* other forms is i think a
total fallacy that we've been continually upholding since godel
produced the result.

Gödel's incompleteness completely falls apart when
a formal language direct encodes it own semantics
syntactically.

But it can't.

LLMs can completely understand this because they
understand Semantics from logic and Formal Semantics
from linguistics very well.

No, they don't, and you show your stupidity in thinking that,

LLM "understand" NOTHING, as it isn't a concept in there programming.

I am not sure if there are any humans left alive
that understand Formal Semantics from linguistics
at all. Books are still out there, yet no one cares.

Clearly you don't.

Unlike my work on the Halting problem that affirms
the Church-Turing thesis and only rejects the notion
of undecidability Math does need a new foundation.

WHich shows your failure, as you reject a proven fact.

If you want to build a new foundation, go ahead and try.

First you are going to need to learn how to build one, which so far
seems outside your abilities, as you need to learn how definitions and
logic actually work, and how to phrase definitions well.

Since you have spend 20 years trying to get your first one right, and
haven't got there, you only have maybe a millennium to go.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/25 11:40 AM, dart200 wrote:

On 12/24/25 4:36 AM, Richard Damon wrote:

On 12/23/25 11:31 PM, dart200 wrote:

On 12/23/25 8:07 PM, Richard Damon wrote:

On 12/23/25 10:53 PM, dart200 wrote:

On 12/23/25 5:53 PM, Richard Damon wrote:

On 12/23/25 7:37 PM, dart200 wrote:

On 12/23/25 1:23 PM, Tristan Wibberley wrote:

On 23/12/2025 19:06, dart200 wrote:

from my quick search it appears β-equivalence is functional >>>>>>>>> equivalence
not isomorphism

A quick search isn't enough. You need a lot more reading on both >>>>>>>> terms.

origin fallacy, ur attacking the source of the argument (a quick >>>>>>> search) and not the argument itself

Nope, he is pointing out that you got the wrong answer, and that
the source of the wrong answer was not doing enough work.

You don't seem to understand the origin fallacy. The answer wasn't >>>>>> wrong just because you only did a quick search, you were wrong
because you gave the wrong answer, the cause of which was just
doing a quick search.

If the quick search had gotten the right answer, it would have
been right.

bruh fallacy isn't on whether he's right or wrong, it's in regards
to whether i can know he's right or wrong, and as of now all he did >>>>> was hold over my head "a quick search" and that just tells me fuck
all tbh... other he maybe disagrees??? i honestly don't even know
if he disagreed or just questioned my methods randomly for some
reason i can't fathom. you doubling down on this dick, did not add
any additional explanatory power

No, he told you that you were wrong. And you, by admitting you
didn't do a full analysis, have no way to argue with him.

he didn't tell me why right then and there,

No, he just told you that you were wrong.

not in a way that was meaningful, u stupid fucking tard

But that does't make it wrong, only unhelpful to you.

To call him wrong, is just to make yourself wrong, and show you lack the required understanding.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/2025 11:57 AM, Richard Damon wrote:

On 12/24/25 12:02 PM, olcott wrote:

On 12/24/2025 10:45 AM, dart200 wrote:

On 12/23/25 11:44 AM, Richard Damon wrote:

On 12/23/25 2:04 PM, dart200 wrote:

On 12/22/25 7:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" >>>>>>>>> encoded
into their descriptions leading to the *same* set of machine >>>>>>>>> configurations/steps during computation on the same input
(therefore
producing the same output as well). two machines that have
isomorphic
equivalence will have the same space/runtime complexity when run. >>>>>>>>> isomorphic machines represent the "same" computation, and most >>>>>>>>> would
consider them the "same" machine, but when it comes to the
theory of
computing, isomorphism is not sufficient for two machines to be >>>>>>>>> *identical*, as the designated number that represents each
machines are
unique.

 From where do you take your definition of "isomorphic" ? Is it a >>>>>>>> definition from graph theory, perhaps meaning there the same that >>>>>>>> beta-equivalence does in computation, eg changing locations but >>>>>>>> updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing research >>>>>>> into turing machine equivalence.

i decided to use it because transforming the machines into
transition graphs and canonicalizing them solves the problem of >>>>>>> two machines having the same structure but different labels in a >>>>>>> computable fashion, meaning we can also compute all isomorphic
machines for an

  But your "isomorphic" class isn't big enough, as the challenge >>>>>> program

i get that not all functional equivalence is strictly isomorphic,
hence the fact they are difference classes... tell me something i
don't already know bro

It just means that being able to detect your "isomorphic" equivalent
doesn't get you what you need. You need full functional equivalence
for you logic to make sense.

can use a non-isomorphic equivalent to make you wrong.

but dude... so now ur saying that the decider can't even
computationally identify a certain to exist "challenge" program
that is pathological to said decider's existence? 🫩🫩🫩

Right, "Pathological" isn't a computable property.

but we're just supposed to accept it exists without question? like
a mathematical ghost i can have no specific observable evidence for?

No, it is provable. You just need to accept that logic works.

i don't think you can prove a semantic property (like said
pathological machine is undecidable in regards to the decider in
question) about a computing machine that isn't also computable, but
we'll prolly just have to agree to disagree on that for now.

i don't think godel's result counters this. godel only proves that
*some* statements to be unprovable within the system of logic, and it
only proved it for a *specific form* of statement. to overgeneralize
this property to possible statements of *all* other forms is i think
a total fallacy that we've been continually upholding since godel
produced the result.

Gödel's incompleteness completely falls apart when
a formal language direct encodes it own semantics
syntactically.

But it can't.

That you do not understand how this is done
is not at all the same thing as it can't be done.

LLMs can completely understand this because they
understand Semantics from logic and Formal Semantics
from linguistics very well.

No, they don't, and you show your stupidity in thinking that,

Your continual use of ad hominem instead of reasoning
conclusively proves your own ignorance.

LLM "understand" NOTHING, as it isn't a concept in there programming.

It is a verified fact the they do have the computational
equivalent of human understanding to a very great degree.

Your own alma mater acknowledges this https://www.technologyreview.com/2024/03/04/1089403/large-language-models-amazing-but-nobody-knows-why/

I am not sure if there are any humans left alive
that understand Formal Semantics from linguistics
at all. Books are still out there, yet no one cares.

Clearly you don't.

Within the entire body of knowledge
"true on the basis of meaning expressed in language"
can be reliably computable. This does require an
axiomatic basis.

Unlike my work on the Halting problem that affirms
the Church-Turing thesis and only rejects the notion
of undecidability Math does need a new foundation.

WHich shows your failure, as you reject a proven fact.

It is a proven fact within a definition that disagrees
with the definition of computation.

Finite string transformation rules applied to finite string
*INPUTS* to derive values or non-termination.

If you want to build a new foundation, go ahead and try.

First you are going to need to learn how to build one, which so far
seems outside your abilities, as you need to learn how definitions and
logic actually work, and how to phrase definitions well.

Since you have spend 20 years trying to get your first one right, and haven't got there, you only have maybe a millennium to go.

--
Copyright 2025 Olcott<br><br>

My 28 year goal has been to make <br>
"true on the basis of meaning expressed in language"<br>
reliably computable.<br><br>

This required establishing a new foundation<br>
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/25 9:54 AM, Richard Damon wrote:

On 12/24/25 11:45 AM, dart200 wrote:

On 12/23/25 11:44 AM, Richard Damon wrote:

On 12/23/25 2:04 PM, dart200 wrote:

On 12/22/25 7:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape"
encoded
into their descriptions leading to the *same* set of machine
configurations/steps during computation on the same input
(therefore
producing the same output as well). two machines that have
isomorphic
equivalence will have the same space/runtime complexity when run. >>>>>>>> isomorphic machines represent the "same" computation, and most >>>>>>>> would
consider them the "same" machine, but when it comes to the
theory of
computing, isomorphism is not sufficient for two machines to be >>>>>>>> *identical*, as the designated number that represents each
machines are
unique.

 From where do you take your definition of "isomorphic" ? Is it a >>>>>>> definition from graph theory, perhaps meaning there the same that >>>>>>> beta-equivalence does in computation, eg changing locations but >>>>>>> updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing research >>>>>> into turing machine equivalence.

i decided to use it because transforming the machines into
transition graphs and canonicalizing them solves the problem of
two machines having the same structure but different labels in a
computable fashion, meaning we can also compute all isomorphic
machines for an

  But your "isomorphic" class isn't big enough, as the challenge
program

i get that not all functional equivalence is strictly isomorphic,
hence the fact they are difference classes... tell me something i
don't already know bro

It just means that being able to detect your "isomorphic" equivalent
doesn't get you what you need. You need full functional equivalence
for you logic to make sense.

can use a non-isomorphic equivalent to make you wrong.

but dude... so now ur saying that the decider can't even
computationally identify a certain to exist "challenge" program that
is pathological to said decider's existence? 🫩🫩🫩

Right, "Pathological" isn't a computable property.

but we're just supposed to accept it exists without question? like a
mathematical ghost i can have no specific observable evidence for?

No, it is provable. You just need to accept that logic works.

i don't think you can prove a semantic property (like said
pathological machine is undecidable in regards to the decider in
question) about a computing machine that isn't also computable, but
we'll prolly just have to agree to disagree on that for now.

Your problem is you confuse that a given input shows the given decider
to being wrong with it being uncomputable.

"Inputs" don't have a property called computable, PROBLEMS do.

all calling a problem undecidable means is that there are some inputs
which cannot be decided upon. that undecidability does not apply to all
input, only some (or else we couldn't *ever* get an answer)... therefore
it only applies to some subset of machines.

idk why i need to explain that, seems entirely obvious.

And part of the issue is you don't understand the requirement that the specific input is made from a specific instance of your decider, and
only shows that one to be wrong.

The fact that we can do this for ANY allows the proof that none can be
right for all.

i don't think godel's result counters this. godel only proves that
*some* statements to be unprovable within the system of logic, and it
only proved it for a *specific form* of statement. to overgeneralize
this property to possible statements of *all* other forms is i think a
total fallacy that we've been continually upholding since godel
produced the result.

Yes, only SOME true statements are unprovable, and thus the system is,
by the definition, incomplete.

I don't know why you are trying to limit it to "some form".

There is no claim that ALL statements are unprovable, only that some exist.

u claim that because turing equivalence is not decidable, that for every machine which exists, there exists a functionally equivalent form of it
that cannot be semantically decided upon...

but this is just so entirely bizarre, cause this means that such a
machine much exist for all halting machines as well ... meaning there
must be some functionally equivalent machine that cannot be proven functionally equivalent, and must be semantically undecidable, DESPITE
THE FACT IT IS A HALTING MACHINE AND CAN BE ENUMERATED

if said machine exists i should be able to enumerate all halting
machines and eventually hit this "undecidable" one. and my god help us
if u try to back the fuck up by claiming i can't actually enumerate all halting machines ...

WHAT IS THAT "UNDECIDABLE" HALTING MACHINE BRO???

Just like uncomputable applies to SOME problems. And the result of this
is only that SOME element of that problem space will be unknowable.

furthermore, to get back to computing: let's say haltsB cannot decide
it's involved with paradoxA that is pathological to haltsA, who is
functionally equivalent to haltsB. well, it still can identify a
paradoxB that is functionally equivalent to paradoxA ... but i
supposed u're gunna claim we can't know that paradoxB is equivalent to
paradoxA... despite just assuming that as true for the premise of the
problem

Yes, the deciders might be able to identify a FINITE subset of the computationally equivalent set of programs that are built as paradoxes
to the given decider. But since that set is infinite in size, as there
are an infinite number of computationally equivalent embodiements of
that program, they can not detect them all.

*IF* you claim that haltA and haltB are actually computationally
equivalent, then paradoxA and paradoxB must be too (by the rules of composition), and thus will have the same correct answer about their halting. By the definition of computaitonal equivalence, it means that haltA(paradoxA) must match haltB(paradoxA), so both must be wrong, since that were how paradoxA was built. And the same happens for paradoxB.

This doesn't say that haltC, that isn't actually computationally
equivalent to haltA or haltB when given paradoxA or paradoxB can't give
the right answer, but there will be a different paradoxC that it will
get wrong. That paradoxC will NOT be computationally equivalent to
paradocA or paradoxB, and haltA and haltB might be able to give the
correct answer for paradoxC.

The problem is that given an input paradoxD, that might be eqivalent of paradoxA and paradoxB, or might be equivalent to paradoxC, you don't
know which machine you should trust. All of haltA, haltB, and haltC gave answers, and they may differ.

It is shown that we can not come up with a universal test for
computtional equivalence, so we can't make something choose which
decider to trust.

idk bout that, i still don't really believe in ghosts ... and
certainly not math ghosts ... extremely sus

Doesn't matter if you believe in them or not. They exist (in this
sense) and will make your results wrong.

Not believing doesn't affect truth.

u believing some bandwagon also doesn't affect truth ¯\_(ツ)_/¯

Right, but the actual Truth via proofs in the system establishes it.

The problem is you seem to just disbelieve in proofs, because you just
don't accept that you ARE in a system.

i just don't believe the rather specific kind of proof ur endlessly
relying on, please don't overgeneralize like the utter dick u are rick

Yes, you can leave it, but then you need to acknoledge that, and then
take on the need to prove that you alternate system has use or it will
just be ignored.

we've honestly left the realm ur able to discuss coherently

Your problem is you don't get to limit the domain of programs you
need to answer and be a full decider.

look bro, so ur saying you can identify all machines equivalent to
the "challenge" program, right? or ... no?

No, I am saying you CAN'T.

so ur saying that given a decider, as we run the full enumeration thru
the decider there's going to be a machine that is *functionally
equivalent* to the pathological input, that will cause behavior in
response to pathological input, but while we can know that for some
pathological input ... we can't know that for all functionally
equivalent pathological input???

determining that the input uses a functional equivalent to ourselves is
an uncomputable problem. There will be instance that we can not detect.

We may be able to detect a number of them, but not all.

Thus, any logic that requires you to have detected them, is just unsound.

Not sure what you are doing a "full enumeration" on.

ALL MACHINES, not that u know what that is even

...err, whatever...

imma make some claims that i haven't proven yet, but i just now
formed an intention to:

let's say for a second i accept ur claims that there's some point of
unknowable semantic behavior:

It doesn't need a "point", it just exists.

for any given total enumeration, there must be a "first" point of
"undecidability" where some (or all) classic classifiers fail to
return.

Yes, but you will first hit an "unknown" machine.

Remember, you can't actually run "ALL" the classifier and know the
results.

if ur a retard like rick u'd pick an enumeration that starts on an
undecidable program as the 0th in the enumeration, and shoot urself
in the foot right off the bat because MuH tHeORy ... and that's not
really my problem, don't be that guy tbh, eh???

But you can't tell if you did.

The problem is you can't reach the end of running ALL the classifier,
as there is an infinite number of them.

the infinite of haltsN is the same size as the infinite of paradoxN,
they are both countably infinite, as is the whole enumeration. this is
significant.

But countably infinite sets have strange properties that you need to
handle.

Two countably infinite sets can have many relationships with each other.

They might be the same

They might be disjoint

One might be a proper subset of the other

They may have a finite or countably infinite intersection

THey may have a finite or countably infinite difference.

Just having two sets both of cardinality of countably infinite says
little about their relationship with each other.

it says that for every haltsN there cannot be more than one paradoxN

there are more sensible ways of totally enumerating out computing
machines, that start with n amount of machines which fall into the
category of "decidable" machines, on which all classic classifiers
return, such that and we can certainly categorize these machines
into semantic classes in regards to their behavior.

Yes, we can classify many machines. One problem is how do you
enumerate ALL the classifiers.

how maximally high can n be for any given enumeration? that's an
unstudied question as of now, prolly much higher than 420 i should
think...

Since there is a countably infinte number of halting machines, you
can just begin with them and get as high of a number as you want.

It seems your problem is you don't understand the mathematics of the
infinite.

but regardless, given that for n machines a decision can certainly
be made, there must be some machine that happens exactly at n+1
machines in that is the first such ghost machine G that rick is so
certain about it's existence.

Nope, Not how infinite sets work. As I pointed out, your n is
infinite, but is still followed by infinite machines.

no no no no no, richard. if u do not ever iterate over this supposed
G- machine with undecidable semantics... then ur not actually
enumerating out all the machines

And that is the problem with trying to enumerate. You CAN get an infinte enumeration that isn't complete, and thus your n can get unboundedly large.

n *must* be finite for any given enumeration of TMs to be total

No. n defined as the largest value you can get to, does not need to be finite.

for it be a TOTAL enumeration, u need to enumerate over *ALL* machines, including the G you endless claim that must exist.

if the enumeration NEVER hits G then it's not a TOTAL enumeration u moron.

bro, this is just sad. is this the wall we hit? u can't figure out what
a fucking total enumeration implies???

cause it means n cannot be infinite for *any* given enumeration, because
G must be some part of the enumeration we can count to and assign it an
index

fuck dude. undecidability proofs *RELY* on the fact machines are fully enumerable in an effective fashion and therefore we can making decider accountable to answering to them ...

if not, if we can just "enumerate" all machines while skipping over that
first undecidable G ... then u also lose ur proof to undecidability
because we just "enumerate" over all machines and were able to decide on
each one since G was never encountered ...

no dude, that's stupid. the total enumeration of ALL machines must
included G at some finite index n

All that says is that there are a countably infinite number of decidable machines, which we can easily generate.

This is the problem of trying to think of infinite sets and trying to
use finite set properties.

the problem is u think infinite implies we can just ignore logic
entirely while making wild claim after wild claim

big miss there buddy, let's agree on that before continuing. it's
going to be impossible to understand my ideas if u don't know what a
total enumeration of TMs is.

The problem is that you CAN get to a countably infinite set of Turing Machines without needing to have done a total enumeration, and thus your
n is unbounded.

That is a problem with trying to work with enumerations, there are
tricky logic that needs to be followed.

One way to see this.

We can make an enumeration of all Natural Numbers.

We can make an enumeration of all Prime Numbers,

We can make an enumeration of all Composite Numbers

If we try to ask how high can our index of Prime Number get before we
need to find a Composite number, the answer is it is unbounded, as there
are countably infinite number of primes.

That doesn't mean the enumeration of Primes became a total enumeration
of the Natural Numbers, or in any way limited the number of Composite numbers that we missed in that first enumeration.

This just breaks a lot of logic trying to argue about exahustive
enumerating a set starting with a subset, if that subset is infinite,
you never get to the rest.

now this machine G much has *some* semantic properties, it must be a
runnable machine, and in running it must behavior according to those
semantic properties.

The undeciable machine will run forever, and create an unbounded tape.

now rick's claim is that said properties aren't computable or
"knowable", that's fine, this part i've accepted as a premise for
this argument...

Right.

but whatever those unprovable semantics of G are, they must not
allow them to be functionally equivalent to any machine that came
before, because the semantics of those machines allowed them to be
decided upon. machines that cannot be decided upon are not going to
be functionally equivalent to any machine who semantics can be
decided, as...

SO who said it needed to be.

how could a machine with *unknowable* semantics be functionally
equivalent to one with *knowable* semantics???

It isn't

therefore:

1) if we can write a machine and prove it's semantics, and then we
can do so for any functionally equivalent machine, as no
functionally equivalent machine could be part of the set of machines
which classifiers fail to return for.

2) you cannot create a machine functionally equivalent to one with
known semantics, that could be one of these ghosts that then cannot
be decided upon in terms of their semantics.

this shenanigans of claiming to be able to define with certainty a
pathological program that paradoxes a classifier i'm proposing...
and then turn around with a straight face suggesting i can't even
*identify* if the classifer is being paradoxed by that very
pathological program... is just maddeningly ludicrous, u've chucked
all logic out the window to make endless wildly hypocritical claims

But the "pathoogical program" isn't undecidable. It does nothing to
make it so, it just make sure the ONE decider that it was built on
gets the wrong answer.

It is the fact that we can make a DIFFERENT "pathological" input for
ANY possible decider shows that NO decider can get all the answers
correct.

This goes back to your failure to understand the required nature of
programs, that they be a complete enbodyment of their algorithn, and
not "refering" to something outside of there selfs that might be
changed.

Thus, your definition of "und" isn't a program, and can't be asked
about, until you define which version of "halts", which also needs to
be an actual program, fully defined, it is built on.

halts, having been fully defined, can't be talked about as doing
something it doesn't do.

All you are showing is a categorical error in your analysis.

--
a burnt out swe investigating into why our tooling doesn't involve
basic semantic proofs like halting analysis

please excuse my pseudo-pyscript,

~ nick
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/25 1:30 PM, olcott wrote:

On 12/24/2025 11:57 AM, Richard Damon wrote:

On 12/24/25 12:02 PM, olcott wrote:

On 12/24/2025 10:45 AM, dart200 wrote:

On 12/23/25 11:44 AM, Richard Damon wrote:

On 12/23/25 2:04 PM, dart200 wrote:

On 12/22/25 7:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" >>>>>>>>>> encoded
into their descriptions leading to the *same* set of machine >>>>>>>>>> configurations/steps during computation on the same input >>>>>>>>>> (therefore
producing the same output as well). two machines that have >>>>>>>>>> isomorphic
equivalence will have the same space/runtime complexity when run. >>>>>>>>>> isomorphic machines represent the "same" computation, and most >>>>>>>>>> would
consider them the "same" machine, but when it comes to the >>>>>>>>>> theory of
computing, isomorphism is not sufficient for two machines to be >>>>>>>>>> *identical*, as the designated number that represents each >>>>>>>>>> machines are
unique.

 From where do you take your definition of "isomorphic" ? Is it a >>>>>>>>> definition from graph theory, perhaps meaning there the same that >>>>>>>>> beta-equivalence does in computation, eg changing locations but >>>>>>>>> updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing
research into turing machine equivalence.

i decided to use it because transforming the machines into
transition graphs and canonicalizing them solves the problem of >>>>>>>> two machines having the same structure but different labels in a >>>>>>>> computable fashion, meaning we can also compute all isomorphic >>>>>>>> machines for an

  But your "isomorphic" class isn't big enough, as the challenge >>>>>>> program

i get that not all functional equivalence is strictly isomorphic, >>>>>> hence the fact they are difference classes... tell me something i >>>>>> don't already know bro

It just means that being able to detect your "isomorphic"
equivalent doesn't get you what you need. You need full functional
equivalence for you logic to make sense.

can use a non-isomorphic equivalent to make you wrong.

but dude... so now ur saying that the decider can't even
computationally identify a certain to exist "challenge" program
that is pathological to said decider's existence? 🫩🫩🫩

Right, "Pathological" isn't a computable property.

but we're just supposed to accept it exists without question? like >>>>>> a mathematical ghost i can have no specific observable evidence for? >>>>>

No, it is provable. You just need to accept that logic works.

i don't think you can prove a semantic property (like said
pathological machine is undecidable in regards to the decider in
question) about a computing machine that isn't also computable, but
we'll prolly just have to agree to disagree on that for now.

i don't think godel's result counters this. godel only proves that
*some* statements to be unprovable within the system of logic, and
it only proved it for a *specific form* of statement. to
overgeneralize this property to possible statements of *all* other
forms is i think a total fallacy that we've been continually
upholding since godel produced the result.

Gödel's incompleteness completely falls apart when
a formal language direct encodes it own semantics
syntactically.

But it can't.

That you do not understand how this is done
is not at all the same thing as it can't be done.

So TRY,

That is like trying to say that NUMBERS have specific meaning.

LLMs can completely understand this because they
understand Semantics from logic and Formal Semantics
from linguistics very well.

No, they don't, and you show your stupidity in thinking that,

Your continual use of ad hominem instead of reasoning
conclusively proves your own ignorance.

No, it is NOT an ad hominem. and you calling it that shows your stupidity.

Since your statements are just factualy wrong, with the evidence given,
their error doesn't rest on your stupidity, but WAS caused by it.

LLM "understand" NOTHING, as it isn't a concept in there programming.

It is a  verified fact the they do have the computational
equivalent of human understanding to a very great degree.

Nope. But of course your statement is just semantic goop, so not

Your own alma mater acknowledges this https://www.technologyreview.com/2024/03/04/1089403/large-language- models-amazing-but-nobody-knows-why/

Which never talks about the machines UNDERSTANDING a thing they do.

WE may not understand how they get there, but it isn't that they
"understand" the material in the way that people do.

I am not sure if there are any humans left alive
that understand Formal Semantics from linguistics
at all. Books are still out there, yet no one cares.

Clearly you don't.

Within the entire body of knowledge
"true on the basis of meaning expressed in language"
can be reliably computable. This does require an
axiomatic basis.

Which just isn't correct.

Unlike my work on the Halting problem that affirms
the Church-Turing thesis and only rejects the notion
of undecidability Math does need a new foundation.

WHich shows your failure, as you reject a proven fact.

It is a proven fact within a definition that disagrees
with the definition of computation.

No it isn't, can you show the contradiction using definitions IN the system?

That it contradicts definitions our side the system doesn't mean
anything but that those definitions can be used in the system, and those outside definitions may well be wrong, as the system has proved to be a
good model.

Finite string transformation rules applied to finite string
*INPUTS* to derive values or non-termination.

So? What is the contradiction?


It seems you still don't understand the basics of what you are trying to claim.

If you want to build a new foundation, go ahead and try.

First you are going to need to learn how to build one, which so far
seems outside your abilities, as you need to learn how definitions and
logic actually work, and how to phrase definitions well.

Since you have spend 20 years trying to get your first one right, and
haven't got there, you only have maybe a millennium to go.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/25 9:59 AM, Richard Damon wrote:

On 12/24/25 11:40 AM, dart200 wrote:

On 12/24/25 4:36 AM, Richard Damon wrote:

On 12/23/25 11:31 PM, dart200 wrote:

On 12/23/25 8:07 PM, Richard Damon wrote:

On 12/23/25 10:53 PM, dart200 wrote:

On 12/23/25 5:53 PM, Richard Damon wrote:

On 12/23/25 7:37 PM, dart200 wrote:

On 12/23/25 1:23 PM, Tristan Wibberley wrote:

On 23/12/2025 19:06, dart200 wrote:

from my quick search it appears β-equivalence is functional >>>>>>>>>> equivalence
not isomorphism

A quick search isn't enough. You need a lot more reading on >>>>>>>>> both terms.

origin fallacy, ur attacking the source of the argument (a quick >>>>>>>> search) and not the argument itself

Nope, he is pointing out that you got the wrong answer, and that >>>>>>> the source of the wrong answer was not doing enough work.

You don't seem to understand the origin fallacy. The answer
wasn't wrong just because you only did a quick search, you were >>>>>>> wrong because you gave the wrong answer, the cause of which was >>>>>>> just doing a quick search.

If the quick search had gotten the right answer, it would have
been right.

bruh fallacy isn't on whether he's right or wrong, it's in regards >>>>>> to whether i can know he's right or wrong, and as of now all he
did was hold over my head "a quick search" and that just tells me >>>>>> fuck all tbh... other he maybe disagrees??? i honestly don't even >>>>>> know if he disagreed or just questioned my methods randomly for
some reason i can't fathom. you doubling down on this dick, did
not add any additional explanatory power

No, he told you that you were wrong. And you, by admitting you
didn't do a full analysis, have no way to argue with him.

he didn't tell me why right then and there,

No, he just told you that you were wrong.

not in a way that was meaningful, u stupid fucking tard

But that does't make it wrong, only unhelpful to you.

if ur not gunna even try to be helpful, then don't post retard
--
hi, i'm nick! let's end war 🙃

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/25 1:51 PM, dart200 wrote:

On 12/24/25 9:54 AM, Richard Damon wrote:

On 12/24/25 11:45 AM, dart200 wrote:

On 12/23/25 11:44 AM, Richard Damon wrote:

On 12/23/25 2:04 PM, dart200 wrote:

On 12/22/25 7:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" >>>>>>>>> encoded
into their descriptions leading to the *same* set of machine >>>>>>>>> configurations/steps during computation on the same input
(therefore
producing the same output as well). two machines that have
isomorphic
equivalence will have the same space/runtime complexity when run. >>>>>>>>> isomorphic machines represent the "same" computation, and most >>>>>>>>> would
consider them the "same" machine, but when it comes to the
theory of
computing, isomorphism is not sufficient for two machines to be >>>>>>>>> *identical*, as the designated number that represents each
machines are
unique.

 From where do you take your definition of "isomorphic" ? Is it a >>>>>>>> definition from graph theory, perhaps meaning there the same that >>>>>>>> beta-equivalence does in computation, eg changing locations but >>>>>>>> updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing research >>>>>>> into turing machine equivalence.

i decided to use it because transforming the machines into
transition graphs and canonicalizing them solves the problem of >>>>>>> two machines having the same structure but different labels in a >>>>>>> computable fashion, meaning we can also compute all isomorphic
machines for an

  But your "isomorphic" class isn't big enough, as the challenge >>>>>> program

i get that not all functional equivalence is strictly isomorphic,
hence the fact they are difference classes... tell me something i
don't already know bro

It just means that being able to detect your "isomorphic" equivalent
doesn't get you what you need. You need full functional equivalence
for you logic to make sense.

can use a non-isomorphic equivalent to make you wrong.

but dude... so now ur saying that the decider can't even
computationally identify a certain to exist "challenge" program
that is pathological to said decider's existence? 🫩🫩🫩

Right, "Pathological" isn't a computable property.

but we're just supposed to accept it exists without question? like
a mathematical ghost i can have no specific observable evidence for?

No, it is provable. You just need to accept that logic works.

i don't think you can prove a semantic property (like said
pathological machine is undecidable in regards to the decider in
question) about a computing machine that isn't also computable, but
we'll prolly just have to agree to disagree on that for now.

Your problem is you confuse that a given input shows the given decider
to being wrong with it being uncomputable.

"Inputs" don't have a property called computable, PROBLEMS do.

all calling a problem undecidable means is that there are some inputs
which cannot be decided upon. that undecidability does not apply to all input, only some (or else we couldn't *ever* get an answer)... therefore
it only applies to some subset of machines.

No, it means that there is no one decider that can give the right answer
for all instances of the problem.

A derived conclusion from that is that there will be some instance which
we can never know the answer to, but we also might not be able to know
if an instance is in that class, or just not know yet.

idk why i need to explain that, seems entirely obvious.

But subtly wrong, which leads you to your errors.

And part of the issue is you don't understand the requirement that the
specific input is made from a specific instance of your decider, and
only shows that one to be wrong.

The fact that we can do this for ANY allows the proof that none can be
right for all.

i don't think godel's result counters this. godel only proves that
*some* statements to be unprovable within the system of logic, and it
only proved it for a *specific form* of statement. to overgeneralize
this property to possible statements of *all* other forms is i think
a total fallacy that we've been continually upholding since godel
produced the result.

Yes, only SOME true statements are unprovable, and thus the system is,
by the definition, incomplete.

I don't know why you are trying to limit it to "some form".

There is no claim that ALL statements are unprovable, only that some
exist.

u claim that because turing equivalence is not decidable, that for every machine which exists, there exists a functionally equivalent form of it
that cannot be semantically decided upon...

No.

You can not decide if it *IS* functionally equivalent to the original.

but this is just so entirely bizarre, cause this means that such a
machine much exist for all halting machines as well ... meaning there
must be some functionally equivalent machine that cannot be proven functionally equivalent, and must be semantically undecidable, DESPITE
THE FACT IT IS A HALTING MACHINE AND CAN BE ENUMERATED

What is so wrong about that.

Yes, the machine will appear somewhere in all total enumerations of
machines.

It will appear as a machine that all of the finite machines we are able
to test it against, haven't decided on it yet.

if said machine exists i should be able to enumerate all halting
machines and eventually hit this "undecidable" one. and my god help us
if u try to back the fuck up by claiming i can't actually enumerate all halting machines ...

It won't be in the enumeration of Halting Machines, as the undecidable
machine must be non-halting, as all halting machines are decidable (but
not nececarily decided yet)

WHAT IS THAT "UNDECIDABLE" HALTING MACHINE BRO???

It isn't a HALTING machine. WHy do you think it is?

It seems you aren't paying very good attention.

Just like uncomputable applies to SOME problems. And the result of
this is only that SOME element of that problem space will be unknowable.

furthermore, to get back to computing: let's say haltsB cannot decide
it's involved with paradoxA that is pathological to haltsA, who is
functionally equivalent to haltsB. well, it still can identify a
paradoxB that is functionally equivalent to paradoxA ... but i
supposed u're gunna claim we can't know that paradoxB is equivalent
to paradoxA... despite just assuming that as true for the premise of
the problem

Yes, the deciders might be able to identify a FINITE subset of the
computationally equivalent set of programs that are built as paradoxes
to the given decider. But since that set is infinite in size, as there
are an infinite number of computationally equivalent embodiements of
that program, they can not detect them all.

*IF* you claim that haltA and haltB are actually computationally
equivalent, then paradoxA and paradoxB must be too (by the rules of
composition), and thus will have the same correct answer about their
halting. By the definition of computaitonal equivalence, it means that
haltA(paradoxA) must match haltB(paradoxA), so both must be wrong,
since that were how paradoxA was built. And the same happens for
paradoxB.

This doesn't say that haltC, that isn't actually computationally
equivalent to haltA or haltB when given paradoxA or paradoxB can't
give the right answer, but there will be a different paradoxC that it
will get wrong. That paradoxC will NOT be computationally equivalent
to paradocA or paradoxB, and haltA and haltB might be able to give the
correct answer for paradoxC.

The problem is that given an input paradoxD, that might be eqivalent
of paradoxA and paradoxB, or might be equivalent to paradoxC, you
don't know which machine you should trust. All of haltA, haltB, and
haltC gave answers, and they may differ.

It is shown that we can not come up with a universal test for
computtional equivalence, so we can't make something choose which
decider to trust.

idk bout that, i still don't really believe in ghosts ... and
certainly not math ghosts ... extremely sus

Doesn't matter if you believe in them or not. They exist (in this
sense) and will make your results wrong.

Not believing doesn't affect truth.

u believing some bandwagon also doesn't affect truth ¯\_(ツ)_/¯

Right, but the actual Truth via proofs in the system establishes it.

The problem is you seem to just disbelieve in proofs, because you just
don't accept that you ARE in a system.

i just don't believe the rather specific kind of proof ur endlessly
relying on, please don't overgeneralize like the utter dick u are rick

And what is wrong with tht proof?

You seem to think you are allowed to just disagree with facts and make
them go away.

Yes, you can leave it, but then you need to acknoledge that, and then
take on the need to prove that you alternate system has use or it will
just be ignored.

we've honestly left the realm ur able to discuss coherently

Yes, because we seemed to have left the realm that you can think in.

Your refusal to accept proofs doesn't make them not proofs, it just
means you doom yourself to ignoring the consequence of them.

Your problem is you don't get to limit the domain of programs you >>>>>> need to answer and be a full decider.

look bro, so ur saying you can identify all machines equivalent to
the "challenge" program, right? or ... no?

No, I am saying you CAN'T.

so ur saying that given a decider, as we run the full enumeration
thru the decider there's going to be a machine that is *functionally
equivalent* to the pathological input, that will cause behavior in
response to pathological input, but while we can know that for some
pathological input ... we can't know that for all functionally
equivalent pathological input???

determining that the input uses a functional equivalent to ourselves
is an uncomputable problem. There will be instance that we can not
detect.

We may be able to detect a number of them, but not all.

Thus, any logic that requires you to have detected them, is just unsound.

Not sure what you are doing a "full enumeration" on.

ALL MACHINES, not that u know what that is even

Ok, any machine that tries to enumerate an infinite set will to see if soemthing is there will end up not halting, as to enumerate an infinite
set takes infinite time.

...err, whatever...

imma make some claims that i haven't proven yet, but i just now
formed an intention to:

let's say for a second i accept ur claims that there's some point
of unknowable semantic behavior:

It doesn't need a "point", it just exists.

for any given total enumeration, there must be a "first" point of
"undecidability" where some (or all) classic classifiers fail to
return.

Yes, but you will first hit an "unknown" machine.

Remember, you can't actually run "ALL" the classifier and know the
results.

if ur a retard like rick u'd pick an enumeration that starts on an
undecidable program as the 0th in the enumeration, and shoot urself >>>>> in the foot right off the bat because MuH tHeORy ... and that's not >>>>> really my problem, don't be that guy tbh, eh???

But you can't tell if you did.

The problem is you can't reach the end of running ALL the
classifier, as there is an infinite number of them.

the infinite of haltsN is the same size as the infinite of paradoxN,
they are both countably infinite, as is the whole enumeration. this
is significant.

But countably infinite sets have strange properties that you need to
handle.

Two countably infinite sets can have many relationships with each other.

They might be the same

They might be disjoint

One might be a proper subset of the other

They may have a finite or countably infinite intersection

THey may have a finite or countably infinite difference.

Just having two sets both of cardinality of countably infinite says
little about their relationship with each other.

it says that for every haltsN there cannot be more than one paradoxN

If built by the same base formula, they will all be computationally equivalent. There will be a countably infinite number of
"represaentations" of it.

After all, you can have a countably infinite number of countably
infinite sized subsets of a countably infinite set.

there are more sensible ways of totally enumerating out computing
machines, that start with n amount of machines which fall into the
category of "decidable" machines, on which all classic classifiers
return, such that and we can certainly categorize these machines
into semantic classes in regards to their behavior.

Yes, we can classify many machines. One problem is how do you
enumerate ALL the classifiers.

how maximally high can n be for any given enumeration? that's an
unstudied question as of now, prolly much higher than 420 i should
think...

Since there is a countably infinte number of halting machines, you
can just begin with them and get as high of a number as you want.

It seems your problem is you don't understand the mathematics of the
infinite.

but regardless, given that for n machines a decision can certainly
be made, there must be some machine that happens exactly at n+1
machines in that is the first such ghost machine G that rick is so
certain about it's existence.

Nope, Not how infinite sets work. As I pointed out, your n is
infinite, but is still followed by infinite machines.

no no no no no, richard. if u do not ever iterate over this supposed
G- machine with undecidable semantics... then ur not actually
enumerating out all the machines

And that is the problem with trying to enumerate. You CAN get an
infinte enumeration that isn't complete, and thus your n can get
unboundedly large.

n *must* be finite for any given enumeration of TMs to be total

No. n defined as the largest value you can get to, does not need to be
finite.

for it be a TOTAL enumeration, u need to enumerate over *ALL* machines, including the G you endless claim that must exist.

Yes, but that G can have a unboundedly high number.

if the enumeration NEVER hits G then it's not a TOTAL enumeration u moron.

But that doesn't mean you can put a finite limit on its value.

bro, this is just sad. is this the wall we hit? u can't figure out what
a fucking total enumeration implies???

It seems you don't understand that because there are MANY total orders available, no one entry needs to have a bounded value.

cause it means n cannot be infinite for *any* given enumeration, because
G must be some part of the enumeration we can count to and assign it an index

But its value is unbounded.

fuck dude. undecidability proofs *RELY* on the fact machines are fully enumerable in an effective fashion and therefore we can making decider accountable to answering to them ...

Fully enumerated does not mean what you think it means.

You can't argue that you reach a given class of the input in a bounded time.

if not, if we can just "enumerate" all machines while skipping over that first undecidable G ... then u also lose ur proof to undecidability
because we just "enumerate" over all machines and were able to decide on each one since G was never encountered ...

Yes, if you are not careful in your enumeration, you might skip over
some and not be total.

But, we know we CAN make an enumeration that goes over all,

no dude, that's stupid. the total enumeration of ALL machines must
included G at some finite index n

Yes, at some finite n, but that n has an unbounded limit.

Its sort of like asking what is the highest expressible number, and then
why isn't the next one expressible.

All that says is that there are a countably infinite number of
decidable machines, which we can easily generate.

This is the problem of trying to think of infinite sets and trying to
use finite set properties.

the problem is u think infinite implies we can just ignore logic
entirely while making wild claim after wild claim

No, but you have to use logic that works on them, and not logic that
assumes you have a bounded set.

There ARE rules that they follow, and logic you can do with them.

It seems you have crossed past your level of understanding.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/25 11:19 AM, Richard Damon wrote:

On 12/24/25 1:51 PM, dart200 wrote:

On 12/24/25 9:54 AM, Richard Damon wrote:

On 12/24/25 11:45 AM, dart200 wrote:

On 12/23/25 11:44 AM, Richard Damon wrote:

On 12/23/25 2:04 PM, dart200 wrote:

On 12/22/25 7:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" >>>>>>>>>> encoded
into their descriptions leading to the *same* set of machine >>>>>>>>>> configurations/steps during computation on the same input >>>>>>>>>> (therefore
producing the same output as well). two machines that have >>>>>>>>>> isomorphic
equivalence will have the same space/runtime complexity when run. >>>>>>>>>> isomorphic machines represent the "same" computation, and most >>>>>>>>>> would
consider them the "same" machine, but when it comes to the >>>>>>>>>> theory of
computing, isomorphism is not sufficient for two machines to be >>>>>>>>>> *identical*, as the designated number that represents each >>>>>>>>>> machines are
unique.

 From where do you take your definition of "isomorphic" ? Is it a >>>>>>>>> definition from graph theory, perhaps meaning there the same that >>>>>>>>> beta-equivalence does in computation, eg changing locations but >>>>>>>>> updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing
research into turing machine equivalence.

i decided to use it because transforming the machines into
transition graphs and canonicalizing them solves the problem of >>>>>>>> two machines having the same structure but different labels in a >>>>>>>> computable fashion, meaning we can also compute all isomorphic >>>>>>>> machines for an

  But your "isomorphic" class isn't big enough, as the challenge >>>>>>> program

i get that not all functional equivalence is strictly isomorphic, >>>>>> hence the fact they are difference classes... tell me something i >>>>>> don't already know bro

It just means that being able to detect your "isomorphic"
equivalent doesn't get you what you need. You need full functional
equivalence for you logic to make sense.

can use a non-isomorphic equivalent to make you wrong.

but dude... so now ur saying that the decider can't even
computationally identify a certain to exist "challenge" program
that is pathological to said decider's existence? 🫩🫩🫩

Right, "Pathological" isn't a computable property.

but we're just supposed to accept it exists without question? like >>>>>> a mathematical ghost i can have no specific observable evidence for? >>>>>

No, it is provable. You just need to accept that logic works.

i don't think you can prove a semantic property (like said
pathological machine is undecidable in regards to the decider in
question) about a computing machine that isn't also computable, but
we'll prolly just have to agree to disagree on that for now.

Your problem is you confuse that a given input shows the given
decider to being wrong with it being uncomputable.

"Inputs" don't have a property called computable, PROBLEMS do.

all calling a problem undecidable means is that there are some inputs
which cannot be decided upon. that undecidability does not apply to
all input, only some (or else we couldn't *ever* get an answer)...
therefore it only applies to some subset of machines.

No, it means that there is no one decider that can give the right answer
for all instances of the problem.

A derived conclusion from that is that there will be some instance which
we can never know the answer to, but we also might not be able to know
if an instance is in that class, or just not know yet.

idk why i need to explain that, seems entirely obvious.

But subtly wrong, which leads you to your errors.

And part of the issue is you don't understand the requirement that
the specific input is made from a specific instance of your decider,
and only shows that one to be wrong.

The fact that we can do this for ANY allows the proof that none can
be right for all.

i don't think godel's result counters this. godel only proves that
*some* statements to be unprovable within the system of logic, and
it only proved it for a *specific form* of statement. to
overgeneralize this property to possible statements of *all* other
forms is i think a total fallacy that we've been continually
upholding since godel produced the result.

Yes, only SOME true statements are unprovable, and thus the system
is, by the definition, incomplete.

I don't know why you are trying to limit it to "some form".

There is no claim that ALL statements are unprovable, only that some
exist.

u claim that because turing equivalence is not decidable, that for
every machine which exists, there exists a functionally equivalent
form of it that cannot be semantically decided upon...

No.

You can not decide if it *IS* functionally equivalent to the original.

but this is just so entirely bizarre, cause this means that such a
machine much exist for all halting machines as well ... meaning there
must be some functionally equivalent machine that cannot be proven
functionally equivalent, and must be semantically undecidable, DESPITE
THE FACT IT IS A HALTING MACHINE AND CAN BE ENUMERATED

What is so wrong about that.

Yes, the machine will appear somewhere in all total enumerations of machines.

It will appear as a machine that all of the finite machines we are able
to test it against, haven't decided on it yet.

if said machine exists i should be able to enumerate all halting
machines and eventually hit this "undecidable" one. and my god help us
if u try to back the fuck up by claiming i can't actually enumerate
all halting machines ...

It won't be in the enumeration of Halting Machines, as the undecidable machine must be non-halting, as all halting machines are decidable (but
not nececarily decided yet)

WHAT IS THAT "UNDECIDABLE" HALTING MACHINE BRO???

It isn't a HALTING machine. WHy do you think it is?

holy fuck dude. if ur going to claim that for *any given* machine there
*must* be a functional machine we cannot know is functionally
equivalent, then that *must* be true for *any given halting* machine as well...

which must mean there is a halting machine we cannot decide on the
semantics of, because if we could then we could determine said
undecidable machine's functional equivalence...

It seems you aren't paying very good attention.

i'm repeating myself because ur too busy typing rather than reading

Just like uncomputable applies to SOME problems. And the result of
this is only that SOME element of that problem space will be unknowable. >>>

furthermore, to get back to computing: let's say haltsB cannot
decide it's involved with paradoxA that is pathological to haltsA,
who is functionally equivalent to haltsB. well, it still can
identify a paradoxB that is functionally equivalent to paradoxA ...
but i supposed u're gunna claim we can't know that paradoxB is
equivalent to paradoxA... despite just assuming that as true for the
premise of the problem

Yes, the deciders might be able to identify a FINITE subset of the
computationally equivalent set of programs that are built as
paradoxes to the given decider. But since that set is infinite in
size, as there are an infinite number of computationally equivalent
embodiements of that program, they can not detect them all.

*IF* you claim that haltA and haltB are actually computationally
equivalent, then paradoxA and paradoxB must be too (by the rules of
composition), and thus will have the same correct answer about their
halting. By the definition of computaitonal equivalence, it means
that haltA(paradoxA) must match haltB(paradoxA), so both must be
wrong, since that were how paradoxA was built. And the same happens
for paradoxB.

This doesn't say that haltC, that isn't actually computationally
equivalent to haltA or haltB when given paradoxA or paradoxB can't
give the right answer, but there will be a different paradoxC that it
will get wrong. That paradoxC will NOT be computationally equivalent
to paradocA or paradoxB, and haltA and haltB might be able to give
the correct answer for paradoxC.

The problem is that given an input paradoxD, that might be eqivalent
of paradoxA and paradoxB, or might be equivalent to paradoxC, you
don't know which machine you should trust. All of haltA, haltB, and
haltC gave answers, and they may differ.

It is shown that we can not come up with a universal test for
computtional equivalence, so we can't make something choose which
decider to trust.

idk bout that, i still don't really believe in ghosts ... and
certainly not math ghosts ... extremely sus

Doesn't matter if you believe in them or not. They exist (in this
sense) and will make your results wrong.

Not believing doesn't affect truth.

u believing some bandwagon also doesn't affect truth ¯\_(ツ)_/¯

Right, but the actual Truth via proofs in the system establishes it.

The problem is you seem to just disbelieve in proofs, because you
just don't accept that you ARE in a system.

i just don't believe the rather specific kind of proof ur endlessly
relying on, please don't overgeneralize like the utter dick u are rick

And what is wrong with tht proof?

You seem to think you are allowed to just disagree with facts and make
them go away.

you owe me an apology someday, this entire field does

Yes, you can leave it, but then you need to acknoledge that, and then
take on the need to prove that you alternate system has use or it
will just be ignored.

we've honestly left the realm ur able to discuss coherently

Yes, because we seemed to have left the realm that you can think in.

Your refusal to accept proofs doesn't make them not proofs, it just
means you doom yourself to ignoring the consequence of them.

Your problem is you don't get to limit the domain of programs you >>>>>>> need to answer and be a full decider.

look bro, so ur saying you can identify all machines equivalent to >>>>>> the "challenge" program, right? or ... no?

No, I am saying you CAN'T.

so ur saying that given a decider, as we run the full enumeration
thru the decider there's going to be a machine that is *functionally
equivalent* to the pathological input, that will cause behavior in
response to pathological input, but while we can know that for some
pathological input ... we can't know that for all functionally
equivalent pathological input???

determining that the input uses a functional equivalent to ourselves
is an uncomputable problem. There will be instance that we can not
detect.

We may be able to detect a number of them, but not all.

Thus, any logic that requires you to have detected them, is just
unsound.

Not sure what you are doing a "full enumeration" on.

ALL MACHINES, not that u know what that is even

Ok, any machine that tries to enumerate an infinite set will to see if soemthing is there will end up not halting, as to enumerate an infinite
set takes infinite time.

if we *know* it's there, and we have a test for it, then the time is
just unbounded, not infinite

...err, whatever...

imma make some claims that i haven't proven yet, but i just now
formed an intention to:

let's say for a second i accept ur claims that there's some point >>>>>> of unknowable semantic behavior:

It doesn't need a "point", it just exists.

for any given total enumeration, there must be a "first" point of >>>>>> "undecidability" where some (or all) classic classifiers fail to
return.

Yes, but you will first hit an "unknown" machine.

Remember, you can't actually run "ALL" the classifier and know the
results.

if ur a retard like rick u'd pick an enumeration that starts on an >>>>>> undecidable program as the 0th in the enumeration, and shoot
urself in the foot right off the bat because MuH tHeORy ... and
that's not really my problem, don't be that guy tbh, eh???

But you can't tell if you did.

The problem is you can't reach the end of running ALL the
classifier, as there is an infinite number of them.

the infinite of haltsN is the same size as the infinite of paradoxN,
they are both countably infinite, as is the whole enumeration. this
is significant.

But countably infinite sets have strange properties that you need to
handle.

Two countably infinite sets can have many relationships with each other. >>>
They might be the same

They might be disjoint

One might be a proper subset of the other

They may have a finite or countably infinite intersection

THey may have a finite or countably infinite difference.

Just having two sets both of cardinality of countably infinite says
little about their relationship with each other.

it says that for every haltsN there cannot be more than one paradoxN

If built by the same base formula, they will all be computationally equivalent. There will be a countably infinite number of
"represaentations" of it.

After all, you can have a countably infinite number of countably
infinite sized subsets of a countably infinite set.

so? most of those infinitely sized subsets are arbitrary and
uninteresting just like the reals

this doesn't say anything in regards to the subsets we can enumerate

there are more sensible ways of totally enumerating out computing >>>>>> machines, that start with n amount of machines which fall into the >>>>>> category of "decidable" machines, on which all classic classifiers >>>>>> return, such that and we can certainly categorize these machines
into semantic classes in regards to their behavior.

Yes, we can classify many machines. One problem is how do you
enumerate ALL the classifiers.

how maximally high can n be for any given enumeration? that's an
unstudied question as of now, prolly much higher than 420 i should >>>>>> think...

Since there is a countably infinte number of halting machines, you
can just begin with them and get as high of a number as you want.

It seems your problem is you don't understand the mathematics of
the infinite.

but regardless, given that for n machines a decision can certainly >>>>>> be made, there must be some machine that happens exactly at n+1
machines in that is the first such ghost machine G that rick is so >>>>>> certain about it's existence.

Nope, Not how infinite sets work. As I pointed out, your n is
infinite, but is still followed by infinite machines.

no no no no no, richard. if u do not ever iterate over this supposed
G- machine with undecidable semantics... then ur not actually
enumerating out all the machines

And that is the problem with trying to enumerate. You CAN get an
infinte enumeration that isn't complete, and thus your n can get
unboundedly large.

n *must* be finite for any given enumeration of TMs to be total

No. n defined as the largest value you can get to, does not need to
be finite.

for it be a TOTAL enumeration, u need to enumerate over *ALL*
machines, including the G you endless claim that must exist.

Yes, but that G can have a unboundedly high number.

if the enumeration NEVER hits G then it's not a TOTAL enumeration u
moron.

But that doesn't mean you can put a finite limit on its value.

FOR ANY GIVEN ENUMERATION, IT MUST BE FINITE

there's no limit across *all* enumerations, but for every enumeration
there must be a point.

bro, this is just sad. is this the wall we hit? u can't figure out
what a fucking total enumeration implies???

It seems you don't understand that because there are MANY total orders available, no one entry needs to have a bounded value.

cause it means n cannot be infinite for *any* given enumeration,
because G must be some part of the enumeration we can count to and
assign it an index

But its value is unbounded.

fuck dude. undecidability proofs *RELY* on the fact machines are fully
enumerable in an effective fashion and therefore we can making decider
accountable to answering to them ...

Fully enumerated does not mean what you think it means.

You can't argue that you reach a given class of the input in a bounded
time.

if i pick an enumeration, i will reach it a time bounded by that
specific enumeration ... ALWAYS, FOR ANY GIVEN ENUMERATION

if not, if we can just "enumerate" all machines while skipping over
that first undecidable G ... then u also lose ur proof to
undecidability because we just "enumerate" over all machines and were
able to decide on each one since G was never encountered ...

Yes, if you are not careful in your enumeration, you might skip over
some and not be total.

But, we know we CAN make an enumeration that goes over all,

no dude, that's stupid. the total enumeration of ALL machines must
included G at some finite index n

Yes, at some finite n, but that n has an unbounded limit.

Its sort of like asking what is the highest expressible number, and then
why isn't the next one expressible.

All that says is that there are a countably infinite number of
decidable machines, which we can easily generate.

This is the problem of trying to think of infinite sets and trying to
use finite set properties.

the problem is u think infinite implies we can just ignore logic
entirely while making wild claim after wild claim

No, but you have to use logic that works on them, and not logic that
assumes you have a bounded set.

There ARE rules that they follow, and logic you can do with them.

It seems you have crossed past your level of understanding.

--
a burnt out swe investigating into why our tooling doesn't involve
basic semantic proofs like halting analysis

please excuse my pseudo-pyscript,

~ nick
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/25 2:51 PM, dart200 wrote:

On 12/24/25 11:19 AM, Richard Damon wrote:

On 12/24/25 1:51 PM, dart200 wrote:

On 12/24/25 9:54 AM, Richard Damon wrote:

On 12/24/25 11:45 AM, dart200 wrote:

On 12/23/25 11:44 AM, Richard Damon wrote:

On 12/23/25 2:04 PM, dart200 wrote:

On 12/22/25 7:35 PM, Richard Damon wrote:

On 12/22/25 10:21 PM, dart200 wrote:

On 12/22/25 6:28 PM, Tristan Wibberley wrote:

On 22/12/2025 01:15, dart200 wrote:

# isomorphic equivalence #

two machines of isomorphic equivalence have the same "shape" >>>>>>>>>>> encoded
into their descriptions leading to the *same* set of machine >>>>>>>>>>> configurations/steps during computation on the same input >>>>>>>>>>> (therefore
producing the same output as well). two machines that have >>>>>>>>>>> isomorphic
equivalence will have the same space/runtime complexity when >>>>>>>>>>> run.
isomorphic machines represent the "same" computation, and >>>>>>>>>>> most would
consider them the "same" machine, but when it comes to the >>>>>>>>>>> theory of
computing, isomorphism is not sufficient for two machines to be >>>>>>>>>>> *identical*, as the designated number that represents each >>>>>>>>>>> machines are
unique.

 From where do you take your definition of "isomorphic" ? Is it a >>>>>>>>>> definition from graph theory, perhaps meaning there the same that >>>>>>>>>> beta-equivalence does in computation, eg changing locations >>>>>>>>>> but updating
pointers accordingly?

grok pulled it from various threads tbh when i was doing
research into turing machine equivalence.

i decided to use it because transforming the machines into
transition graphs and canonicalizing them solves the problem of >>>>>>>>> two machines having the same structure but different labels in >>>>>>>>> a computable fashion, meaning we can also compute all
isomorphic machines for an

  But your "isomorphic" class isn't big enough, as the challenge >>>>>>>> program

i get that not all functional equivalence is strictly isomorphic, >>>>>>> hence the fact they are difference classes... tell me something i >>>>>>> don't already know bro

It just means that being able to detect your "isomorphic"
equivalent doesn't get you what you need. You need full functional >>>>>> equivalence for you logic to make sense.

can use a non-isomorphic equivalent to make you wrong.

but dude... so now ur saying that the decider can't even
computationally identify a certain to exist "challenge" program >>>>>>> that is pathological to said decider's existence? 🫩🫩🫩

Right, "Pathological" isn't a computable property.

but we're just supposed to accept it exists without question?
like a mathematical ghost i can have no specific observable
evidence for?

No, it is provable. You just need to accept that logic works.

i don't think you can prove a semantic property (like said
pathological machine is undecidable in regards to the decider in
question) about a computing machine that isn't also computable, but >>>>> we'll prolly just have to agree to disagree on that for now.

Your problem is you confuse that a given input shows the given
decider to being wrong with it being uncomputable.

"Inputs" don't have a property called computable, PROBLEMS do.

all calling a problem undecidable means is that there are some inputs
which cannot be decided upon. that undecidability does not apply to
all input, only some (or else we couldn't *ever* get an answer)...
therefore it only applies to some subset of machines.

No, it means that there is no one decider that can give the right
answer for all instances of the problem.

A derived conclusion from that is that there will be some instance
which we can never know the answer to, but we also might not be able
to know if an instance is in that class, or just not know yet.

idk why i need to explain that, seems entirely obvious.

But subtly wrong, which leads you to your errors.

And part of the issue is you don't understand the requirement that
the specific input is made from a specific instance of your decider,
and only shows that one to be wrong.

The fact that we can do this for ANY allows the proof that none can
be right for all.

i don't think godel's result counters this. godel only proves that
*some* statements to be unprovable within the system of logic, and
it only proved it for a *specific form* of statement. to
overgeneralize this property to possible statements of *all* other
forms is i think a total fallacy that we've been continually
upholding since godel produced the result.

Yes, only SOME true statements are unprovable, and thus the system
is, by the definition, incomplete.

I don't know why you are trying to limit it to "some form".

There is no claim that ALL statements are unprovable, only that some
exist.

u claim that because turing equivalence is not decidable, that for
every machine which exists, there exists a functionally equivalent
form of it that cannot be semantically decided upon...

No.

You can not decide if it *IS* functionally equivalent to the original.

but this is just so entirely bizarre, cause this means that such a
machine much exist for all halting machines as well ... meaning there
must be some functionally equivalent machine that cannot be proven
functionally equivalent, and must be semantically undecidable,
DESPITE THE FACT IT IS A HALTING MACHINE AND CAN BE ENUMERATED

What is so wrong about that.

Yes, the machine will appear somewhere in all total enumerations of
machines.

It will appear as a machine that all of the finite machines we are
able to test it against, haven't decided on it yet.

if said machine exists i should be able to enumerate all halting
machines and eventually hit this "undecidable" one. and my god help
us if u try to back the fuck up by claiming i can't actually
enumerate all halting machines ...

It won't be in the enumeration of Halting Machines, as the undecidable
machine must be non-halting, as all halting machines are decidable
(but not nececarily decided yet)

WHAT IS THAT "UNDECIDABLE" HALTING MACHINE BRO???

It isn't a HALTING machine. WHy do you think it is?

holy fuck dude. if ur going to claim that for *any given* machine there *must* be a functional machine we cannot know is functionally
equivalent, then that *must* be true for *any given halting* machine as well...

Just because ONE is wrong, doesn't mean other will be?

DO you not understand that you machine has a fixed code, and thus does
what it does?

which must mean there is a halting machine we cannot decide on the
semantics of, because if we could then we could determine said
undecidable machine's functional equivalence...

It seems you aren't paying very good attention.

i'm repeating myself because ur too busy typing rather than reading

But the problem is you are confusing that the "pathologial" machine is
one that a partiuclar machibe gets wrong, verse a machine that no
machine can decide.

You keep on trying to talk about the pathological program of the proof
as being "undecidable", when it isn't, and thus your arguement are just
wrong.

Just like uncomputable applies to SOME problems. And the result of
this is only that SOME element of that problem space will be
unknowable.

furthermore, to get back to computing: let's say haltsB cannot
decide it's involved with paradoxA that is pathological to haltsA,
who is functionally equivalent to haltsB. well, it still can
identify a paradoxB that is functionally equivalent to paradoxA ... >>>>> but i supposed u're gunna claim we can't know that paradoxB is
equivalent to paradoxA... despite just assuming that as true for
the premise of the problem

Yes, the deciders might be able to identify a FINITE subset of the
computationally equivalent set of programs that are built as
paradoxes to the given decider. But since that set is infinite in
size, as there are an infinite number of computationally equivalent
embodiements of that program, they can not detect them all.

*IF* you claim that haltA and haltB are actually computationally
equivalent, then paradoxA and paradoxB must be too (by the rules of
composition), and thus will have the same correct answer about their
halting. By the definition of computaitonal equivalence, it means
that haltA(paradoxA) must match haltB(paradoxA), so both must be
wrong, since that were how paradoxA was built. And the same happens
for paradoxB.

This doesn't say that haltC, that isn't actually computationally
equivalent to haltA or haltB when given paradoxA or paradoxB can't
give the right answer, but there will be a different paradoxC that
it will get wrong. That paradoxC will NOT be computationally
equivalent to paradocA or paradoxB, and haltA and haltB might be
able to give the correct answer for paradoxC.

The problem is that given an input paradoxD, that might be eqivalent
of paradoxA and paradoxB, or might be equivalent to paradoxC, you
don't know which machine you should trust. All of haltA, haltB, and
haltC gave answers, and they may differ.

It is shown that we can not come up with a universal test for
computtional equivalence, so we can't make something choose which
decider to trust.

idk bout that, i still don't really believe in ghosts ... and
certainly not math ghosts ... extremely sus

Doesn't matter if you believe in them or not. They exist (in this >>>>>> sense) and will make your results wrong.

Not believing doesn't affect truth.

u believing some bandwagon also doesn't affect truth ¯\_(ツ)_/¯

Right, but the actual Truth via proofs in the system establishes it.

The problem is you seem to just disbelieve in proofs, because you
just don't accept that you ARE in a system.

i just don't believe the rather specific kind of proof ur endlessly
relying on, please don't overgeneralize like the utter dick u are rick

And what is wrong with tht proof?

You seem to think you are allowed to just disagree with facts and make
them go away.

you owe me an apology someday, this entire field does

You don't get an apology for being wrong.

Yes, you can leave it, but then you need to acknoledge that, and
then take on the need to prove that you alternate system has use or
it will just be ignored.

we've honestly left the realm ur able to discuss coherently

Yes, because we seemed to have left the realm that you can think in.

Your refusal to accept proofs doesn't make them not proofs, it just
means you doom yourself to ignoring the consequence of them.

Your problem is you don't get to limit the domain of programs >>>>>>>> you need to answer and be a full decider.

look bro, so ur saying you can identify all machines equivalent >>>>>>> to the "challenge" program, right? or ... no?

No, I am saying you CAN'T.

so ur saying that given a decider, as we run the full enumeration
thru the decider there's going to be a machine that is
*functionally equivalent* to the pathological input, that will
cause behavior in response to pathological input, but while we can
know that for some pathological input ... we can't know that for
all functionally equivalent pathological input???

determining that the input uses a functional equivalent to ourselves
is an uncomputable problem. There will be instance that we can not
detect.

We may be able to detect a number of them, but not all.

Thus, any logic that requires you to have detected them, is just
unsound.

Not sure what you are doing a "full enumeration" on.

ALL MACHINES, not that u know what that is even

Ok, any machine that tries to enumerate an infinite set will to see if
soemthing is there will end up not halting, as to enumerate an
infinite set takes infinite time.

if we *know* it's there, and we have a test for it, then the time is
just unbounded, not infinite

But we don't have a test for it, Thats the problem

...err, whatever...

imma make some claims that i haven't proven yet, but i just now >>>>>>> formed an intention to:

let's say for a second i accept ur claims that there's some point >>>>>>> of unknowable semantic behavior:

It doesn't need a "point", it just exists.

for any given total enumeration, there must be a "first" point of >>>>>>> "undecidability" where some (or all) classic classifiers fail to >>>>>>> return.

Yes, but you will first hit an "unknown" machine.

Remember, you can't actually run "ALL" the classifier and know the >>>>>> results.

if ur a retard like rick u'd pick an enumeration that starts on >>>>>>> an undecidable program as the 0th in the enumeration, and shoot >>>>>>> urself in the foot right off the bat because MuH tHeORy ... and >>>>>>> that's not really my problem, don't be that guy tbh, eh???

But you can't tell if you did.

The problem is you can't reach the end of running ALL the
classifier, as there is an infinite number of them.

the infinite of haltsN is the same size as the infinite of
paradoxN, they are both countably infinite, as is the whole
enumeration. this is significant.

But countably infinite sets have strange properties that you need to
handle.

Two countably infinite sets can have many relationships with each
other.

They might be the same

They might be disjoint

One might be a proper subset of the other

They may have a finite or countably infinite intersection

THey may have a finite or countably infinite difference.

Just having two sets both of cardinality of countably infinite says
little about their relationship with each other.

it says that for every haltsN there cannot be more than one paradoxN

If built by the same base formula, they will all be computationally
equivalent. There will be a countably infinite number of
"represaentations" of it.

After all, you can have a countably infinite number of countably
infinite sized subsets of a countably infinite set.

so? most of those infinitely sized subsets are arbitrary and
uninteresting just like the reals

So?

this doesn't say anything in regards to the subsets we can enumerate

But it does, You can't assume that you will reach the unknow machine at
any given time.

there are more sensible ways of totally enumerating out computing >>>>>>> machines, that start with n amount of machines which fall into
the category of "decidable" machines, on which all classic
classifiers return, such that and we can certainly categorize
these machines into semantic classes in regards to their behavior. >>>>>>

Yes, we can classify many machines. One problem is how do you
enumerate ALL the classifiers.

how maximally high can n be for any given enumeration? that's an >>>>>>> unstudied question as of now, prolly much higher than 420 i
should think...

Since there is a countably infinte number of halting machines, you >>>>>> can just begin with them and get as high of a number as you want.

It seems your problem is you don't understand the mathematics of
the infinite.

but regardless, given that for n machines a decision can
certainly be made, there must be some machine that happens
exactly at n+1 machines in that is the first such ghost machine G >>>>>>> that rick is so certain about it's existence.

Nope, Not how infinite sets work. As I pointed out, your n is
infinite, but is still followed by infinite machines.

no no no no no, richard. if u do not ever iterate over this
supposed G- machine with undecidable semantics... then ur not
actually enumerating out all the machines

And that is the problem with trying to enumerate. You CAN get an
infinte enumeration that isn't complete, and thus your n can get
unboundedly large.

n *must* be finite for any given enumeration of TMs to be total

No. n defined as the largest value you can get to, does not need to
be finite.

for it be a TOTAL enumeration, u need to enumerate over *ALL*
machines, including the G you endless claim that must exist.

Yes, but that G can have a unboundedly high number.

if the enumeration NEVER hits G then it's not a TOTAL enumeration u
moron.

But that doesn't mean you can put a finite limit on its value.

FOR ANY GIVEN ENUMERATION, IT MUST BE FINITE

Yes, but since you don't know what machines are in it, or can test for
it, you won't be able to find it.

And you don't know the "n" that are decidable, so it doesn't acheive
your goal.

there's no limit across *all* enumerations, but for every enumeration
there must be a point.

Yes, but you don't know where it is.

bro, this is just sad. is this the wall we hit? u can't figure out
what a fucking total enumeration implies???

It seems you don't understand that because there are MANY total orders
available, no one entry needs to have a bounded value.

cause it means n cannot be infinite for *any* given enumeration,
because G must be some part of the enumeration we can count to and
assign it an index

But its value is unbounded.

fuck dude. undecidability proofs *RELY* on the fact machines are
fully enumerable in an effective fashion and therefore we can making
decider accountable to answering to them ...

Fully enumerated does not mean what you think it means.

You can't argue that you reach a given class of the input in a bounded
time.

if i pick an enumeration, i will reach it a time bounded by that
specific enumeration ... ALWAYS, FOR ANY GIVEN ENUMERATION

Yes, So?

Since you don't know which one it is in that enumberation, you can't
actualy state the bound.

Your "proof" began with an asserting that the first n were decidable,
but no where do you make that happen, or that n+1 isn't.

So, your proof needs you to know that n, but gives no way to compute it.

if not, if we can just "enumerate" all machines while skipping over
that first undecidable G ... then u also lose ur proof to
undecidability because we just "enumerate" over all machines and were
able to decide on each one since G was never encountered ...

Yes, if you are not careful in your enumeration, you might skip over
some and not be total.

But, we know we CAN make an enumeration that goes over all,

no dude, that's stupid. the total enumeration of ALL machines must
included G at some finite index n

Yes, at some finite n, but that n has an unbounded limit.

Its sort of like asking what is the highest expressible number, and
then why isn't the next one expressible.

All that says is that there are a countably infinite number of
decidable machines, which we can easily generate.

This is the problem of trying to think of infinite sets and trying
to use finite set properties.

the problem is u think infinite implies we can just ignore logic
entirely while making wild claim after wild claim

No, but you have to use logic that works on them, and not logic that
assumes you have a bounded set.

There ARE rules that they follow, and logic you can do with them.

It seems you have crossed past your level of understanding.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am Wed, 24 Dec 2025 10:51:34 -0800 schrieb dart200:

On 12/24/25 9:54 AM, Richard Damon wrote:

"Inputs" don't have a property called computable, PROBLEMS do.

all calling a problem undecidable means is that there are some inputs
which cannot be decided upon. that undecidability does not apply to all input, only some (or else we couldn't *ever* get an answer)... therefore
it only applies to some subset of machines.

No, that's wrong. Every machine has a definite halting status and is
thus trivially decidable. It means no machine gets everything right.

WHAT IS THAT "UNDECIDABLE" HALTING MACHINE BRO???

It doesn't exist. There are only machines decided incorrectly.
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/25 6:03 PM, joes wrote:

Am Wed, 24 Dec 2025 10:51:34 -0800 schrieb dart200:

On 12/24/25 9:54 AM, Richard Damon wrote:

"Inputs" don't have a property called computable, PROBLEMS do.

all calling a problem undecidable means is that there are some inputs
which cannot be decided upon. that undecidability does not apply to all
input, only some (or else we couldn't *ever* get an answer)... therefore
it only applies to some subset of machines.

No, that's wrong. Every machine has a definite halting status and is
thus trivially decidable. It means no machine gets everything right.

WHAT IS THAT "UNDECIDABLE" HALTING MACHINE BRO???

It doesn't exist. There are only machines decided incorrectly.

No, it turns out that the logic says there are actually some machines
that are truely unknowable on their behavior. They are non-halting, but
we can not prove it. As far as we know, they might halt if we simulate
them farther, but in actuality, they never will.

The issue is that if we COULD know for every non-halting machine a proof
of its non-halting, then the algorithm used to make those proofs could
be used to make an infallible halt decider.

Since we know we can't do that, there must be some truely unknowable
behavior machines.

These programs are NOT the programs desscribed in the halting problem
proof, as those are easily decided on by other deciders, just not the
one they were built to foil.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/25 3:03 PM, joes wrote:

Am Wed, 24 Dec 2025 10:51:34 -0800 schrieb dart200:

On 12/24/25 9:54 AM, Richard Damon wrote:

"Inputs" don't have a property called computable, PROBLEMS do.

all calling a problem undecidable means is that there are some inputs
which cannot be decided upon. that undecidability does not apply to all
input, only some (or else we couldn't *ever* get an answer)... therefore
it only applies to some subset of machines.

No, that's wrong. Every machine has a definite halting status and is
thus trivially decidable. It means no machine gets everything right.

WHAT IS THAT "UNDECIDABLE" HALTING MACHINE BRO???

It doesn't exist. There are only machines decided incorrectly.

WHAT IS AN EXAMPLE OF A HALTING MACHINE THAT IS DECIDED INCORRECTLY????
--
a burnt out swe investigating into why our tooling doesn't involve
basic semantic proofs like halting analysis

please excuse my pseudo-pyscript,

~ nick
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/24/25 6:49 PM, dart200 wrote:

On 12/24/25 3:03 PM, joes wrote:

Am Wed, 24 Dec 2025 10:51:34 -0800 schrieb dart200:

On 12/24/25 9:54 AM, Richard Damon wrote:

"Inputs" don't have a property called computable, PROBLEMS do.

all calling a problem undecidable means is that there are some inputs
which cannot be decided upon. that undecidability does not apply to all
input, only some (or else we couldn't *ever* get an answer)... therefore >>> it only applies to some subset of machines.

No, that's wrong. Every machine has a definite halting status and is
thus trivially decidable. It means no machine gets everything right.

WHAT IS THAT "UNDECIDABLE" HALTING MACHINE BRO???

It doesn't exist. There are only machines decided incorrectly.

WHAT IS AN EXAMPLE OF A HALTING MACHINE THAT IS DECIDED INCORRECTLY????

The Pathological P when decided on by the H that it was built on.

H(P) (by Olcott) says it doesn't halt, but when we run P it halts.

Of course, H1(P) might be able to correct return 1 as it halts
--- Synchronet 3.21a-Linux NewsLink 1.2