On 11/1/25 12:37 PM, dart200 wrote:
On 11/1/25 6:19 AM, Richard Damon wrote:
On 11/1/25 2:18 AM, dart200 wrote:
On 10/31/25 9:33 PM, Richard Damon wrote:
On 10/31/25 11:52 PM, dart200 wrote:
On 10/31/25 8:33 PM, Richard Damon wrote:
On 10/31/25 11:16 PM, dart200 wrote:
On 10/31/25 7:59 PM, Richard Damon wrote:
On 10/31/25 3:29 PM, dart200 wrote:
On 10/31/25 9:18 AM, Richard Damon wrote:
On 10/30/25 2:27 PM, dart200 wrote:
On 10/29/25 8:42 PM, olcott wrote:
On 10/29/2025 10:23 PM, dart200 wrote:
On 10/29/25 6:45 PM, Richard Damon wrote:
On 10/29/25 12:24 PM, dart200 wrote:TMs with a modification, specifically adding full >>>>>>>>>>>>>> mechanical reflection to TMs in order to produce
On 10/29/25 4:29 AM, Richard Damon wrote:
On 10/28/25 11:23 PM, dart200 wrote:blatant lie
On 10/28/25 6:55 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 10/28/25 9:41 PM, dart200 wrote:
On 10/28/25 6:34 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>>>>>> On 10/28/2025 5:43 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>> [...]
not my argument u fucking useless boomer >>>>>>>>>>>>>>>>>>>>>Well, how do you solve the halting problem? >>>>>>>>>>>>>>>>>>>>>
with reflection, something u lack as a useless >>>>>>>>>>>>>>>>>>>> fucking boomer
Which you can't say how to do, because your only >>>>>>>>>>>>>>>>>>> answer is to define that you can.
we haven't even gotten the point of working out the >>>>>>>>>>>>>>>>>> ramifications of what i've defined,
Because you haven't actually defined what you are doing. >>>>>>>>>>>>>>>>
Really, show where you have ACTUALLY fully defined your >>>>>>>>>>>>>>> computation machine to a level you can actually analyize >>>>>>>>>>>>>>> one.
Reflective TMs (RTMs)
adding full mechanical reflection just means it gets a >>>>>>>>>>>>>> single instruction that dumps *all* this information to >>>>>>>>>>>>>> the tape, at the head, when that instruction is called: >>>>>>>>>>>>>>
1) machine description
2) initial tape state
3) current instruction
4) current tape state
call it REFLECT, if u will... this information allows a >>>>>>>>>>>>>> computation to know exactly where it is in the overall >>>>>>>>>>>>>> runtime of computation, and with that it can subvert >>>>>>>>>>>>>> semantic paradoxes like the halting problem.
you have to understand this is a *mechanical* modification >>>>>>>>>>>>>> to turing machines, not a computational one. much like how >>>>>>>>>>>>>> RTMs can move a head left/right, or write 0/1 to the >>>>>>>>>>>>>> tape ... they mechanically just do this operation when the >>>>>>>>>>>>>> instruction is called.
*these mechanics are (relatively) simple and self- >>>>>>>>>>>>>> evidentially possible and therefore mathematically feasible.* >>>>>>>>>>>>>>
BUT, let me try a step deeper, and quote turing at you >>>>>>>>>>>>>> from his original paper on computable numbers:
/We may compare a man in the process of computing a real >>>>>>>>>>>>>> number to a
machine which is only capable of a finite number of >>>>>>>>>>>>>> conditions/ [Tur36]
THE ENTIRE JUSTIFICATION FOR TURING MACHINES RESTS >>>>>>>>>>>>>> SQUARELY ON THE NOTION OF "CAN A MAN MECHANICALLY >>>>>>>>>>>>>> UNDERTAKE THESE STATE TRANSITIONS"
1) if a man is running thru the steps of a computation, >>>>>>>>>>>>>> then obviously he has access the full machine description, >>>>>>>>>>>>>> or how else the fuck is he doing any of these state >>>>>>>>>>>>>> transitions??? therefore he obviously can dump the machine >>>>>>>>>>>>>> description, in whatever format he has it in, to the tape >>>>>>>>>>>>>> when REFLECT is encountered.
2) if a man is running thru the steps of a computation, >>>>>>>>>>>>>> then obviously he can to the side save the initial tape in >>>>>>>>>>>>>> a "buffer" that than cannot be overwritten. with that he >>>>>>>>>>>>>> can can obviously dump the initial tape state to the tape >>>>>>>>>>>>>> whenever REFLECT is encountered.
3) if a man is running thru the steps of a computation, >>>>>>>>>>>>>> then obviously he has access input of a particular >>>>>>>>>>>>>> transition, and therefore can dump that input to the tape >>>>>>>>>>>>>> when REFLECT is encountered, in whatever format he >>>>>>>>>>>>>> encounters it in.
4) if a man is running thru the steps of a computation ... >>>>>>>>>>>>>> he can obviously duplicate the tape when REFLECT is >>>>>>>>>>>>>> called. or more precisely he can save it into a buffer, >>>>>>>>>>>>>> and dump from the buffer after putting 1-3 on the tape. >>>>>>>>>>>>>>
THAT IS THE SAME LEVEL OF FORMAT JUSTIFICATION TURING >>>>>>>>>>>>>> ULTIMATELY GIVES FOR ANY COMPUTING MACHINE. SERIOUSLY READ >>>>>>>>>>>>>> HIS FUCKING ESSAY YOU DORK
please tell me where u are confused, not how u think i'm >>>>>>>>>>>>>> wrong
I can finally see the gist of what you are saying
and it seems to be very similar to my idea.
like i've said polcott, i consider you having a half-way >>>>>>>>>>>> solution. u have something that's executable for sure, and >>>>>>>>>>>> that is a definite improvement over total undecidability. >>>>>>>>>>>>
but it's not totally epistemically useful, it still
doesn't / effectively compute/ the halting function in a >>>>>>>>>>>> *general* manner.
i'm proposing something that's both executable *and*
epistemically useful for that purpose.
the RTM i'm proposing here is just the underlying
theoretical mechanisms that can be used to produce a
theoretically coherent context-dependent decider,
which can then be used to /effectively compute/ the halting >>>>>>>>>>>> function irrespective of semantic paradoxes ...
something that is in total a step beyond the mere
executability that you are proposing.
No, the problem you have is that you make the same error and >>>>>>>>>>> try to redefine the question, and allow your machine to give >>>>>>>>>>> wrong answers.
it's not a "wrong" answer if it contains no information to be >>>>>>>>>> wrong about, and it's only given in a situation where there's >>>>>>>>>> no "right" answer.
But their is a right answer for every actual D based on every >>>>>>>>> actual H.
It just isn't the answer that H gives.
how is it reasonable to expect a decider to respond truthfully >>>>>>>>>> to a situation that would only make that truth untrue
Because deciders are just deterministic processes with a fixed >>>>>>>>> algorithm.
right, and context can be an input to the determinism
console.trace() isn't nondeterministic, it's context dependent >>>>>>>>
Note, the system DOES understand that some problems turn out to >>>>>>>>> be uncomputable, so no decider exists that can be correct for >>>>>>>>> all inputs. Nothing wrong with that, it just means that any >>>>>>>>> decider that wants to try to claim to solve it will be wrong >>>>>>>>> for some input.
The key point here is the question can't be asked until after a >>>>>>>>> decider steps up to make the claim, as the prove-it-wrong input >>>>>>>>> is different for every possible decider, and thus, by the time >>>>>>>>> the question can be asked, the deciders result for that input >>>>>>>>> was already determined by its algorithm. For the decider it >>>>>>>>> isn't a matter of being "truthful", it is just doing what it >>>>>>>>> was programmed to do.
It becomes a matter of correctness, not truthfulness.
It is the creator of the algoritm to which truthfulness is
applied, and claiming that it will give the right answer when >>>>>>>>> it doesn't shows that his claim wasn't truthful.
there's no "correct" answer to a pathological question of
halts(und) on this line:
und = () -> halts(und) && loop_forever()
Which isn't a computation if your symbology means that halts is >>>>>>> taken from the context that the symbol und is used in.
Sorry, you are just showing you don't know the meaning of the words. >>>>>>>
and the resolution is just to give a non-answer, so i split the >>>>>>>> decider into two halves and made false a non-answer. it cannot >>>>>>>> be a contradiction because it doesn't give information /in that >>>>>>>> moment/ about und() to contradict.
But since you are starting with the same category error of
Olcott, you get the same nonsense he does.
The category for the input to a Halt Decider is the
representation of a Computation.
By DEFINITION, this has a FULLY defined algorithm, and thus NOT a >>>>>>> closure.
If you want to try to define your own theory of computation that >>>>>>> uses a broader defintion, go ahead, the problem is you will find >>>>>>> you can do litle with it, and that the semantic paradox you are >>>>>>> complaining about is totally due to you altered definition of a >>>>>>> computation.
right why do u keep asserting ur existential fuckup is more
correct than a working decider on the matter???
Because it doesn't give the right answer per the original problem.
it gives you the right answer in all the places that the information
of that answer is actually usable, and it does so generally.
In other words, your logic says it is ok to be wrong in some cases,
if you can give a "good excuse" why it is ok to be wrong there.
All that does is destroy the meaning of "Correct".
you are holding onto some notion of wanting a "right" answer where
no right answer can exist, and that's just bizarre because with that
desire u lose the ability to generally get a "right" answer in first
place.
Because it *DOES* have a proper definition.
ALWAYS means ALWAYS, not just where I want it.
i can't believe ur a chief engineer asking for correctness where
a) it has no practical usecase
b) it ends up neutering ur theoretical ability to generally handle the
problem
ur demanding to be able to shoot urself in ur foot over some decider
that can't even exist.
weird fetish bro
I guess you just think that lies are valid, and truth doesn't matter.
Note, a real halt decider, if it existed, would have a LOT of actually practical uses, and the fact it can't exist is important knowledge.
ur throwing the fucking baby out with the bathwater dude,
it's fucking stupid
Nope, because for actual problems like Busy Beaver, which again asks
about for results from ALL possible machihes with specific criteria,
that pattern might just coencidentally occur.
If you want to be clear that you aren't working on that problem, or >>>>> even working under that system, go ahead, just make sure you fully
define what you are doing and try to show where it is useful.
i'm not building a separate form of computing, i'm upgrading what we
have
In other words, you are admitting you are lying.
It is a VIOLATION of the meaning of the words to change the meaning
of the word as already used.
You "upgrade" a system by adding new ideas without removing or
changing any of the old.
If you need to remove or change something, you have a new system.
DEFINITION.
like adding a new operation BY DEFINITION???
Sure, it it can't be done within the limits of the previously defined system.
honestly idk if ur just in denial, too senior to take criticism
anymore, or just shoved a stick too far ur butthole,
Nope, it is just sticking up for truth against stupid people who don't understand what they are talking about.
but suggesting i'm not changing anything when i've spent pages trying
to define a very particular change, even given it's a label RTM is
just completely disingenuous of you.
So, how does the machine write out information that it doesn't have stored?
i'm insulted at the lack of consideration i'm getting here, clearly u
have no willingness to engaging in genuine discussion, cause ur just
blatantly lying about my position.
Then you are being insulted by your own errors.
YOU are the one who has decided not to engage in answering question put
to you to explain.
how can u offer me any meaningful feedback if ur just gunna blatantly
lie about my position???
What LIE have I said?
To show that what I have said can't be done, just needs a showing how
you claim it actually could be done within the restrictions of the
framework you are in.
Part of your problem, is it seems you haven't bothered to learn what the frameworks actually is.
Again, all you are doing is admitting that you system is based on you
claiming the right to lie about what you are doing, by ignoring the
rules of the system.
yes this does mean maybe /false/ could be returned everywhere, >>>>>>>> but that's not fucking interesting ... nor does it give /
effective computability/ in regards to the halting question.
Since your input is a category error for the actual Computation >>>>>>> Theory as classical defined, your results don't apply.
classic computing theory doesn't have a halt decider defined
tho ... u only have a halting function, not a decider. the decider >>>>>> is *disproven* and therefore cannot be defined as per consensus
theory.
u fucking retard.
u keep asserting SOMETHING THAT DOESN'T EVEN EXIST is somehow more >>>>>> correct than SOMETHING THAT CAN EXIST
The DEFINITION of a Halting Decider exists.
The fact that the definiton is not realizable, proves the theory.
To call something a Halt Decider that doesn't meet the definition,
is just a lie, making the person making the claim just a liar.
just like there's more than one way to ask the same question,
there's more than one way to define a halting decider, which is the
interface into an algorithm, not the algorithm itself.
Right, but if they are semantically different, it isn't the same
question.
the one i'm proposing can actually generally exist, unlike the
classical definition.
But only is a Computation System that is broken, because programs
don't reliable produce the same answer when run.
Once you allow things to lie, you have destroyed the concept of truth.
it's really that simple.
Yes, allowing lying seems simple until you need to count on something.
ur special pleading is just so mindnumbingly boring. i DEFINED my
We can easily DEFINE things that don't exist.>
which is the point of the context-dependent decider. halts() is >>>>>>>> required to return /true/ only whereever both /possible/ and / >>>>>>>> truthful/ to do so.
So, if you want to try to talk about this, you first need to try >>>>>>> to develop a basic theory about context dependent Computations, >>>>>>> to see if it can actually be useful for anything.
i fucking already did. u just aren't reading cause ur too busy
trying to show off how big a fucking retard u can be.
No you haven't, unless you consider your claim that is the
equivalent of defining that 1 == 2 is a definition.
DESCRIBING what you want to do is NOT the same as DEFINING how to
do it.
mechanics in MORE detail that turing did his, and yet u arbitrarily
reject it as "describing" which seems like a made up distinction here.
NO YOU HAVEN'T.
You have PRESUMED an ability on the machine that can not actually be
implemented on it without breaking it.
i'm intelligent enough to write down the machine description to the
tape when i see the operation REFLECT, and therefore accept the
defined ability
But is it the RIGHT machine description for the program in question?
And where does it get the contents of the original tape?
i get that ur apparently too fucking retarded to do that, and
therefore don't accept it.
Nope, it seems you are too retarded to actually think about what other
say about your system. You suffer from the fallacy that you assume you
are right and thus ignore the definitions of what you are talking about.
Your "Definition" is the equivalent of defining that for this work, I
will consider 1 to be equal to 2.
sometimes i really do feel like just buying a gun a shooting myself,
cause i really am stuck on a planet of fucking idiots.
y must u endlessly torture me so with ur fucking idiocracy?
I could say the same to you. Why are you so stuck on insisting on
things that are not.
Computations, as defined, can't change their answers for the same
input. PERIOD.
To insist they can is just to admit you are just a lunatic.
right, printing stack traces actually isn't part of computing. every
time we step thru debugging we're doing theoretically indescribable
magic, according to richard
And what does that have to do with what I said?
And yes, a routine looking at who called it is NOT part of "Computing"
per computation theory, as it can't matter.
It seems part of your problem is you don't actually know what you are talking about.
Remember, Computing isn't directly about "Computers" as we currently
know them, but is more fundamental.
It seems you have forgotten that "Computing" as a term existed BEFORE
the computers you want to talk about.
So, how does the machine write out information that it doesn't have stored?
On 11/2/25 11:10 AM, Richard Damon wrote:
On 11/1/25 12:37 PM, dart200 wrote:
On 11/1/25 6:19 AM, Richard Damon wrote:
On 11/1/25 2:18 AM, dart200 wrote:
On 10/31/25 9:33 PM, Richard Damon wrote:
On 10/31/25 11:52 PM, dart200 wrote:
On 10/31/25 8:33 PM, Richard Damon wrote:
On 10/31/25 11:16 PM, dart200 wrote:
On 10/31/25 7:59 PM, Richard Damon wrote:
On 10/31/25 3:29 PM, dart200 wrote:
On 10/31/25 9:18 AM, Richard Damon wrote:
On 10/30/25 2:27 PM, dart200 wrote:
On 10/29/25 8:42 PM, olcott wrote:
On 10/29/2025 10:23 PM, dart200 wrote:
On 10/29/25 6:45 PM, Richard Damon wrote:
On 10/29/25 12:24 PM, dart200 wrote:TMs with a modification, specifically adding full >>>>>>>>>>>>>>> mechanical reflection to TMs in order to produce >>>>>>>>>>>>>>> Reflective TMs (RTMs)
On 10/29/25 4:29 AM, Richard Damon wrote:
On 10/28/25 11:23 PM, dart200 wrote:blatant lie
On 10/28/25 6:55 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 10/28/25 9:41 PM, dart200 wrote:
On 10/28/25 6:34 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/28/2025 5:43 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>> [...]
not my argument u fucking useless boomer >>>>>>>>>>>>>>>>>>>>>>Well, how do you solve the halting problem? >>>>>>>>>>>>>>>>>>>>>>
with reflection, something u lack as a useless >>>>>>>>>>>>>>>>>>>>> fucking boomer
Which you can't say how to do, because your only >>>>>>>>>>>>>>>>>>>> answer is to define that you can.
we haven't even gotten the point of working out the >>>>>>>>>>>>>>>>>>> ramifications of what i've defined,
Because you haven't actually defined what you are doing. >>>>>>>>>>>>>>>>>
Really, show where you have ACTUALLY fully defined your >>>>>>>>>>>>>>>> computation machine to a level you can actually analyize >>>>>>>>>>>>>>>> one.
adding full mechanical reflection just means it gets a >>>>>>>>>>>>>>> single instruction that dumps *all* this information to >>>>>>>>>>>>>>> the tape, at the head, when that instruction is called: >>>>>>>>>>>>>>>
1) machine description
2) initial tape state
3) current instruction
4) current tape state
call it REFLECT, if u will... this information allows a >>>>>>>>>>>>>>> computation to know exactly where it is in the overall >>>>>>>>>>>>>>> runtime of computation, and with that it can subvert >>>>>>>>>>>>>>> semantic paradoxes like the halting problem.
you have to understand this is a *mechanical*
modification to turing machines, not a computational one. >>>>>>>>>>>>>>> much like how RTMs can move a head left/right, or write >>>>>>>>>>>>>>> 0/1 to the tape ... they mechanically just do this >>>>>>>>>>>>>>> operation when the instruction is called.
*these mechanics are (relatively) simple and self- >>>>>>>>>>>>>>> evidentially possible and therefore mathematically >>>>>>>>>>>>>>> feasible.*
BUT, let me try a step deeper, and quote turing at you >>>>>>>>>>>>>>> from his original paper on computable numbers:
/We may compare a man in the process of computing a real >>>>>>>>>>>>>>> number to a
machine which is only capable of a finite number of >>>>>>>>>>>>>>> conditions/ [Tur36]
THE ENTIRE JUSTIFICATION FOR TURING MACHINES RESTS >>>>>>>>>>>>>>> SQUARELY ON THE NOTION OF "CAN A MAN MECHANICALLY >>>>>>>>>>>>>>> UNDERTAKE THESE STATE TRANSITIONS"
1) if a man is running thru the steps of a computation, >>>>>>>>>>>>>>> then obviously he has access the full machine
description, or how else the fuck is he doing any of >>>>>>>>>>>>>>> these state transitions??? therefore he obviously can >>>>>>>>>>>>>>> dump the machine description, in whatever format he has >>>>>>>>>>>>>>> it in, to the tape when REFLECT is encountered.
2) if a man is running thru the steps of a computation, >>>>>>>>>>>>>>> then obviously he can to the side save the initial tape >>>>>>>>>>>>>>> in a "buffer" that than cannot be overwritten. with that >>>>>>>>>>>>>>> he can can obviously dump the initial tape state to the >>>>>>>>>>>>>>> tape whenever REFLECT is encountered.
3) if a man is running thru the steps of a computation, >>>>>>>>>>>>>>> then obviously he has access input of a particular >>>>>>>>>>>>>>> transition, and therefore can dump that input to the tape >>>>>>>>>>>>>>> when REFLECT is encountered, in whatever format he >>>>>>>>>>>>>>> encounters it in.
4) if a man is running thru the steps of a
computation ... he can obviously duplicate the tape when >>>>>>>>>>>>>>> REFLECT is called. or more precisely he can save it into >>>>>>>>>>>>>>> a buffer, and dump from the buffer after putting 1-3 on >>>>>>>>>>>>>>> the tape.
THAT IS THE SAME LEVEL OF FORMAT JUSTIFICATION TURING >>>>>>>>>>>>>>> ULTIMATELY GIVES FOR ANY COMPUTING MACHINE. SERIOUSLY >>>>>>>>>>>>>>> READ HIS FUCKING ESSAY YOU DORK
please tell me where u are confused, not how u think i'm >>>>>>>>>>>>>>> wrong
I can finally see the gist of what you are saying
and it seems to be very similar to my idea.
like i've said polcott, i consider you having a half-way >>>>>>>>>>>>> solution. u have something that's executable for sure, and >>>>>>>>>>>>> that is a definite improvement over total undecidability. >>>>>>>>>>>>>
but it's not totally epistemically useful, it still >>>>>>>>>>>>> doesn't / effectively compute/ the halting function in a >>>>>>>>>>>>> *general* manner.
i'm proposing something that's both executable *and* >>>>>>>>>>>>> epistemically useful for that purpose.
the RTM i'm proposing here is just the underlying
theoretical mechanisms that can be used to produce a >>>>>>>>>>>>> theoretically coherent context-dependent decider,
which can then be used to /effectively compute/ the halting >>>>>>>>>>>>> function irrespective of semantic paradoxes ...
something that is in total a step beyond the mere
executability that you are proposing.
No, the problem you have is that you make the same error and >>>>>>>>>>>> try to redefine the question, and allow your machine to give >>>>>>>>>>>> wrong answers.
it's not a "wrong" answer if it contains no information to be >>>>>>>>>>> wrong about, and it's only given in a situation where there's >>>>>>>>>>> no "right" answer.
But their is a right answer for every actual D based on every >>>>>>>>>> actual H.
It just isn't the answer that H gives.
Because deciders are just deterministic processes with a fixed >>>>>>>>>> algorithm.
how is it reasonable to expect a decider to respond
truthfully to a situation that would only make that truth untrue >>>>>>>>>>
right, and context can be an input to the determinism
console.trace() isn't nondeterministic, it's context dependent >>>>>>>>>
Note, the system DOES understand that some problems turn out >>>>>>>>>> to be uncomputable, so no decider exists that can be correct >>>>>>>>>> for all inputs. Nothing wrong with that, it just means that >>>>>>>>>> any decider that wants to try to claim to solve it will be >>>>>>>>>> wrong for some input.
The key point here is the question can't be asked until after >>>>>>>>>> a decider steps up to make the claim, as the prove-it-wrong >>>>>>>>>> input is different for every possible decider, and thus, by >>>>>>>>>> the time the question can be asked, the deciders result for >>>>>>>>>> that input was already determined by its algorithm. For the >>>>>>>>>> decider it isn't a matter of being "truthful", it is just >>>>>>>>>> doing what it was programmed to do.
It becomes a matter of correctness, not truthfulness.
It is the creator of the algoritm to which truthfulness is >>>>>>>>>> applied, and claiming that it will give the right answer when >>>>>>>>>> it doesn't shows that his claim wasn't truthful.
there's no "correct" answer to a pathological question of
halts(und) on this line:
und = () -> halts(und) && loop_forever()
Which isn't a computation if your symbology means that halts is >>>>>>>> taken from the context that the symbol und is used in.
Sorry, you are just showing you don't know the meaning of the >>>>>>>> words.
and the resolution is just to give a non-answer, so i split the >>>>>>>>> decider into two halves and made false a non-answer. it cannot >>>>>>>>> be a contradiction because it doesn't give information /in that >>>>>>>>> moment/ about und() to contradict.
But since you are starting with the same category error of
Olcott, you get the same nonsense he does.
The category for the input to a Halt Decider is the
representation of a Computation.
By DEFINITION, this has a FULLY defined algorithm, and thus NOT >>>>>>>> a closure.
If you want to try to define your own theory of computation that >>>>>>>> uses a broader defintion, go ahead, the problem is you will find >>>>>>>> you can do litle with it, and that the semantic paradox you are >>>>>>>> complaining about is totally due to you altered definition of a >>>>>>>> computation.
right why do u keep asserting ur existential fuckup is more
correct than a working decider on the matter???
Because it doesn't give the right answer per the original problem.
it gives you the right answer in all the places that the
information of that answer is actually usable, and it does so
generally.
In other words, your logic says it is ok to be wrong in some cases,
if you can give a "good excuse" why it is ok to be wrong there.
All that does is destroy the meaning of "Correct".
you are holding onto some notion of wanting a "right" answer where
no right answer can exist, and that's just bizarre because with
that desire u lose the ability to generally get a "right" answer in >>>>> first place.
Because it *DOES* have a proper definition.
ALWAYS means ALWAYS, not just where I want it.
i can't believe ur a chief engineer asking for correctness where
a) it has no practical usecase
b) it ends up neutering ur theoretical ability to generally handle
the problem
ur demanding to be able to shoot urself in ur foot over some decider
that can't even exist.
weird fetish bro
I guess you just think that lies are valid, and truth doesn't matter.
Note, a real halt decider, if it existed, would have a LOT of actually
practical uses, and the fact it can't exist is important knowledge.
ur throwing the fucking baby out with the bathwater dude,
it's fucking stupid
Nope, because for actual problems like Busy Beaver, which again asks
about for results from ALL possible machihes with specific criteria,
that pattern might just coencidentally occur.
If you want to be clear that you aren't working on that problem,
or even working under that system, go ahead, just make sure you
fully define what you are doing and try to show where it is useful. >>>>>>
i'm not building a separate form of computing, i'm upgrading what
we have
In other words, you are admitting you are lying.
It is a VIOLATION of the meaning of the words to change the meaning
of the word as already used.
You "upgrade" a system by adding new ideas without removing or
changing any of the old.
If you need to remove or change something, you have a new system.
DEFINITION.
like adding a new operation BY DEFINITION???
Sure, it it can't be done within the limits of the previously defined
system.
honestly idk if ur just in denial, too senior to take criticism
anymore, or just shoved a stick too far ur butthole,
Nope, it is just sticking up for truth against stupid people who don't
understand what they are talking about.
but suggesting i'm not changing anything when i've spent pages trying
to define a very particular change, even given it's a label RTM is
just completely disingenuous of you.
So, how does the machine write out information that it doesn't have
stored?
i'm insulted at the lack of consideration i'm getting here, clearly u
have no willingness to engaging in genuine discussion, cause ur just
blatantly lying about my position.
Then you are being insulted by your own errors.
YOU are the one who has decided not to engage in answering question
put to you to explain.
how can u offer me any meaningful feedback if ur just gunna blatantly
lie about my position???
What LIE have I said?
To show that what I have said can't be done, just needs a showing how
you claim it actually could be done within the restrictions of the
framework you are in.
Part of your problem, is it seems you haven't bothered to learn what
the frameworks actually is.
Again, all you are doing is admitting that you system is based on
you claiming the right to lie about what you are doing, by ignoring
the rules of the system.
yes this does mean maybe /false/ could be returned everywhere, >>>>>>>>> but that's not fucking interesting ... nor does it give /
effective computability/ in regards to the halting question.
Since your input is a category error for the actual Computation >>>>>>>> Theory as classical defined, your results don't apply.
classic computing theory doesn't have a halt decider defined
tho ... u only have a halting function, not a decider. the
decider is *disproven* and therefore cannot be defined as per
consensus theory.
u fucking retard.
u keep asserting SOMETHING THAT DOESN'T EVEN EXIST is somehow
more correct than SOMETHING THAT CAN EXIST
The DEFINITION of a Halting Decider exists.
The fact that the definiton is not realizable, proves the theory.
To call something a Halt Decider that doesn't meet the definition, >>>>>> is just a lie, making the person making the claim just a liar.
just like there's more than one way to ask the same question,
there's more than one way to define a halting decider, which is the >>>>> interface into an algorithm, not the algorithm itself.
Right, but if they are semantically different, it isn't the same
question.
the one i'm proposing can actually generally exist, unlike the
classical definition.
But only is a Computation System that is broken, because programs
don't reliable produce the same answer when run.
Once you allow things to lie, you have destroyed the concept of truth. >>>>
it's really that simple.
Yes, allowing lying seems simple until you need to count on something. >>>>
NO YOU HAVEN'T.
ur special pleading is just so mindnumbingly boring. i DEFINED my
We can easily DEFINE things that don't exist.>
which is the point of the context-dependent decider. halts() is >>>>>>>>> required to return /true/ only whereever both /possible/ and / >>>>>>>>> truthful/ to do so.
So, if you want to try to talk about this, you first need to try >>>>>>>> to develop a basic theory about context dependent Computations, >>>>>>>> to see if it can actually be useful for anything.
i fucking already did. u just aren't reading cause ur too busy
trying to show off how big a fucking retard u can be.
No you haven't, unless you consider your claim that is the
equivalent of defining that 1 == 2 is a definition.
DESCRIBING what you want to do is NOT the same as DEFINING how to >>>>>> do it.
mechanics in MORE detail that turing did his, and yet u arbitrarily >>>>> reject it as "describing" which seems like a made up distinction here. >>>>
You have PRESUMED an ability on the machine that can not actually be
implemented on it without breaking it.
i'm intelligent enough to write down the machine description to the
tape when i see the operation REFLECT, and therefore accept the
defined ability
But is it the RIGHT machine description for the program in question?
And where does it get the contents of the original tape?
i get that ur apparently too fucking retarded to do that, and
therefore don't accept it.
Nope, it seems you are too retarded to actually think about what other
say about your system. You suffer from the fallacy that you assume you
are right and thus ignore the definitions of what you are talking about.
Your "Definition" is the equivalent of defining that for this work,
I will consider 1 to be equal to 2.
sometimes i really do feel like just buying a gun a shooting
myself, cause i really am stuck on a planet of fucking idiots.
y must u endlessly torture me so with ur fucking idiocracy?
I could say the same to you. Why are you so stuck on insisting on
things that are not.
Computations, as defined, can't change their answers for the same
input. PERIOD.
To insist they can is just to admit you are just a lunatic.
right, printing stack traces actually isn't part of computing. every
time we step thru debugging we're doing theoretically indescribable
magic, according to richard
And what does that have to do with what I said?
And yes, a routine looking at who called it is NOT part of "Computing"
per computation theory, as it can't matter.
It seems part of your problem is you don't actually know what you are
talking about.
Remember, Computing isn't directly about "Computers" as we currently
know them, but is more fundamental.
It seems you have forgotten that "Computing" as a term existed BEFORE
the computers you want to talk about.
blows my mind that u think a computing function that prints a stack
trace does something which cannot be done on and explained by a turing machine
i'm not sure y u think this mindnumbing gishgallop u shit out is worth a continued response to
can u explain what my argument even is?
or are you basically just a fucking chatbot keying off one sentence at a time?
On 02/11/2025 19:10, Richard Damon wrote:
So, how does the machine write out information that it doesn't have stored?
A TM (at least typically) has a current machine state from a finite list
of machine states, a reflecting extension can be defined to have a representation for each that it writes out upon interpreting a symbol at
the tape head for each machine state (or for a subset of machine states,
etc) instead of a simple move-left or move-right.
For clarity I think dart200 is talking about an extended TM, extended to
have one or more machine-state write-out transitions defined.
For additional clarity, "machine state" does not normally refer to the
tape contents nor to the current tape-cell index but the state of the
machine (like register values, for machines defined to have those). You
can't include the tape cell index in the machine state because then it
would have an infinite number of machine states. I understand that would
not be a TM, strictly.
--
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.
On 11/2/2025 2:57 PM, Tristan Wibberley wrote:
[ ... whatever ... ]That seems to show a pretty good depth of understanding.
On 2025-11-01, dart200 <[email protected]d> wrote:
On 11/1/25 9:37 AM, Kaz Kylheku wrote:
On 2025-11-01, dart200 <[email protected]d> wrote:
On 10/31/25 9:20 PM, Kaz Kylheku wrote:
On 2025-11-01, dart200 <[email protected]d> wrote:
there's no "correct" answer to a pathological question of halts(und) on >>>>>> this line:
und = () -> halts(und) && loop_forever()
Yes there is; the correct answer is ¬halts(und). The logical negation >>>>> of whatever halts(und) decides.
the correct answer is to give the opposite of it's own answer???
The correct answer isn't /to give/ anything; it just /is/
halts() is a total decider, ur now just ignoring what i defined()
I'm obviously aware of how you defined it.
If you initially impose the definition "halts is the name of a total decider", then you arrive at a contradiction: halts cannot be
deciding und, as required of a total decider.
So then, the definition is a kind of proposition, which is shown false;
it does not hold.
But what is the logical opposite of the proposition "halts is the name
of a total decider?" It is not: "halts does not exist", but simply:
"halts is /not/ the name of a total decider".
A halts can exist just fine, just not as a total decider.
Stop insisting that halts is a the total halting decider which cannot
exist, allowing it to be a partial halting decider which cannot be
total, and the apparent paradox goes away. und then exists and has a
defnite halting status, which is opposite to whatever that partial
decider says.
great now ur arguing polcott is right.
Not really; he has never agreed with the above!
the problem with a set of partial deciders is that the resolution isn't
/effectively computable/. with "partial" deciders then the question
becomes which partial decider is correct: u've just kicked the can down
the road
Yes; because no combination of partial deciders gives you a total
decider.
We can trivially form a set of partial deciders which has complete
coverage:
H_0 := (P) -> 0
H_1 := (P) -> 1
H_0 correctly decides all non-terminating inputs. H_1 correctly
decides all terminating inputs. So one of these two is always
correct! (Notice how I'm not saying anything more informative
than "a machine always halts or does not halt").
We don't know which decider is the right one for which input.
We need a third decider H whch decides whether to use H_0
or H_1.
This example may look silly: because what is H, but simply
a decider which has to determine whether to returh 0 or 1
(which are only trivially disguised as H_0(P) and H_1(P))?
But this idea generalizes. No matter what kind of partial deciders we
have, or how many, deciding which one is correct for which input is equivalent to deciding halting.
The result of combining partial deciders will always be a decider
that can be shown not to be total.
The can is indeed always kicked down the road.
yes this does mean maybe /false/ could be returned everywhere, but >>>>>> that's not fucking interesting ... nor does it give /effective
computability/ in regards to the halting question.
which is the point of the context-dependent decider. halts() is required >>>>>> to return /true/ only whereever both /possible/ and /truthful/ to do so. >>>>>>
if u don't agree with this, that's fine...
but you actually need to construct a contradiction, you can't just >>>>>> continually make bare assertions that it's a contradiction.
If contexts are represenable in a Turing substrate, then everything
succumbs to Turing incomputability of halting.
If contexts are not representable in Turing, then the
model-with-contexts is either effectievely computable non-Turing, or >>>>> else contexts are just imaginary, like magic oracles.
false dichotomy
Well, trichotomy, by my count.
- contexts are Turing (1)
- contexts are not Turing:
- somehow effectively computable (2)
- not computable (3)
What possibility have I unintentionally left out?
like i'm even open to being wrong, but like u need to work with the
system in order to show a contradiction with the system itself, just not >>>> assume the contradiction will happen.
If they are imaginary, you only have a thought experiment.
(In which Turing-plus-contexts machines can decide Turing
halting, but so what?)
REFLECT is completely mechanically demonstrable operation with a pen and >>>> paper, i demonstrated it in a post here already, justifying it's
theoretical existence
OK, that points to it being embeddable in Turing
computation. Which then points to undecidabiity.
or ur just assuming a false dichotomy
If your mechanical pencil-and-paper calculations are shown to be Turing, anything rendered using those calculations is Turing. It is not
a dichotomy, true or false.
the TM limitation is mechanical, not computational. classical theory
only supposes about computational limitations, there's no notion of
mechanical limitation.
Are you talking about analog computation with continuous quantities,
and such?
So your pencil-and-paper calculations are actually perhaps geometric,
like compass-and-ruler derivations?
but the mechanical, not computational, limitation means:
- TMs can simulate RTMs
- RTMs don't fix the problems with TMs
- it doesn't matter that they don't because RTMs can compute
everything TMs do + have increased power
If TMs can simulate RTMs then they do not have increased power.
They may have increased "expressive power", which is something only
relevant to how "nice" they are to write applications in.
A different Turing model can also have better efficiency; i.e the best
way of solving a problem in one kind of machine may have exponential
time whereas another can express a solution that is polynomial.
Since
- ugly code that correctly solves a problem halts,
- inefficient code that correctly solves a problem halts,
neither expressive power nor efficiency are relevant in halting.
what i'm doing is trivializing TMs undecidability, not resolving it. but
this overall resolves the halting problem by providing a mechanical
improvement that can allow theory to escape limitations stemming from
the liar's paradox being encoded into machines
(If you want to talk Olcott, /that/'s a great narrative:
"halting problem implies liar paradox.")
REFLECT gives a semantic decider the ability to know it's calling
context, which gives it the ability to return a context dependent answer. >>>>
If you find some computational model with contexts which is effective, >>>>> but beyond Turing, then /that/ is the big deal; delegate the halting >>>>> cruft to others. You are important because you've done what nobody else >>>>> has done before: you found an effective method of computation that is >>>>> not Turing! So you go to conference sall over the world where you are >>>>> flocked by groupies. Fuck halting, at that point, you know?
it's a mild extension of TMs,
If it is mechanically demonstrable with pen and paper, then it isn't
an extension of TM.
no idea what u mean here, TMs are likewise also demonstrable with a pen
and paper, and that was turing's original justification for their
feasibility
(What I mean that it's just TM, and not an extension.)
Functions can depend on their context. That context can make some
instances of them halting and others not, even with all the explicit
arguments being the same. Thus we cannot ask whether a function halts;
it has to be, does it halt /in what calling context/.
only if it involves a REFLECT command, otherwise it's not possible to be
dependent on context.
So if only deciders are allowed to use REFLECT, but the inputs
are not allowed to use REFLECT, then indeed it is impossible for an
input to contradict a decider which uses REFLECT.
But then deciders are not deciding everything; they are deciding
only those inputs that don't use REFLECT.
On 11/1/25 1:26 PM, Kaz Kylheku wrote:
On 2025-11-01, dart200 <[email protected]d> wrote:
On 11/1/25 9:37 AM, Kaz Kylheku wrote:
On 2025-11-01, dart200 <[email protected]d> wrote:
On 10/31/25 9:20 PM, Kaz Kylheku wrote:
On 2025-11-01, dart200 <[email protected]d> wrote:
there's no "correct" answer to a pathological question of
halts(und) on
this line:
und = () -> halts(und) && loop_forever()
Yes there is; the correct answer is ¬halts(und). The logical negation >>>>>> of whatever halts(und) decides.
the correct answer is to give the opposite of it's own answer???
The correct answer isn't /to give/ anything; it just /is/
halts() is a total decider, ur now just ignoring what i defined()
I'm obviously aware of how you defined it.
If you initially impose the definition "halts is the name of a total
decider", then you arrive at a contradiction: halts cannot be
deciding und, as required of a total decider.
So then, the definition is a kind of proposition, which is shown false;
it does not hold.
But what is the logical opposite of the proposition "halts is the name
of a total decider?" It is not: "halts does not exist", but simply:
"halts is /not/ the name of a total decider".
A halts can exist just fine, just not as a total decider.
Stop insisting that halts is a the total halting decider which cannot
exist, allowing it to be a partial halting decider which cannot be
total, and the apparent paradox goes away. und then exists and has a >>>> defnite halting status, which is opposite to whatever that partial
decider says.
great now ur arguing polcott is right.
Not really; he has never agreed with the above!
he might not agree with the wording, but it is kinda what he's proposing
the problem with a set of partial deciders is that the resolution isn't
/effectively computable/. with "partial" deciders then the question
becomes which partial decider is correct: u've just kicked the can down
the road
Yes; because no combination of partial deciders gives you a total
decider.
We can trivially form a set of partial deciders which has complete
coverage:
H_0 := (P) -> 0
H_1 := (P) -> 1
H_0 correctly decides all non-terminating inputs. H_1 correctly
decides all terminating inputs. So one of these two is always
correct! (Notice how I'm not saying anything more informative
than "a machine always halts or does not halt").
We don't know which decider is the right one for which input.
We need a third decider H whch decides whether to use H_0
or H_1.
This example may look silly: because what is H, but simply
a decider which has to determine whether to returh 0 or 1
(which are only trivially disguised as H_0(P) and H_1(P))?
But this idea generalizes. No matter what kind of partial deciders we
have, or how many, deciding which one is correct for which input is
equivalent to deciding halting.
The result of combining partial deciders will always be a decider
that can be shown not to be total.
The can is indeed always kicked down the road.
great! so ur own answered question of why i'm not particularly excited
by partial deciders, and want a way to /effectively compute/ whether an input machine halts not
do we need to have this discussion again kaz, or???
yes this does mean maybe /false/ could be returned everywhere, but >>>>>>> that's not fucking interesting ... nor does it give /effective
computability/ in regards to the halting question.
which is the point of the context-dependent decider. halts() is >>>>>>> required
to return /true/ only whereever both /possible/ and /truthful/ to >>>>>>> do so.
if u don't agree with this, that's fine...
but you actually need to construct a contradiction, you can't just >>>>>>> continually make bare assertions that it's a contradiction.
If contexts are represenable in a Turing substrate, then everything >>>>>> succumbs to Turing incomputability of halting.
If contexts are not representable in Turing, then the
model-with-contexts is either effectievely computable non-Turing, or >>>>>> else contexts are just imaginary, like magic oracles.
false dichotomy
Well, trichotomy, by my count.
- contexts are Turing (1)
- contexts are not Turing:
- somehow effectively computable (2)
- not computable (3)
What possibility have I unintentionally left out?
like i'm even open to being wrong, but like u need to work with the
system in order to show a contradiction with the system itself,
just not
assume the contradiction will happen.
If they are imaginary, you only have a thought experiment.
(In which Turing-plus-contexts machines can decide Turing
halting, but so what?)
REFLECT is completely mechanically demonstrable operation with a
pen and
paper, i demonstrated it in a post here already, justifying it's
theoretical existence
OK, that points to it being embeddable in Turing
computation. Which then points to undecidabiity.
or ur just assuming a false dichotomy
If your mechanical pencil-and-paper calculations are shown to be Turing,
anything rendered using those calculations is Turing. It is not
a dichotomy, true or false.
what i'm proposing obviously will look very much like TMs in many if not most computatation. in fact: any computation can run on a TM will in
fact be run the same on an RTM.
the differences in RTMs only come up in computations that aren't
directly expressible on TMs
the TM limitation is mechanical, not computational. classical theory
only supposes about computational limitations, there's no notion of
mechanical limitation.
Are you talking about analog computation with continuous quantities,
and such?
no
So your pencil-and-paper calculations are actually perhaps geometric,
like compass-and-ruler derivations?
r u intentionally trying to be obtuse?
but the mechanical, not computational, limitation means:
- TMs can simulate RTMs
- RTMs don't fix the problems with TMs
- it doesn't matter that they don't because RTMs can compute
everything TMs do + have increased power
If TMs can simulate RTMs then they do not have increased power.
no. TMs have the computational power to handle what RTMs compute ... but
the lack of the REFLECT operation mechanically limits them from
dependable access to the required runtime information to actually be
RTMs directly.
this relationship just can't be pigeonholed into what u'd like, you are overgeneralizing
this doesn't solve TM limitation because again the problem is TMs lack mechanical access to not be limited. RTMs instead *trivialize* the TM halting problem because RTMs can express everything TMs + overcome
attempts at constructing semantic paradoxes with RTMs.
They may have increased "expressive power", which is something only
relevant to how "nice" they are to write applications in.
A different Turing model can also have better efficiency; i.e the best
way of solving a problem in one kind of machine may have exponential
time whereas another can express a solution that is polynomial.
Since
- ugly code that correctly solves a problem halts,
- inefficient code that correctly solves a problem halts,
neither expressive power nor efficiency are relevant in halting.
what i'm doing is trivializing TMs undecidability, not resolving it. but >>> this overall resolves the halting problem by providing a mechanical
improvement that can allow theory to escape limitations stemming from
the liar's paradox being encoded into machines
(If you want to talk Olcott, /that/'s a great narrative:
"halting problem implies liar paradox.")
REFLECT gives a semantic decider the ability to know it's calling
context, which gives it the ability to return a context dependent
answer.
If you find some computational model with contexts which is
effective,
but beyond Turing, then /that/ is the big deal; delegate the halting >>>>>> cruft to others. You are important because you've done what nobody >>>>>> else
has done before: you found an effective method of computation that is >>>>>> not Turing! So you go to conference sall over the world where you are >>>>>> flocked by groupies. Fuck halting, at that point, you know?
it's a mild extension of TMs,
If it is mechanically demonstrable with pen and paper, then it isn't
an extension of TM.
no idea what u mean here, TMs are likewise also demonstrable with a pen
and paper, and that was turing's original justification for their
feasibility
(What I mean that it's just TM, and not an extension.)
Functions can depend on their context. That context can make some
instances of them halting and others not, even with all the explicit
arguments being the same. Thus we cannot ask whether a function halts; >>>> it has to be, does it halt /in what calling context/.
only if it involves a REFLECT command, otherwise it's not possible to be >>> dependent on context.
So if only deciders are allowed to use REFLECT, but the inputs
are not allowed to use REFLECT, then indeed it is impossible for an
input to contradict a decider which uses REFLECT.
But then deciders are not deciding everything; they are deciding
only those inputs that don't use REFLECT.
inputs are allowed to use REFLECT. this doesn't make it possible to construct a halting paradox because it does not stop deciders from
using /false/ to escape any demonstrable paradox.
On 2025-11-02, olcott <[email protected]> wrote:
On 11/2/2025 2:57 PM, Tristan Wibberley wrote:
[ ... whatever ... ]That seems to show a pretty good depth of understanding.
I'm picturing a bunch of flat earthers sitting around a table,
acknowledging the new guy.
"Yes Dave, you got it! Ships fall off the earth when they go over the horizon. Your depth of understanding is superb!"
On 02/11/2025 19:10, Richard Damon wrote:
So, how does the machine write out information that it doesn't have stored?
A TM (at least typically) has a current machine state from a finite list
of machine states, a reflecting extension can be defined to have a representation for each that it writes out upon interpreting a symbol at
the tape head for each machine state (or for a subset of machine states,
etc) instead of a simple move-left or move-right.
For clarity I think dart200 is talking about an extended TM, extended to
have one or more machine-state write-out transitions defined.
For additional clarity, "machine state" does not normally refer to the
tape contents nor to the current tape-cell index but the state of the
machine (like register values, for machines defined to have those). You
can't include the tape cell index in the machine state because then it
would have an infinite number of machine states. I understand that would
not be a TM, strictly.
--
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.
On 11/2/25 11:10 AM, Richard Damon wrote:
On 11/1/25 12:37 PM, dart200 wrote:
On 11/1/25 6:19 AM, Richard Damon wrote:
On 11/1/25 2:18 AM, dart200 wrote:
On 10/31/25 9:33 PM, Richard Damon wrote:
On 10/31/25 11:52 PM, dart200 wrote:
On 10/31/25 8:33 PM, Richard Damon wrote:
On 10/31/25 11:16 PM, dart200 wrote:
On 10/31/25 7:59 PM, Richard Damon wrote:
On 10/31/25 3:29 PM, dart200 wrote:
On 10/31/25 9:18 AM, Richard Damon wrote:
On 10/30/25 2:27 PM, dart200 wrote:
On 10/29/25 8:42 PM, olcott wrote:
On 10/29/2025 10:23 PM, dart200 wrote:
On 10/29/25 6:45 PM, Richard Damon wrote:
On 10/29/25 12:24 PM, dart200 wrote:TMs with a modification, specifically adding full >>>>>>>>>>>>>>> mechanical reflection to TMs in order to produce >>>>>>>>>>>>>>> Reflective TMs (RTMs)
On 10/29/25 4:29 AM, Richard Damon wrote:
On 10/28/25 11:23 PM, dart200 wrote:blatant lie
On 10/28/25 6:55 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 10/28/25 9:41 PM, dart200 wrote:
On 10/28/25 6:34 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/28/2025 5:43 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>> [...]
not my argument u fucking useless boomer >>>>>>>>>>>>>>>>>>>>>>Well, how do you solve the halting problem? >>>>>>>>>>>>>>>>>>>>>>
with reflection, something u lack as a useless >>>>>>>>>>>>>>>>>>>>> fucking boomer
Which you can't say how to do, because your only >>>>>>>>>>>>>>>>>>>> answer is to define that you can.
we haven't even gotten the point of working out the >>>>>>>>>>>>>>>>>>> ramifications of what i've defined,
Because you haven't actually defined what you are doing. >>>>>>>>>>>>>>>>>
Really, show where you have ACTUALLY fully defined your >>>>>>>>>>>>>>>> computation machine to a level you can actually analyize >>>>>>>>>>>>>>>> one.
adding full mechanical reflection just means it gets a >>>>>>>>>>>>>>> single instruction that dumps *all* this information to >>>>>>>>>>>>>>> the tape, at the head, when that instruction is called: >>>>>>>>>>>>>>>
1) machine description
2) initial tape state
3) current instruction
4) current tape state
call it REFLECT, if u will... this information allows a >>>>>>>>>>>>>>> computation to know exactly where it is in the overall >>>>>>>>>>>>>>> runtime of computation, and with that it can subvert >>>>>>>>>>>>>>> semantic paradoxes like the halting problem.
you have to understand this is a *mechanical*
modification to turing machines, not a computational one. >>>>>>>>>>>>>>> much like how RTMs can move a head left/right, or write >>>>>>>>>>>>>>> 0/1 to the tape ... they mechanically just do this >>>>>>>>>>>>>>> operation when the instruction is called.
*these mechanics are (relatively) simple and self- >>>>>>>>>>>>>>> evidentially possible and therefore mathematically >>>>>>>>>>>>>>> feasible.*
BUT, let me try a step deeper, and quote turing at you >>>>>>>>>>>>>>> from his original paper on computable numbers:
/We may compare a man in the process of computing a real >>>>>>>>>>>>>>> number to a
machine which is only capable of a finite number of >>>>>>>>>>>>>>> conditions/ [Tur36]
THE ENTIRE JUSTIFICATION FOR TURING MACHINES RESTS >>>>>>>>>>>>>>> SQUARELY ON THE NOTION OF "CAN A MAN MECHANICALLY >>>>>>>>>>>>>>> UNDERTAKE THESE STATE TRANSITIONS"
1) if a man is running thru the steps of a computation, >>>>>>>>>>>>>>> then obviously he has access the full machine
description, or how else the fuck is he doing any of >>>>>>>>>>>>>>> these state transitions??? therefore he obviously can >>>>>>>>>>>>>>> dump the machine description, in whatever format he has >>>>>>>>>>>>>>> it in, to the tape when REFLECT is encountered.
2) if a man is running thru the steps of a computation, >>>>>>>>>>>>>>> then obviously he can to the side save the initial tape >>>>>>>>>>>>>>> in a "buffer" that than cannot be overwritten. with that >>>>>>>>>>>>>>> he can can obviously dump the initial tape state to the >>>>>>>>>>>>>>> tape whenever REFLECT is encountered.
3) if a man is running thru the steps of a computation, >>>>>>>>>>>>>>> then obviously he has access input of a particular >>>>>>>>>>>>>>> transition, and therefore can dump that input to the tape >>>>>>>>>>>>>>> when REFLECT is encountered, in whatever format he >>>>>>>>>>>>>>> encounters it in.
4) if a man is running thru the steps of a
computation ... he can obviously duplicate the tape when >>>>>>>>>>>>>>> REFLECT is called. or more precisely he can save it into >>>>>>>>>>>>>>> a buffer, and dump from the buffer after putting 1-3 on >>>>>>>>>>>>>>> the tape.
THAT IS THE SAME LEVEL OF FORMAT JUSTIFICATION TURING >>>>>>>>>>>>>>> ULTIMATELY GIVES FOR ANY COMPUTING MACHINE. SERIOUSLY >>>>>>>>>>>>>>> READ HIS FUCKING ESSAY YOU DORK
please tell me where u are confused, not how u think i'm >>>>>>>>>>>>>>> wrong
I can finally see the gist of what you are saying
and it seems to be very similar to my idea.
like i've said polcott, i consider you having a half-way >>>>>>>>>>>>> solution. u have something that's executable for sure, and >>>>>>>>>>>>> that is a definite improvement over total undecidability. >>>>>>>>>>>>>
but it's not totally epistemically useful, it still >>>>>>>>>>>>> doesn't / effectively compute/ the halting function in a >>>>>>>>>>>>> *general* manner.
i'm proposing something that's both executable *and* >>>>>>>>>>>>> epistemically useful for that purpose.
the RTM i'm proposing here is just the underlying
theoretical mechanisms that can be used to produce a >>>>>>>>>>>>> theoretically coherent context-dependent decider,
which can then be used to /effectively compute/ the halting >>>>>>>>>>>>> function irrespective of semantic paradoxes ...
something that is in total a step beyond the mere
executability that you are proposing.
No, the problem you have is that you make the same error and >>>>>>>>>>>> try to redefine the question, and allow your machine to give >>>>>>>>>>>> wrong answers.
it's not a "wrong" answer if it contains no information to be >>>>>>>>>>> wrong about, and it's only given in a situation where there's >>>>>>>>>>> no "right" answer.
But their is a right answer for every actual D based on every >>>>>>>>>> actual H.
It just isn't the answer that H gives.
Because deciders are just deterministic processes with a fixed >>>>>>>>>> algorithm.
how is it reasonable to expect a decider to respond
truthfully to a situation that would only make that truth untrue >>>>>>>>>>
right, and context can be an input to the determinism
console.trace() isn't nondeterministic, it's context dependent >>>>>>>>>
Note, the system DOES understand that some problems turn out >>>>>>>>>> to be uncomputable, so no decider exists that can be correct >>>>>>>>>> for all inputs. Nothing wrong with that, it just means that >>>>>>>>>> any decider that wants to try to claim to solve it will be >>>>>>>>>> wrong for some input.
The key point here is the question can't be asked until after >>>>>>>>>> a decider steps up to make the claim, as the prove-it-wrong >>>>>>>>>> input is different for every possible decider, and thus, by >>>>>>>>>> the time the question can be asked, the deciders result for >>>>>>>>>> that input was already determined by its algorithm. For the >>>>>>>>>> decider it isn't a matter of being "truthful", it is just >>>>>>>>>> doing what it was programmed to do.
It becomes a matter of correctness, not truthfulness.
It is the creator of the algoritm to which truthfulness is >>>>>>>>>> applied, and claiming that it will give the right answer when >>>>>>>>>> it doesn't shows that his claim wasn't truthful.
there's no "correct" answer to a pathological question of
halts(und) on this line:
und = () -> halts(und) && loop_forever()
Which isn't a computation if your symbology means that halts is >>>>>>>> taken from the context that the symbol und is used in.
Sorry, you are just showing you don't know the meaning of the >>>>>>>> words.
and the resolution is just to give a non-answer, so i split the >>>>>>>>> decider into two halves and made false a non-answer. it cannot >>>>>>>>> be a contradiction because it doesn't give information /in that >>>>>>>>> moment/ about und() to contradict.
But since you are starting with the same category error of
Olcott, you get the same nonsense he does.
The category for the input to a Halt Decider is the
representation of a Computation.
By DEFINITION, this has a FULLY defined algorithm, and thus NOT >>>>>>>> a closure.
If you want to try to define your own theory of computation that >>>>>>>> uses a broader defintion, go ahead, the problem is you will find >>>>>>>> you can do litle with it, and that the semantic paradox you are >>>>>>>> complaining about is totally due to you altered definition of a >>>>>>>> computation.
right why do u keep asserting ur existential fuckup is more
correct than a working decider on the matter???
Because it doesn't give the right answer per the original problem.
it gives you the right answer in all the places that the
information of that answer is actually usable, and it does so
generally.
In other words, your logic says it is ok to be wrong in some cases,
if you can give a "good excuse" why it is ok to be wrong there.
All that does is destroy the meaning of "Correct".
you are holding onto some notion of wanting a "right" answer where
no right answer can exist, and that's just bizarre because with
that desire u lose the ability to generally get a "right" answer in >>>>> first place.
Because it *DOES* have a proper definition.
ALWAYS means ALWAYS, not just where I want it.
i can't believe ur a chief engineer asking for correctness where
a) it has no practical usecase
b) it ends up neutering ur theoretical ability to generally handle
the problem
ur demanding to be able to shoot urself in ur foot over some decider
that can't even exist.
weird fetish bro
I guess you just think that lies are valid, and truth doesn't matter.
Note, a real halt decider, if it existed, would have a LOT of actually
practical uses, and the fact it can't exist is important knowledge.
ur throwing the fucking baby out with the bathwater dude,
it's fucking stupid
Nope, because for actual problems like Busy Beaver, which again asks
about for results from ALL possible machihes with specific criteria,
that pattern might just coencidentally occur.
If you want to be clear that you aren't working on that problem,
or even working under that system, go ahead, just make sure you
fully define what you are doing and try to show where it is useful. >>>>>>
i'm not building a separate form of computing, i'm upgrading what
we have
In other words, you are admitting you are lying.
It is a VIOLATION of the meaning of the words to change the meaning
of the word as already used.
You "upgrade" a system by adding new ideas without removing or
changing any of the old.
If you need to remove or change something, you have a new system.
DEFINITION.
like adding a new operation BY DEFINITION???
Sure, it it can't be done within the limits of the previously defined
system.
honestly idk if ur just in denial, too senior to take criticism
anymore, or just shoved a stick too far ur butthole,
Nope, it is just sticking up for truth against stupid people who don't
understand what they are talking about.
but suggesting i'm not changing anything when i've spent pages trying
to define a very particular change, even given it's a label RTM is
just completely disingenuous of you.
So, how does the machine write out information that it doesn't have
stored?
i'm insulted at the lack of consideration i'm getting here, clearly u
have no willingness to engaging in genuine discussion, cause ur just
blatantly lying about my position.
Then you are being insulted by your own errors.
YOU are the one who has decided not to engage in answering question
put to you to explain.
how can u offer me any meaningful feedback if ur just gunna blatantly
lie about my position???
What LIE have I said?
To show that what I have said can't be done, just needs a showing how
you claim it actually could be done within the restrictions of the
framework you are in.
Part of your problem, is it seems you haven't bothered to learn what
the frameworks actually is.
Again, all you are doing is admitting that you system is based on
you claiming the right to lie about what you are doing, by ignoring
the rules of the system.
yes this does mean maybe /false/ could be returned everywhere, >>>>>>>>> but that's not fucking interesting ... nor does it give /
effective computability/ in regards to the halting question.
Since your input is a category error for the actual Computation >>>>>>>> Theory as classical defined, your results don't apply.
classic computing theory doesn't have a halt decider defined
tho ... u only have a halting function, not a decider. the
decider is *disproven* and therefore cannot be defined as per
consensus theory.
u fucking retard.
u keep asserting SOMETHING THAT DOESN'T EVEN EXIST is somehow
more correct than SOMETHING THAT CAN EXIST
The DEFINITION of a Halting Decider exists.
The fact that the definiton is not realizable, proves the theory.
To call something a Halt Decider that doesn't meet the definition, >>>>>> is just a lie, making the person making the claim just a liar.
just like there's more than one way to ask the same question,
there's more than one way to define a halting decider, which is the >>>>> interface into an algorithm, not the algorithm itself.
Right, but if they are semantically different, it isn't the same
question.
the one i'm proposing can actually generally exist, unlike the
classical definition.
But only is a Computation System that is broken, because programs
don't reliable produce the same answer when run.
Once you allow things to lie, you have destroyed the concept of truth. >>>>
it's really that simple.
Yes, allowing lying seems simple until you need to count on something. >>>>
NO YOU HAVEN'T.
ur special pleading is just so mindnumbingly boring. i DEFINED my
We can easily DEFINE things that don't exist.>
which is the point of the context-dependent decider. halts() is >>>>>>>>> required to return /true/ only whereever both /possible/ and / >>>>>>>>> truthful/ to do so.
So, if you want to try to talk about this, you first need to try >>>>>>>> to develop a basic theory about context dependent Computations, >>>>>>>> to see if it can actually be useful for anything.
i fucking already did. u just aren't reading cause ur too busy
trying to show off how big a fucking retard u can be.
No you haven't, unless you consider your claim that is the
equivalent of defining that 1 == 2 is a definition.
DESCRIBING what you want to do is NOT the same as DEFINING how to >>>>>> do it.
mechanics in MORE detail that turing did his, and yet u arbitrarily >>>>> reject it as "describing" which seems like a made up distinction here. >>>>
You have PRESUMED an ability on the machine that can not actually be
implemented on it without breaking it.
i'm intelligent enough to write down the machine description to the
tape when i see the operation REFLECT, and therefore accept the
defined ability
But is it the RIGHT machine description for the program in question?
And where does it get the contents of the original tape?
i get that ur apparently too fucking retarded to do that, and
therefore don't accept it.
Nope, it seems you are too retarded to actually think about what other
say about your system. You suffer from the fallacy that you assume you
are right and thus ignore the definitions of what you are talking about.
Your "Definition" is the equivalent of defining that for this work,
I will consider 1 to be equal to 2.
sometimes i really do feel like just buying a gun a shooting
myself, cause i really am stuck on a planet of fucking idiots.
y must u endlessly torture me so with ur fucking idiocracy?
I could say the same to you. Why are you so stuck on insisting on
things that are not.
Computations, as defined, can't change their answers for the same
input. PERIOD.
To insist they can is just to admit you are just a lunatic.
right, printing stack traces actually isn't part of computing. every
time we step thru debugging we're doing theoretically indescribable
magic, according to richard
And what does that have to do with what I said?
And yes, a routine looking at who called it is NOT part of "Computing"
per computation theory, as it can't matter.
It seems part of your problem is you don't actually know what you are
talking about.
Remember, Computing isn't directly about "Computers" as we currently
know them, but is more fundamental.
It seems you have forgotten that "Computing" as a term existed BEFORE
the computers you want to talk about.
blows my mind that u think a computing function that prints a stack
trace does something which cannot be done on and explained by a turing machine
i'm not sure y u think this mindnumbing gishgallop u shit out is worth a continued response to
can u explain what my argument even is?
or are you basically just a fucking chatbot keying off one sentence at a time?
On 02/11/2025 19:10, Richard Damon wrote:
So, how does the machine write out information that it doesn't have stored?
A TM (at least typically) has a current machine state from a finite list
of machine states, a reflecting extension can be defined to have a representation for each that it writes out upon interpreting a symbol at
the tape head for each machine state (or for a subset of machine states,
etc) instead of a simple move-left or move-right.
For clarity I think dart200 is talking about an extended TM, extended to
have one or more machine-state write-out transitions defined.
For additional clarity, "machine state" does not normally refer to the
tape contents nor to the current tape-cell index but the state of the
machine (like register values, for machines defined to have those). You
can't include the tape cell index in the machine state because then it
would have an infinite number of machine states. I understand that would
not be a TM, strictly.
--
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.
On 11/2/25 12:57 PM, Tristan Wibberley wrote:
On 02/11/2025 19:10, Richard Damon wrote:
So, how does the machine write out information that it doesn't have
stored?
A TM (at least typically) has a current machine state from a finite list
of machine states, a reflecting extension can be defined to have a
representation for each that it writes out upon interpreting a symbol at
the tape head for each machine state (or for a subset of machine states,
etc) instead of a simple move-left or move-right.
For clarity I think dart200 is talking about an extended TM, extended to
have one or more machine-state write-out transitions defined.
For additional clarity, "machine state" does not normally refer to the
tape contents nor to the current tape-cell index but the state of the
machine (like register values, for machines defined to have those). You
can't include the tape cell index in the machine state because then it
would have an infinite number of machine states. I understand that would
not be a TM, strictly.
further more RTMs themselves don't just then solve the halting problem.
RTMs allow for context-aware computing, which we can use to propose a context-aware decider, that can proactively avoid succumbing to semantic paradoxes
G0 = () -> {
if ( halts(G0) ) // false, as true would cause input to loop
loop_forever()
if ( loops(G0) ) // false, as true would cause input to halt
halt
if ( halts(G0) ) // true, as input does halt
print "halts!"
if ( loops(G0) ) // false, as input does not loop
print "does not halt!"
halt
}
--
Tristan Wibberley
ur not a boomer eh?
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.
On 11/1/25 1:26 PM, Kaz Kylheku wrote:
On 2025-11-01, dart200 <[email protected]d> wrote:
On 11/1/25 9:37 AM, Kaz Kylheku wrote:
On 2025-11-01, dart200 <[email protected]d> wrote:
On 10/31/25 9:20 PM, Kaz Kylheku wrote:
On 2025-11-01, dart200 <[email protected]d> wrote:
there's no "correct" answer to a pathological question of
halts(und) on
this line:
und = () -> halts(und) && loop_forever()
Yes there is; the correct answer is ¬halts(und). The logical negation >>>>>> of whatever halts(und) decides.
the correct answer is to give the opposite of it's own answer???
The correct answer isn't /to give/ anything; it just /is/
halts() is a total decider, ur now just ignoring what i defined()
I'm obviously aware of how you defined it.
If you initially impose the definition "halts is the name of a total
decider", then you arrive at a contradiction: halts cannot be
deciding und, as required of a total decider.
So then, the definition is a kind of proposition, which is shown false;
it does not hold.
But what is the logical opposite of the proposition "halts is the name
of a total decider?" It is not: "halts does not exist", but simply:
"halts is /not/ the name of a total decider".
A halts can exist just fine, just not as a total decider.
Stop insisting that halts is a the total halting decider which cannot
exist, allowing it to be a partial halting decider which cannot be
total, and the apparent paradox goes away. und then exists and has a >>>> defnite halting status, which is opposite to whatever that partial
decider says.
great now ur arguing polcott is right.
Not really; he has never agreed with the above!
he might not agree with the wording, but it is kinda what he's proposing
the problem with a set of partial deciders is that the resolution isn't
/effectively computable/. with "partial" deciders then the question
becomes which partial decider is correct: u've just kicked the can down
the road
Yes; because no combination of partial deciders gives you a total
decider.
We can trivially form a set of partial deciders which has complete
coverage:
H_0 := (P) -> 0
H_1 := (P) -> 1
H_0 correctly decides all non-terminating inputs. H_1 correctly
decides all terminating inputs. So one of these two is always
correct! (Notice how I'm not saying anything more informative
than "a machine always halts or does not halt").
We don't know which decider is the right one for which input.
We need a third decider H whch decides whether to use H_0
or H_1.
This example may look silly: because what is H, but simply
a decider which has to determine whether to returh 0 or 1
(which are only trivially disguised as H_0(P) and H_1(P))?
But this idea generalizes. No matter what kind of partial deciders we
have, or how many, deciding which one is correct for which input is
equivalent to deciding halting.
The result of combining partial deciders will always be a decider
that can be shown not to be total.
The can is indeed always kicked down the road.
great! so ur own answered question of why i'm not particularly excited
by partial deciders, and want a way to /effectively compute/ whether an input machine halts not
do we need to have this discussion again kaz, or???
yes this does mean maybe /false/ could be returned everywhere, but >>>>>>> that's not fucking interesting ... nor does it give /effective
computability/ in regards to the halting question.
which is the point of the context-dependent decider. halts() is >>>>>>> required
to return /true/ only whereever both /possible/ and /truthful/ to >>>>>>> do so.
if u don't agree with this, that's fine...
but you actually need to construct a contradiction, you can't just >>>>>>> continually make bare assertions that it's a contradiction.
If contexts are represenable in a Turing substrate, then everything >>>>>> succumbs to Turing incomputability of halting.
If contexts are not representable in Turing, then the
model-with-contexts is either effectievely computable non-Turing, or >>>>>> else contexts are just imaginary, like magic oracles.
false dichotomy
Well, trichotomy, by my count.
- contexts are Turing (1)
- contexts are not Turing:
- somehow effectively computable (2)
- not computable (3)
What possibility have I unintentionally left out?
like i'm even open to being wrong, but like u need to work with the
system in order to show a contradiction with the system itself,
just not
assume the contradiction will happen.
If they are imaginary, you only have a thought experiment.
(In which Turing-plus-contexts machines can decide Turing
halting, but so what?)
REFLECT is completely mechanically demonstrable operation with a
pen and
paper, i demonstrated it in a post here already, justifying it's
theoretical existence
OK, that points to it being embeddable in Turing
computation. Which then points to undecidabiity.
or ur just assuming a false dichotomy
If your mechanical pencil-and-paper calculations are shown to be Turing,
anything rendered using those calculations is Turing. It is not
a dichotomy, true or false.
what i'm proposing obviously will look very much like TMs in many if not most computatation. in fact: any computation can run on a TM will in
fact be run the same on an RTM.
the differences in RTMs only come up in computations that aren't
directly expressible on TMs
the TM limitation is mechanical, not computational. classical theory
only supposes about computational limitations, there's no notion of
mechanical limitation.
Are you talking about analog computation with continuous quantities,
and such?
no
So your pencil-and-paper calculations are actually perhaps geometric,
like compass-and-ruler derivations?
r u intentionally trying to be obtuse?
but the mechanical, not computational, limitation means:
- TMs can simulate RTMs
- RTMs don't fix the problems with TMs
- it doesn't matter that they don't because RTMs can compute
everything TMs do + have increased power
If TMs can simulate RTMs then they do not have increased power.
no. TMs have the computational power to handle what RTMs compute ... but
the lack of the REFLECT operation mechanically limits them from
dependable access to the required runtime information to actually be
RTMs directly.
this relationship just can't be pigeonholed into what u'd like, you are overgeneralizing
this doesn't solve TM limitation because again the problem is TMs lack mechanical access to not be limited. RTMs instead *trivialize* the TM halting problem because RTMs can express everything TMs + overcome
attempts at constructing semantic paradoxes with RTMs.
They may have increased "expressive power", which is something only
relevant to how "nice" they are to write applications in.
A different Turing model can also have better efficiency; i.e the best
way of solving a problem in one kind of machine may have exponential
time whereas another can express a solution that is polynomial.
Since
- ugly code that correctly solves a problem halts,
- inefficient code that correctly solves a problem halts,
neither expressive power nor efficiency are relevant in halting.
what i'm doing is trivializing TMs undecidability, not resolving it. but >>> this overall resolves the halting problem by providing a mechanical
improvement that can allow theory to escape limitations stemming from
the liar's paradox being encoded into machines
(If you want to talk Olcott, /that/'s a great narrative:
"halting problem implies liar paradox.")
REFLECT gives a semantic decider the ability to know it's calling
context, which gives it the ability to return a context dependent
answer.
If you find some computational model with contexts which is
effective,
but beyond Turing, then /that/ is the big deal; delegate the halting >>>>>> cruft to others. You are important because you've done what nobody >>>>>> else
has done before: you found an effective method of computation that is >>>>>> not Turing! So you go to conference sall over the world where you are >>>>>> flocked by groupies. Fuck halting, at that point, you know?
it's a mild extension of TMs,
If it is mechanically demonstrable with pen and paper, then it isn't
an extension of TM.
no idea what u mean here, TMs are likewise also demonstrable with a pen
and paper, and that was turing's original justification for their
feasibility
(What I mean that it's just TM, and not an extension.)
Functions can depend on their context. That context can make some
instances of them halting and others not, even with all the explicit
arguments being the same. Thus we cannot ask whether a function halts; >>>> it has to be, does it halt /in what calling context/.
only if it involves a REFLECT command, otherwise it's not possible to be >>> dependent on context.
So if only deciders are allowed to use REFLECT, but the inputs
are not allowed to use REFLECT, then indeed it is impossible for an
input to contradict a decider which uses REFLECT.
But then deciders are not deciding everything; they are deciding
only those inputs that don't use REFLECT.
inputs are allowed to use REFLECT. this doesn't make it possible to construct a halting paradox because it does not stop deciders from
using /false/ to escape any demonstrable paradox.
On 11/2/25 3:45 PM, dart200 wrote:
On 11/2/25 11:10 AM, Richard Damon wrote:
On 11/1/25 12:37 PM, dart200 wrote:
On 11/1/25 6:19 AM, Richard Damon wrote:
On 11/1/25 2:18 AM, dart200 wrote:
On 10/31/25 9:33 PM, Richard Damon wrote:
On 10/31/25 11:52 PM, dart200 wrote:it gives you the right answer in all the places that the
On 10/31/25 8:33 PM, Richard Damon wrote:
On 10/31/25 11:16 PM, dart200 wrote:
On 10/31/25 7:59 PM, Richard Damon wrote:
On 10/31/25 3:29 PM, dart200 wrote:
On 10/31/25 9:18 AM, Richard Damon wrote:
On 10/30/25 2:27 PM, dart200 wrote:
On 10/29/25 8:42 PM, olcott wrote:
On 10/29/2025 10:23 PM, dart200 wrote:
On 10/29/25 6:45 PM, Richard Damon wrote:
On 10/29/25 12:24 PM, dart200 wrote:TMs with a modification, specifically adding full >>>>>>>>>>>>>>>> mechanical reflection to TMs in order to produce >>>>>>>>>>>>>>>> Reflective TMs (RTMs)
On 10/29/25 4:29 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 10/28/25 11:23 PM, dart200 wrote:
blatant lieOn 10/28/25 6:55 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 10/28/25 9:41 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/28/25 6:34 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>>>>>>>> On 10/28/2025 5:43 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>> [...]
not my argument u fucking useless boomer >>>>>>>>>>>>>>>>>>>>>>>Well, how do you solve the halting problem? >>>>>>>>>>>>>>>>>>>>>>>
with reflection, something u lack as a useless >>>>>>>>>>>>>>>>>>>>>> fucking boomer
Which you can't say how to do, because your only >>>>>>>>>>>>>>>>>>>>> answer is to define that you can.
we haven't even gotten the point of working out the >>>>>>>>>>>>>>>>>>>> ramifications of what i've defined,
Because you haven't actually defined what you are doing. >>>>>>>>>>>>>>>>>>
Really, show where you have ACTUALLY fully defined your >>>>>>>>>>>>>>>>> computation machine to a level you can actually >>>>>>>>>>>>>>>>> analyize one.
adding full mechanical reflection just means it gets a >>>>>>>>>>>>>>>> single instruction that dumps *all* this information to >>>>>>>>>>>>>>>> the tape, at the head, when that instruction is called: >>>>>>>>>>>>>>>>
1) machine description
2) initial tape state
3) current instruction
4) current tape state
call it REFLECT, if u will... this information allows a >>>>>>>>>>>>>>>> computation to know exactly where it is in the overall >>>>>>>>>>>>>>>> runtime of computation, and with that it can subvert >>>>>>>>>>>>>>>> semantic paradoxes like the halting problem.
you have to understand this is a *mechanical* >>>>>>>>>>>>>>>> modification to turing machines, not a computational >>>>>>>>>>>>>>>> one. much like how RTMs can move a head left/right, or >>>>>>>>>>>>>>>> write 0/1 to the tape ... they mechanically just do this >>>>>>>>>>>>>>>> operation when the instruction is called.
*these mechanics are (relatively) simple and self- >>>>>>>>>>>>>>>> evidentially possible and therefore mathematically >>>>>>>>>>>>>>>> feasible.*
BUT, let me try a step deeper, and quote turing at you >>>>>>>>>>>>>>>> from his original paper on computable numbers: >>>>>>>>>>>>>>>>
/We may compare a man in the process of computing a real >>>>>>>>>>>>>>>> number to a
machine which is only capable of a finite number of >>>>>>>>>>>>>>>> conditions/ [Tur36]
THE ENTIRE JUSTIFICATION FOR TURING MACHINES RESTS >>>>>>>>>>>>>>>> SQUARELY ON THE NOTION OF "CAN A MAN MECHANICALLY >>>>>>>>>>>>>>>> UNDERTAKE THESE STATE TRANSITIONS"
1) if a man is running thru the steps of a computation, >>>>>>>>>>>>>>>> then obviously he has access the full machine >>>>>>>>>>>>>>>> description, or how else the fuck is he doing any of >>>>>>>>>>>>>>>> these state transitions??? therefore he obviously can >>>>>>>>>>>>>>>> dump the machine description, in whatever format he has >>>>>>>>>>>>>>>> it in, to the tape when REFLECT is encountered. >>>>>>>>>>>>>>>>
2) if a man is running thru the steps of a computation, >>>>>>>>>>>>>>>> then obviously he can to the side save the initial tape >>>>>>>>>>>>>>>> in a "buffer" that than cannot be overwritten. with that >>>>>>>>>>>>>>>> he can can obviously dump the initial tape state to the >>>>>>>>>>>>>>>> tape whenever REFLECT is encountered.
3) if a man is running thru the steps of a computation, >>>>>>>>>>>>>>>> then obviously he has access input of a particular >>>>>>>>>>>>>>>> transition, and therefore can dump that input to the >>>>>>>>>>>>>>>> tape when REFLECT is encountered, in whatever format he >>>>>>>>>>>>>>>> encounters it in.
4) if a man is running thru the steps of a
computation ... he can obviously duplicate the tape when >>>>>>>>>>>>>>>> REFLECT is called. or more precisely he can save it into >>>>>>>>>>>>>>>> a buffer, and dump from the buffer after putting 1-3 on >>>>>>>>>>>>>>>> the tape.
THAT IS THE SAME LEVEL OF FORMAT JUSTIFICATION TURING >>>>>>>>>>>>>>>> ULTIMATELY GIVES FOR ANY COMPUTING MACHINE. SERIOUSLY >>>>>>>>>>>>>>>> READ HIS FUCKING ESSAY YOU DORK
please tell me where u are confused, not how u think i'm >>>>>>>>>>>>>>>> wrong
I can finally see the gist of what you are saying >>>>>>>>>>>>>>> and it seems to be very similar to my idea.
like i've said polcott, i consider you having a half-way >>>>>>>>>>>>>> solution. u have something that's executable for sure, and >>>>>>>>>>>>>> that is a definite improvement over total undecidability. >>>>>>>>>>>>>>
but it's not totally epistemically useful, it still >>>>>>>>>>>>>> doesn't / effectively compute/ the halting function in a >>>>>>>>>>>>>> *general* manner.
i'm proposing something that's both executable *and* >>>>>>>>>>>>>> epistemically useful for that purpose.
the RTM i'm proposing here is just the underlying >>>>>>>>>>>>>> theoretical mechanisms that can be used to produce a >>>>>>>>>>>>>> theoretically coherent context-dependent decider,
which can then be used to /effectively compute/ the >>>>>>>>>>>>>> halting function irrespective of semantic paradoxes ... >>>>>>>>>>>>>>
something that is in total a step beyond the mere >>>>>>>>>>>>>> executability that you are proposing.
No, the problem you have is that you make the same error >>>>>>>>>>>>> and try to redefine the question, and allow your machine to >>>>>>>>>>>>> give wrong answers.
it's not a "wrong" answer if it contains no information to >>>>>>>>>>>> be wrong about, and it's only given in a situation where >>>>>>>>>>>> there's no "right" answer.
But their is a right answer for every actual D based on every >>>>>>>>>>> actual H.
It just isn't the answer that H gives.
how is it reasonable to expect a decider to respond
truthfully to a situation that would only make that truth >>>>>>>>>>>> untrue
Because deciders are just deterministic processes with a >>>>>>>>>>> fixed algorithm.
right, and context can be an input to the determinism
console.trace() isn't nondeterministic, it's context dependent >>>>>>>>>>
Note, the system DOES understand that some problems turn out >>>>>>>>>>> to be uncomputable, so no decider exists that can be correct >>>>>>>>>>> for all inputs. Nothing wrong with that, it just means that >>>>>>>>>>> any decider that wants to try to claim to solve it will be >>>>>>>>>>> wrong for some input.
The key point here is the question can't be asked until after >>>>>>>>>>> a decider steps up to make the claim, as the prove-it-wrong >>>>>>>>>>> input is different for every possible decider, and thus, by >>>>>>>>>>> the time the question can be asked, the deciders result for >>>>>>>>>>> that input was already determined by its algorithm. For the >>>>>>>>>>> decider it isn't a matter of being "truthful", it is just >>>>>>>>>>> doing what it was programmed to do.
It becomes a matter of correctness, not truthfulness.
It is the creator of the algoritm to which truthfulness is >>>>>>>>>>> applied, and claiming that it will give the right answer when >>>>>>>>>>> it doesn't shows that his claim wasn't truthful.
there's no "correct" answer to a pathological question of >>>>>>>>>> halts(und) on this line:
und = () -> halts(und) && loop_forever()
Which isn't a computation if your symbology means that halts is >>>>>>>>> taken from the context that the symbol und is used in.
Sorry, you are just showing you don't know the meaning of the >>>>>>>>> words.
and the resolution is just to give a non-answer, so i split >>>>>>>>>> the decider into two halves and made false a non-answer. it >>>>>>>>>> cannot be a contradiction because it doesn't give
information /in that moment/ about und() to contradict.
But since you are starting with the same category error of
Olcott, you get the same nonsense he does.
The category for the input to a Halt Decider is the
representation of a Computation.
By DEFINITION, this has a FULLY defined algorithm, and thus NOT >>>>>>>>> a closure.
If you want to try to define your own theory of computation >>>>>>>>> that uses a broader defintion, go ahead, the problem is you >>>>>>>>> will find you can do litle with it, and that the semantic
paradox you are complaining about is totally due to you altered >>>>>>>>> definition of a computation.
right why do u keep asserting ur existential fuckup is more
correct than a working decider on the matter???
Because it doesn't give the right answer per the original problem. >>>>>>
information of that answer is actually usable, and it does so
generally.
In other words, your logic says it is ok to be wrong in some cases, >>>>> if you can give a "good excuse" why it is ok to be wrong there.
All that does is destroy the meaning of "Correct".
you are holding onto some notion of wanting a "right" answer where >>>>>> no right answer can exist, and that's just bizarre because with
that desire u lose the ability to generally get a "right" answer
in first place.
Because it *DOES* have a proper definition.
ALWAYS means ALWAYS, not just where I want it.
i can't believe ur a chief engineer asking for correctness where
a) it has no practical usecase
b) it ends up neutering ur theoretical ability to generally handle
the problem
ur demanding to be able to shoot urself in ur foot over some decider
that can't even exist.
weird fetish bro
I guess you just think that lies are valid, and truth doesn't matter.
Note, a real halt decider, if it existed, would have a LOT of
actually practical uses, and the fact it can't exist is important
knowledge.
ur throwing the fucking baby out with the bathwater dude,
it's fucking stupid
Nope, because for actual problems like Busy Beaver, which again
asks about for results from ALL possible machihes with specific
criteria, that pattern might just coencidentally occur.
If you want to be clear that you aren't working on that problem, >>>>>>> or even working under that system, go ahead, just make sure you >>>>>>> fully define what you are doing and try to show where it is useful. >>>>>>>
i'm not building a separate form of computing, i'm upgrading what >>>>>> we have
In other words, you are admitting you are lying.
It is a VIOLATION of the meaning of the words to change the meaning >>>>> of the word as already used.
You "upgrade" a system by adding new ideas without removing or
changing any of the old.
If you need to remove or change something, you have a new system.
DEFINITION.
like adding a new operation BY DEFINITION???
Sure, it it can't be done within the limits of the previously defined
system.
honestly idk if ur just in denial, too senior to take criticism
anymore, or just shoved a stick too far ur butthole,
Nope, it is just sticking up for truth against stupid people who
don't understand what they are talking about.
but suggesting i'm not changing anything when i've spent pages
trying to define a very particular change, even given it's a label
RTM is just completely disingenuous of you.
So, how does the machine write out information that it doesn't have
stored?
i'm insulted at the lack of consideration i'm getting here, clearly
u have no willingness to engaging in genuine discussion, cause ur
just blatantly lying about my position.
Then you are being insulted by your own errors.
YOU are the one who has decided not to engage in answering question
put to you to explain.
how can u offer me any meaningful feedback if ur just gunna
blatantly lie about my position???
What LIE have I said?
To show that what I have said can't be done, just needs a showing how
you claim it actually could be done within the restrictions of the
framework you are in.
Part of your problem, is it seems you haven't bothered to learn what
the frameworks actually is.
Again, all you are doing is admitting that you system is based on
you claiming the right to lie about what you are doing, by ignoring >>>>> the rules of the system.
Since your input is a category error for the actual Computation >>>>>>>>> Theory as classical defined, your results don't apply.
yes this does mean maybe /false/ could be returned everywhere, >>>>>>>>>> but that's not fucking interesting ... nor does it give / >>>>>>>>>> effective computability/ in regards to the halting question. >>>>>>>>>
classic computing theory doesn't have a halt decider defined
tho ... u only have a halting function, not a decider. the
decider is *disproven* and therefore cannot be defined as per >>>>>>>> consensus theory.
u fucking retard.
u keep asserting SOMETHING THAT DOESN'T EVEN EXIST is somehow >>>>>>>> more correct than SOMETHING THAT CAN EXIST
The DEFINITION of a Halting Decider exists.
The fact that the definiton is not realizable, proves the theory. >>>>>>>
To call something a Halt Decider that doesn't meet the
definition, is just a lie, making the person making the claim
just a liar.
just like there's more than one way to ask the same question,
there's more than one way to define a halting decider, which is
the interface into an algorithm, not the algorithm itself.
Right, but if they are semantically different, it isn't the same
question.
the one i'm proposing can actually generally exist, unlike the
classical definition.
But only is a Computation System that is broken, because programs
don't reliable produce the same answer when run.
Once you allow things to lie, you have destroyed the concept of truth. >>>>>
it's really that simple.
Yes, allowing lying seems simple until you need to count on something. >>>>>
ur special pleading is just so mindnumbingly boring. i DEFINED my >>>>>> mechanics in MORE detail that turing did his, and yet u
We can easily DEFINE things that don't exist.>
i fucking already did. u just aren't reading cause ur too busy >>>>>>>> trying to show off how big a fucking retard u can be.
which is the point of the context-dependent decider. halts() >>>>>>>>>> is required to return /true/ only whereever both /possible/ >>>>>>>>>> and / truthful/ to do so.
So, if you want to try to talk about this, you first need to >>>>>>>>> try to develop a basic theory about context dependent
Computations, to see if it can actually be useful for anything. >>>>>>>>
No you haven't, unless you consider your claim that is the
equivalent of defining that 1 == 2 is a definition.
DESCRIBING what you want to do is NOT the same as DEFINING how to >>>>>>> do it.
arbitrarily reject it as "describing" which seems like a made up
distinction here.
NO YOU HAVEN'T.
You have PRESUMED an ability on the machine that can not actually
be implemented on it without breaking it.
i'm intelligent enough to write down the machine description to the
tape when i see the operation REFLECT, and therefore accept the
defined ability
But is it the RIGHT machine description for the program in question?
And where does it get the contents of the original tape?
i get that ur apparently too fucking retarded to do that, and
therefore don't accept it.
Nope, it seems you are too retarded to actually think about what
other say about your system. You suffer from the fallacy that you
assume you are right and thus ignore the definitions of what you are
talking about.
Your "Definition" is the equivalent of defining that for this work, >>>>> I will consider 1 to be equal to 2.
sometimes i really do feel like just buying a gun a shooting
myself, cause i really am stuck on a planet of fucking idiots.
y must u endlessly torture me so with ur fucking idiocracy?
I could say the same to you. Why are you so stuck on insisting on
things that are not.
Computations, as defined, can't change their answers for the same
input. PERIOD.
To insist they can is just to admit you are just a lunatic.
right, printing stack traces actually isn't part of computing. every
time we step thru debugging we're doing theoretically indescribable
magic, according to richard
And what does that have to do with what I said?
And yes, a routine looking at who called it is NOT part of
"Computing" per computation theory, as it can't matter.
It seems part of your problem is you don't actually know what you are
talking about.
Remember, Computing isn't directly about "Computers" as we currently
know them, but is more fundamental.
It seems you have forgotten that "Computing" as a term existed BEFORE
the computers you want to talk about.
blows my mind that u think a computing function that prints a stack
trace does something which cannot be done on and explained by a turing
machine
Well, try to define a Turing Machinne that does that.
Your first problem will be that Turing Machines don't have a stack to dump.
i'm not sure y u think this mindnumbing gishgallop u shit out is worth
a continued response to
can u explain what my argument even is?
or are you basically just a fucking chatbot keying off one sentence at
a time?
No, but it seems you are just a idiot that refuses to learn the meaning
of the words you are using.
As I have pointed out several times, trying to relate a "Computation"
per COmputation Theory to behavior of modern computers is just an error.
On 11/2/25 8:08 PM, Richard Damon wrote:
On 11/2/25 3:45 PM, dart200 wrote:
On 11/2/25 11:10 AM, Richard Damon wrote:
On 11/1/25 12:37 PM, dart200 wrote:
On 11/1/25 6:19 AM, Richard Damon wrote:
On 11/1/25 2:18 AM, dart200 wrote:
On 10/31/25 9:33 PM, Richard Damon wrote:
On 10/31/25 11:52 PM, dart200 wrote:it gives you the right answer in all the places that the
On 10/31/25 8:33 PM, Richard Damon wrote:
On 10/31/25 11:16 PM, dart200 wrote:
On 10/31/25 7:59 PM, Richard Damon wrote:
On 10/31/25 3:29 PM, dart200 wrote:
On 10/31/25 9:18 AM, Richard Damon wrote:
On 10/30/25 2:27 PM, dart200 wrote:
On 10/29/25 8:42 PM, olcott wrote:
On 10/29/2025 10:23 PM, dart200 wrote:
On 10/29/25 6:45 PM, Richard Damon wrote:
On 10/29/25 12:24 PM, dart200 wrote:TMs with a modification, specifically adding full >>>>>>>>>>>>>>>>> mechanical reflection to TMs in order to produce >>>>>>>>>>>>>>>>> Reflective TMs (RTMs)
On 10/29/25 4:29 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 10/28/25 11:23 PM, dart200 wrote:
On 10/28/25 6:55 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/28/25 9:41 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>> On 10/28/25 6:34 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 10/28/2025 5:43 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>>> [...]
not my argument u fucking useless boomer >>>>>>>>>>>>>>>>>>>>>>>>Well, how do you solve the halting problem? >>>>>>>>>>>>>>>>>>>>>>>>
with reflection, something u lack as a useless >>>>>>>>>>>>>>>>>>>>>>> fucking boomer
Which you can't say how to do, because your only >>>>>>>>>>>>>>>>>>>>>> answer is to define that you can.
we haven't even gotten the point of working out the >>>>>>>>>>>>>>>>>>>>> ramifications of what i've defined,
Because you haven't actually defined what you are >>>>>>>>>>>>>>>>>>>> doing.
blatant lie
Really, show where you have ACTUALLY fully defined >>>>>>>>>>>>>>>>>> your computation machine to a level you can actually >>>>>>>>>>>>>>>>>> analyize one.
adding full mechanical reflection just means it gets a >>>>>>>>>>>>>>>>> single instruction that dumps *all* this information to >>>>>>>>>>>>>>>>> the tape, at the head, when that instruction is called: >>>>>>>>>>>>>>>>>
1) machine description
2) initial tape state
3) current instruction
4) current tape state
call it REFLECT, if u will... this information allows a >>>>>>>>>>>>>>>>> computation to know exactly where it is in the overall >>>>>>>>>>>>>>>>> runtime of computation, and with that it can subvert >>>>>>>>>>>>>>>>> semantic paradoxes like the halting problem. >>>>>>>>>>>>>>>>>
you have to understand this is a *mechanical* >>>>>>>>>>>>>>>>> modification to turing machines, not a computational >>>>>>>>>>>>>>>>> one. much like how RTMs can move a head left/right, or >>>>>>>>>>>>>>>>> write 0/1 to the tape ... they mechanically just do >>>>>>>>>>>>>>>>> this operation when the instruction is called. >>>>>>>>>>>>>>>>>
*these mechanics are (relatively) simple and self- >>>>>>>>>>>>>>>>> evidentially possible and therefore mathematically >>>>>>>>>>>>>>>>> feasible.*
BUT, let me try a step deeper, and quote turing at you >>>>>>>>>>>>>>>>> from his original paper on computable numbers: >>>>>>>>>>>>>>>>>
/We may compare a man in the process of computing a >>>>>>>>>>>>>>>>> real number to a
machine which is only capable of a finite number of >>>>>>>>>>>>>>>>> conditions/ [Tur36]
THE ENTIRE JUSTIFICATION FOR TURING MACHINES RESTS >>>>>>>>>>>>>>>>> SQUARELY ON THE NOTION OF "CAN A MAN MECHANICALLY >>>>>>>>>>>>>>>>> UNDERTAKE THESE STATE TRANSITIONS"
1) if a man is running thru the steps of a computation, >>>>>>>>>>>>>>>>> then obviously he has access the full machine >>>>>>>>>>>>>>>>> description, or how else the fuck is he doing any of >>>>>>>>>>>>>>>>> these state transitions??? therefore he obviously can >>>>>>>>>>>>>>>>> dump the machine description, in whatever format he has >>>>>>>>>>>>>>>>> it in, to the tape when REFLECT is encountered. >>>>>>>>>>>>>>>>>
2) if a man is running thru the steps of a computation, >>>>>>>>>>>>>>>>> then obviously he can to the side save the initial tape >>>>>>>>>>>>>>>>> in a "buffer" that than cannot be overwritten. with >>>>>>>>>>>>>>>>> that he can can obviously dump the initial tape state >>>>>>>>>>>>>>>>> to the tape whenever REFLECT is encountered. >>>>>>>>>>>>>>>>>
3) if a man is running thru the steps of a computation, >>>>>>>>>>>>>>>>> then obviously he has access input of a particular >>>>>>>>>>>>>>>>> transition, and therefore can dump that input to the >>>>>>>>>>>>>>>>> tape when REFLECT is encountered, in whatever format he >>>>>>>>>>>>>>>>> encounters it in.
4) if a man is running thru the steps of a
computation ... he can obviously duplicate the tape >>>>>>>>>>>>>>>>> when REFLECT is called. or more precisely he can save >>>>>>>>>>>>>>>>> it into a buffer, and dump from the buffer after >>>>>>>>>>>>>>>>> putting 1-3 on the tape.
THAT IS THE SAME LEVEL OF FORMAT JUSTIFICATION TURING >>>>>>>>>>>>>>>>> ULTIMATELY GIVES FOR ANY COMPUTING MACHINE. SERIOUSLY >>>>>>>>>>>>>>>>> READ HIS FUCKING ESSAY YOU DORK
please tell me where u are confused, not how u think >>>>>>>>>>>>>>>>> i'm wrong
I can finally see the gist of what you are saying >>>>>>>>>>>>>>>> and it seems to be very similar to my idea.
like i've said polcott, i consider you having a half-way >>>>>>>>>>>>>>> solution. u have something that's executable for sure, >>>>>>>>>>>>>>> and that is a definite improvement over total
undecidability.
but it's not totally epistemically useful, it still >>>>>>>>>>>>>>> doesn't / effectively compute/ the halting function in a >>>>>>>>>>>>>>> *general* manner.
i'm proposing something that's both executable *and* >>>>>>>>>>>>>>> epistemically useful for that purpose.
the RTM i'm proposing here is just the underlying >>>>>>>>>>>>>>> theoretical mechanisms that can be used to produce a >>>>>>>>>>>>>>> theoretically coherent context-dependent decider, >>>>>>>>>>>>>>>
which can then be used to /effectively compute/ the >>>>>>>>>>>>>>> halting function irrespective of semantic paradoxes ... >>>>>>>>>>>>>>>
something that is in total a step beyond the mere >>>>>>>>>>>>>>> executability that you are proposing.
No, the problem you have is that you make the same error >>>>>>>>>>>>>> and try to redefine the question, and allow your machine >>>>>>>>>>>>>> to give wrong answers.
it's not a "wrong" answer if it contains no information to >>>>>>>>>>>>> be wrong about, and it's only given in a situation where >>>>>>>>>>>>> there's no "right" answer.
But their is a right answer for every actual D based on >>>>>>>>>>>> every actual H.
It just isn't the answer that H gives.
how is it reasonable to expect a decider to respond >>>>>>>>>>>>> truthfully to a situation that would only make that truth >>>>>>>>>>>>> untrue
Because deciders are just deterministic processes with a >>>>>>>>>>>> fixed algorithm.
right, and context can be an input to the determinism
console.trace() isn't nondeterministic, it's context dependent >>>>>>>>>>>
Note, the system DOES understand that some problems turn out >>>>>>>>>>>> to be uncomputable, so no decider exists that can be correct >>>>>>>>>>>> for all inputs. Nothing wrong with that, it just means that >>>>>>>>>>>> any decider that wants to try to claim to solve it will be >>>>>>>>>>>> wrong for some input.
The key point here is the question can't be asked until >>>>>>>>>>>> after a decider steps up to make the claim, as the prove-it- >>>>>>>>>>>> wrong input is different for every possible decider, and >>>>>>>>>>>> thus, by the time the question can be asked, the deciders >>>>>>>>>>>> result for that input was already determined by its
algorithm. For the decider it isn't a matter of being >>>>>>>>>>>> "truthful", it is just doing what it was programmed to do. >>>>>>>>>>>>
It becomes a matter of correctness, not truthfulness.
It is the creator of the algoritm to which truthfulness is >>>>>>>>>>>> applied, and claiming that it will give the right answer >>>>>>>>>>>> when it doesn't shows that his claim wasn't truthful.
there's no "correct" answer to a pathological question of >>>>>>>>>>> halts(und) on this line:
und = () -> halts(und) && loop_forever()
Which isn't a computation if your symbology means that halts >>>>>>>>>> is taken from the context that the symbol und is used in.
Sorry, you are just showing you don't know the meaning of the >>>>>>>>>> words.
and the resolution is just to give a non-answer, so i split >>>>>>>>>>> the decider into two halves and made false a non-answer. it >>>>>>>>>>> cannot be a contradiction because it doesn't give
information /in that moment/ about und() to contradict.
But since you are starting with the same category error of >>>>>>>>>> Olcott, you get the same nonsense he does.
The category for the input to a Halt Decider is the
representation of a Computation.
By DEFINITION, this has a FULLY defined algorithm, and thus >>>>>>>>>> NOT a closure.
If you want to try to define your own theory of computation >>>>>>>>>> that uses a broader defintion, go ahead, the problem is you >>>>>>>>>> will find you can do litle with it, and that the semantic >>>>>>>>>> paradox you are complaining about is totally due to you
altered definition of a computation.
right why do u keep asserting ur existential fuckup is more >>>>>>>>> correct than a working decider on the matter???
Because it doesn't give the right answer per the original problem. >>>>>>>
information of that answer is actually usable, and it does so
generally.
In other words, your logic says it is ok to be wrong in some
cases, if you can give a "good excuse" why it is ok to be wrong
there.
All that does is destroy the meaning of "Correct".
you are holding onto some notion of wanting a "right" answer
where no right answer can exist, and that's just bizarre because >>>>>>> with that desire u lose the ability to generally get a "right"
answer in first place.
Because it *DOES* have a proper definition.
ALWAYS means ALWAYS, not just where I want it.
i can't believe ur a chief engineer asking for correctness where
a) it has no practical usecase
b) it ends up neutering ur theoretical ability to generally handle
the problem
ur demanding to be able to shoot urself in ur foot over some
decider that can't even exist.
weird fetish bro
I guess you just think that lies are valid, and truth doesn't matter.
Note, a real halt decider, if it existed, would have a LOT of
actually practical uses, and the fact it can't exist is important
knowledge.
ur throwing the fucking baby out with the bathwater dude,
it's fucking stupid
Nope, because for actual problems like Busy Beaver, which again
asks about for results from ALL possible machihes with specific
criteria, that pattern might just coencidentally occur.
If you want to be clear that you aren't working on that problem, >>>>>>>> or even working under that system, go ahead, just make sure you >>>>>>>> fully define what you are doing and try to show where it is useful. >>>>>>>>
i'm not building a separate form of computing, i'm upgrading what >>>>>>> we have
In other words, you are admitting you are lying.
It is a VIOLATION of the meaning of the words to change the
meaning of the word as already used.
You "upgrade" a system by adding new ideas without removing or
changing any of the old.
If you need to remove or change something, you have a new system. >>>>>> DEFINITION.
like adding a new operation BY DEFINITION???
Sure, it it can't be done within the limits of the previously
defined system.
honestly idk if ur just in denial, too senior to take criticism
anymore, or just shoved a stick too far ur butthole,
Nope, it is just sticking up for truth against stupid people who
don't understand what they are talking about.
but suggesting i'm not changing anything when i've spent pages
trying to define a very particular change, even given it's a label
RTM is just completely disingenuous of you.
So, how does the machine write out information that it doesn't have
stored?
i'm insulted at the lack of consideration i'm getting here, clearly >>>>> u have no willingness to engaging in genuine discussion, cause ur
just blatantly lying about my position.
Then you are being insulted by your own errors.
YOU are the one who has decided not to engage in answering question
put to you to explain.
how can u offer me any meaningful feedback if ur just gunna
blatantly lie about my position???
What LIE have I said?
To show that what I have said can't be done, just needs a showing
how you claim it actually could be done within the restrictions of
the framework you are in.
Part of your problem, is it seems you haven't bothered to learn what
the frameworks actually is.
Again, all you are doing is admitting that you system is based on >>>>>> you claiming the right to lie about what you are doing, by
ignoring the rules of the system.
yes this does mean maybe /false/ could be returned
everywhere, but that's not fucking interesting ... nor does >>>>>>>>>>> it give / effective computability/ in regards to the halting >>>>>>>>>>> question.
Since your input is a category error for the actual
Computation Theory as classical defined, your results don't >>>>>>>>>> apply.
classic computing theory doesn't have a halt decider defined >>>>>>>>> tho ... u only have a halting function, not a decider. the
decider is *disproven* and therefore cannot be defined as per >>>>>>>>> consensus theory.
u fucking retard.
u keep asserting SOMETHING THAT DOESN'T EVEN EXIST is somehow >>>>>>>>> more correct than SOMETHING THAT CAN EXIST
The DEFINITION of a Halting Decider exists.
The fact that the definiton is not realizable, proves the theory. >>>>>>>>
To call something a Halt Decider that doesn't meet the
definition, is just a lie, making the person making the claim >>>>>>>> just a liar.
just like there's more than one way to ask the same question,
there's more than one way to define a halting decider, which is >>>>>>> the interface into an algorithm, not the algorithm itself.
Right, but if they are semantically different, it isn't the same
question.
the one i'm proposing can actually generally exist, unlike the
classical definition.
But only is a Computation System that is broken, because programs >>>>>> don't reliable produce the same answer when run.
Once you allow things to lie, you have destroyed the concept of
truth.
it's really that simple.
Yes, allowing lying seems simple until you need to count on
something.
ur special pleading is just so mindnumbingly boring. i DEFINED my >>>>>>> mechanics in MORE detail that turing did his, and yet u
We can easily DEFINE things that don't exist.>
i fucking already did. u just aren't reading cause ur too busy >>>>>>>>> trying to show off how big a fucking retard u can be.
which is the point of the context-dependent decider. halts() >>>>>>>>>>> is required to return /true/ only whereever both /possible/ >>>>>>>>>>> and / truthful/ to do so.
So, if you want to try to talk about this, you first need to >>>>>>>>>> try to develop a basic theory about context dependent
Computations, to see if it can actually be useful for anything. >>>>>>>>>
No you haven't, unless you consider your claim that is the
equivalent of defining that 1 == 2 is a definition.
DESCRIBING what you want to do is NOT the same as DEFINING how >>>>>>>> to do it.
arbitrarily reject it as "describing" which seems like a made up >>>>>>> distinction here.
NO YOU HAVEN'T.
You have PRESUMED an ability on the machine that can not actually >>>>>> be implemented on it without breaking it.
i'm intelligent enough to write down the machine description to the >>>>> tape when i see the operation REFLECT, and therefore accept the
defined ability
But is it the RIGHT machine description for the program in question?
And where does it get the contents of the original tape?
i get that ur apparently too fucking retarded to do that, and
therefore don't accept it.
Nope, it seems you are too retarded to actually think about what
other say about your system. You suffer from the fallacy that you
assume you are right and thus ignore the definitions of what you are
talking about.
Your "Definition" is the equivalent of defining that for this
work, I will consider 1 to be equal to 2.
sometimes i really do feel like just buying a gun a shooting
myself, cause i really am stuck on a planet of fucking idiots.
y must u endlessly torture me so with ur fucking idiocracy?
I could say the same to you. Why are you so stuck on insisting on >>>>>> things that are not.
Computations, as defined, can't change their answers for the same >>>>>> input. PERIOD.
To insist they can is just to admit you are just a lunatic.
right, printing stack traces actually isn't part of computing.
every time we step thru debugging we're doing theoretically
indescribable magic, according to richard
And what does that have to do with what I said?
And yes, a routine looking at who called it is NOT part of
"Computing" per computation theory, as it can't matter.
It seems part of your problem is you don't actually know what you
are talking about.
Remember, Computing isn't directly about "Computers" as we currently
know them, but is more fundamental.
It seems you have forgotten that "Computing" as a term existed
BEFORE the computers you want to talk about.
blows my mind that u think a computing function that prints a stack
trace does something which cannot be done on and explained by a
turing machine
Well, try to define a Turing Machinne that does that.
Your first problem will be that Turing Machines don't have a stack to
dump.
i'm not sure y u think this mindnumbing gishgallop u shit out is
worth a continued response to
can u explain what my argument even is?
or are you basically just a fucking chatbot keying off one sentence
at a time?
No, but it seems you are just a idiot that refuses to learn the
meaning of the words you are using.
As I have pointed out several times, trying to relate a "Computation"
per COmputation Theory to behavior of modern computers is just an error.
well, that's just fucking retarded.
do you honestly think the behavior exhibiting within modern computing somehow exists outside the theory of computing???
On 11/2/25 3:57 PM, Tristan Wibberley wrote:
On 02/11/2025 19:10, Richard Damon wrote:
So, how does the machine write out information that it doesn't have
stored?
A TM (at least typically) has a current machine state from a finite list
of machine states, a reflecting extension can be defined to have a
representation for each that it writes out upon interpreting a symbol at
the tape head for each machine state (or for a subset of machine states,
etc) instead of a simple move-left or move-right.
But their isn't a unique representation for that, and what good is
dumping the information in a format that the program doesn't expect.
And dumping the code isn't the biggest problem, although it does mean
such a Turing Macine no longer has the property of always being a computation under the operation of composition of sub-proggrams.
The bigger issue is recovering the inital tape as defined.
For clarity I think dart200 is talking about an extended TM, extended to
have one or more machine-state write-out transitions defined.
And such an extended machine means it fails to have the essential
property of a standard Turing Machine of all programs and subprograms designed for it are actual computations.
That property is what make it a computation machine.>
For additional clarity, "machine state" does not normally refer to the
tape contents nor to the current tape-cell index but the state of the
machine (like register values, for machines defined to have those). You
can't include the tape cell index in the machine state because then it
would have an infinite number of machine states. I understand that would
not be a TM, strictly.
--
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.
On 11/2/25 11:42 PM, dart200 wrote:
On 11/2/25 8:08 PM, Richard Damon wrote:
On 11/2/25 3:45 PM, dart200 wrote:
On 11/2/25 11:10 AM, Richard Damon wrote:
On 11/1/25 12:37 PM, dart200 wrote:
On 11/1/25 6:19 AM, Richard Damon wrote:
On 11/1/25 2:18 AM, dart200 wrote:
On 10/31/25 9:33 PM, Richard Damon wrote:
On 10/31/25 11:52 PM, dart200 wrote:it gives you the right answer in all the places that the
On 10/31/25 8:33 PM, Richard Damon wrote:
On 10/31/25 11:16 PM, dart200 wrote:
On 10/31/25 7:59 PM, Richard Damon wrote:
On 10/31/25 3:29 PM, dart200 wrote:
On 10/31/25 9:18 AM, Richard Damon wrote:
On 10/30/25 2:27 PM, dart200 wrote:
On 10/29/25 8:42 PM, olcott wrote:
On 10/29/2025 10:23 PM, dart200 wrote:
On 10/29/25 6:45 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 10/29/25 12:24 PM, dart200 wrote:
TMs with a modification, specifically adding full >>>>>>>>>>>>>>>>>> mechanical reflection to TMs in order to produce >>>>>>>>>>>>>>>>>> Reflective TMs (RTMs)On 10/29/25 4:29 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 10/28/25 11:23 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/28/25 6:55 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 10/28/25 9:41 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 10/28/25 6:34 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 10/28/2025 5:43 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>>>> [...]
Because you haven't actually defined what you are >>>>>>>>>>>>>>>>>>>>> doing.we haven't even gotten the point of working out >>>>>>>>>>>>>>>>>>>>>> the ramifications of what i've defined, >>>>>>>>>>>>>>>>>>>>>not my argument u fucking useless boomer >>>>>>>>>>>>>>>>>>>>>>>>>Well, how do you solve the halting problem? >>>>>>>>>>>>>>>>>>>>>>>>>
with reflection, something u lack as a useless >>>>>>>>>>>>>>>>>>>>>>>> fucking boomer
Which you can't say how to do, because your only >>>>>>>>>>>>>>>>>>>>>>> answer is to define that you can. >>>>>>>>>>>>>>>>>>>>>>
blatant lie
Really, show where you have ACTUALLY fully defined >>>>>>>>>>>>>>>>>>> your computation machine to a level you can actually >>>>>>>>>>>>>>>>>>> analyize one.
adding full mechanical reflection just means it gets a >>>>>>>>>>>>>>>>>> single instruction that dumps *all* this information >>>>>>>>>>>>>>>>>> to the tape, at the head, when that instruction is >>>>>>>>>>>>>>>>>> called:
1) machine description
2) initial tape state
3) current instruction
4) current tape state
call it REFLECT, if u will... this information allows >>>>>>>>>>>>>>>>>> a computation to know exactly where it is in the >>>>>>>>>>>>>>>>>> overall runtime of computation, and with that it can >>>>>>>>>>>>>>>>>> subvert semantic paradoxes like the halting problem. >>>>>>>>>>>>>>>>>>
you have to understand this is a *mechanical* >>>>>>>>>>>>>>>>>> modification to turing machines, not a computational >>>>>>>>>>>>>>>>>> one. much like how RTMs can move a head left/right, or >>>>>>>>>>>>>>>>>> write 0/1 to the tape ... they mechanically just do >>>>>>>>>>>>>>>>>> this operation when the instruction is called. >>>>>>>>>>>>>>>>>>
*these mechanics are (relatively) simple and self- >>>>>>>>>>>>>>>>>> evidentially possible and therefore mathematically >>>>>>>>>>>>>>>>>> feasible.*
BUT, let me try a step deeper, and quote turing at you >>>>>>>>>>>>>>>>>> from his original paper on computable numbers: >>>>>>>>>>>>>>>>>>
/We may compare a man in the process of computing a >>>>>>>>>>>>>>>>>> real number to a
machine which is only capable of a finite number of >>>>>>>>>>>>>>>>>> conditions/ [Tur36]
THE ENTIRE JUSTIFICATION FOR TURING MACHINES RESTS >>>>>>>>>>>>>>>>>> SQUARELY ON THE NOTION OF "CAN A MAN MECHANICALLY >>>>>>>>>>>>>>>>>> UNDERTAKE THESE STATE TRANSITIONS"
1) if a man is running thru the steps of a >>>>>>>>>>>>>>>>>> computation, then obviously he has access the full >>>>>>>>>>>>>>>>>> machine description, or how else the fuck is he doing >>>>>>>>>>>>>>>>>> any of these state transitions??? therefore he >>>>>>>>>>>>>>>>>> obviously can dump the machine description, in >>>>>>>>>>>>>>>>>> whatever format he has it in, to the tape when REFLECT >>>>>>>>>>>>>>>>>> is encountered.
2) if a man is running thru the steps of a >>>>>>>>>>>>>>>>>> computation, then obviously he can to the side save >>>>>>>>>>>>>>>>>> the initial tape in a "buffer" that than cannot be >>>>>>>>>>>>>>>>>> overwritten. with that he can can obviously dump the >>>>>>>>>>>>>>>>>> initial tape state to the tape whenever REFLECT is >>>>>>>>>>>>>>>>>> encountered.
3) if a man is running thru the steps of a >>>>>>>>>>>>>>>>>> computation, then obviously he has access input of a >>>>>>>>>>>>>>>>>> particular transition, and therefore can dump that >>>>>>>>>>>>>>>>>> input to the tape when REFLECT is encountered, in >>>>>>>>>>>>>>>>>> whatever format he encounters it in.
4) if a man is running thru the steps of a >>>>>>>>>>>>>>>>>> computation ... he can obviously duplicate the tape >>>>>>>>>>>>>>>>>> when REFLECT is called. or more precisely he can save >>>>>>>>>>>>>>>>>> it into a buffer, and dump from the buffer after >>>>>>>>>>>>>>>>>> putting 1-3 on the tape.
THAT IS THE SAME LEVEL OF FORMAT JUSTIFICATION TURING >>>>>>>>>>>>>>>>>> ULTIMATELY GIVES FOR ANY COMPUTING MACHINE. SERIOUSLY >>>>>>>>>>>>>>>>>> READ HIS FUCKING ESSAY YOU DORK
please tell me where u are confused, not how u think >>>>>>>>>>>>>>>>>> i'm wrong
I can finally see the gist of what you are saying >>>>>>>>>>>>>>>>> and it seems to be very similar to my idea.
like i've said polcott, i consider you having a half-way >>>>>>>>>>>>>>>> solution. u have something that's executable for sure, >>>>>>>>>>>>>>>> and that is a definite improvement over total >>>>>>>>>>>>>>>> undecidability.
but it's not totally epistemically useful, it still >>>>>>>>>>>>>>>> doesn't / effectively compute/ the halting function in a >>>>>>>>>>>>>>>> *general* manner.
i'm proposing something that's both executable *and* >>>>>>>>>>>>>>>> epistemically useful for that purpose.
the RTM i'm proposing here is just the underlying >>>>>>>>>>>>>>>> theoretical mechanisms that can be used to produce a >>>>>>>>>>>>>>>> theoretically coherent context-dependent decider, >>>>>>>>>>>>>>>>
which can then be used to /effectively compute/ the >>>>>>>>>>>>>>>> halting function irrespective of semantic paradoxes ... >>>>>>>>>>>>>>>>
something that is in total a step beyond the mere >>>>>>>>>>>>>>>> executability that you are proposing.
No, the problem you have is that you make the same error >>>>>>>>>>>>>>> and try to redefine the question, and allow your machine >>>>>>>>>>>>>>> to give wrong answers.
it's not a "wrong" answer if it contains no information to >>>>>>>>>>>>>> be wrong about, and it's only given in a situation where >>>>>>>>>>>>>> there's no "right" answer.
But their is a right answer for every actual D based on >>>>>>>>>>>>> every actual H.
It just isn't the answer that H gives.
how is it reasonable to expect a decider to respond >>>>>>>>>>>>>> truthfully to a situation that would only make that truth >>>>>>>>>>>>>> untrue
Because deciders are just deterministic processes with a >>>>>>>>>>>>> fixed algorithm.
right, and context can be an input to the determinism
console.trace() isn't nondeterministic, it's context dependent >>>>>>>>>>>>
Note, the system DOES understand that some problems turn >>>>>>>>>>>>> out to be uncomputable, so no decider exists that can be >>>>>>>>>>>>> correct for all inputs. Nothing wrong with that, it just >>>>>>>>>>>>> means that any decider that wants to try to claim to solve >>>>>>>>>>>>> it will be wrong for some input.
The key point here is the question can't be asked until >>>>>>>>>>>>> after a decider steps up to make the claim, as the prove- >>>>>>>>>>>>> it- wrong input is different for every possible decider, >>>>>>>>>>>>> and thus, by the time the question can be asked, the >>>>>>>>>>>>> deciders result for that input was already determined by >>>>>>>>>>>>> its algorithm. For the decider it isn't a matter of being >>>>>>>>>>>>> "truthful", it is just doing what it was programmed to do. >>>>>>>>>>>>>
It becomes a matter of correctness, not truthfulness. >>>>>>>>>>>>>
It is the creator of the algoritm to which truthfulness is >>>>>>>>>>>>> applied, and claiming that it will give the right answer >>>>>>>>>>>>> when it doesn't shows that his claim wasn't truthful. >>>>>>>>>>>>>
there's no "correct" answer to a pathological question of >>>>>>>>>>>> halts(und) on this line:
und = () -> halts(und) && loop_forever()
Which isn't a computation if your symbology means that halts >>>>>>>>>>> is taken from the context that the symbol und is used in. >>>>>>>>>>>
Sorry, you are just showing you don't know the meaning of the >>>>>>>>>>> words.
But since you are starting with the same category error of >>>>>>>>>>> Olcott, you get the same nonsense he does.
and the resolution is just to give a non-answer, so i split >>>>>>>>>>>> the decider into two halves and made false a non-answer. it >>>>>>>>>>>> cannot be a contradiction because it doesn't give
information /in that moment/ about und() to contradict. >>>>>>>>>>>
The category for the input to a Halt Decider is the
representation of a Computation.
By DEFINITION, this has a FULLY defined algorithm, and thus >>>>>>>>>>> NOT a closure.
If you want to try to define your own theory of computation >>>>>>>>>>> that uses a broader defintion, go ahead, the problem is you >>>>>>>>>>> will find you can do litle with it, and that the semantic >>>>>>>>>>> paradox you are complaining about is totally due to you >>>>>>>>>>> altered definition of a computation.
right why do u keep asserting ur existential fuckup is more >>>>>>>>>> correct than a working decider on the matter???
Because it doesn't give the right answer per the original problem. >>>>>>>>
information of that answer is actually usable, and it does so >>>>>>>> generally.
In other words, your logic says it is ok to be wrong in some
cases, if you can give a "good excuse" why it is ok to be wrong >>>>>>> there.
All that does is destroy the meaning of "Correct".
you are holding onto some notion of wanting a "right" answer
where no right answer can exist, and that's just bizarre because >>>>>>>> with that desire u lose the ability to generally get a "right" >>>>>>>> answer in first place.
Because it *DOES* have a proper definition.
ALWAYS means ALWAYS, not just where I want it.
i can't believe ur a chief engineer asking for correctness where
a) it has no practical usecase
b) it ends up neutering ur theoretical ability to generally handle >>>>>> the problem
ur demanding to be able to shoot urself in ur foot over some
decider that can't even exist.
weird fetish bro
I guess you just think that lies are valid, and truth doesn't matter. >>>>>
Note, a real halt decider, if it existed, would have a LOT of
actually practical uses, and the fact it can't exist is important
knowledge.
ur throwing the fucking baby out with the bathwater dude,
it's fucking stupid
Nope, because for actual problems like Busy Beaver, which again >>>>>>> asks about for results from ALL possible machihes with specific >>>>>>> criteria, that pattern might just coencidentally occur.
If you want to be clear that you aren't working on that
problem, or even working under that system, go ahead, just make >>>>>>>>> sure you fully define what you are doing and try to show where >>>>>>>>> it is useful.
i'm not building a separate form of computing, i'm upgrading
what we have
In other words, you are admitting you are lying.
It is a VIOLATION of the meaning of the words to change the
meaning of the word as already used.
You "upgrade" a system by adding new ideas without removing or
changing any of the old.
If you need to remove or change something, you have a new system. >>>>>>> DEFINITION.
like adding a new operation BY DEFINITION???
Sure, it it can't be done within the limits of the previously
defined system.
honestly idk if ur just in denial, too senior to take criticism
anymore, or just shoved a stick too far ur butthole,
Nope, it is just sticking up for truth against stupid people who
don't understand what they are talking about.
but suggesting i'm not changing anything when i've spent pages
trying to define a very particular change, even given it's a label >>>>>> RTM is just completely disingenuous of you.
So, how does the machine write out information that it doesn't have >>>>> stored?
i'm insulted at the lack of consideration i'm getting here,
clearly u have no willingness to engaging in genuine discussion,
cause ur just blatantly lying about my position.
Then you are being insulted by your own errors.
YOU are the one who has decided not to engage in answering question >>>>> put to you to explain.
how can u offer me any meaningful feedback if ur just gunna
blatantly lie about my position???
What LIE have I said?
To show that what I have said can't be done, just needs a showing
how you claim it actually could be done within the restrictions of
the framework you are in.
Part of your problem, is it seems you haven't bothered to learn
what the frameworks actually is.
Again, all you are doing is admitting that you system is based on >>>>>>> you claiming the right to lie about what you are doing, by
ignoring the rules of the system.
yes this does mean maybe /false/ could be returned
everywhere, but that's not fucking interesting ... nor does >>>>>>>>>>>> it give / effective computability/ in regards to the halting >>>>>>>>>>>> question.
Since your input is a category error for the actual
Computation Theory as classical defined, your results don't >>>>>>>>>>> apply.
classic computing theory doesn't have a halt decider defined >>>>>>>>>> tho ... u only have a halting function, not a decider. the >>>>>>>>>> decider is *disproven* and therefore cannot be defined as per >>>>>>>>>> consensus theory.
u fucking retard.
u keep asserting SOMETHING THAT DOESN'T EVEN EXIST is somehow >>>>>>>>>> more correct than SOMETHING THAT CAN EXIST
The DEFINITION of a Halting Decider exists.
The fact that the definiton is not realizable, proves the theory. >>>>>>>>>
To call something a Halt Decider that doesn't meet the
definition, is just a lie, making the person making the claim >>>>>>>>> just a liar.
just like there's more than one way to ask the same question, >>>>>>>> there's more than one way to define a halting decider, which is >>>>>>>> the interface into an algorithm, not the algorithm itself.
Right, but if they are semantically different, it isn't the same >>>>>>> question.
the one i'm proposing can actually generally exist, unlike the >>>>>>>> classical definition.
But only is a Computation System that is broken, because programs >>>>>>> don't reliable produce the same answer when run.
Once you allow things to lie, you have destroyed the concept of >>>>>>> truth.
it's really that simple.
Yes, allowing lying seems simple until you need to count on
something.
ur special pleading is just so mindnumbingly boring. i DEFINED >>>>>>>> my mechanics in MORE detail that turing did his, and yet u
We can easily DEFINE things that don't exist.>
i fucking already did. u just aren't reading cause ur too busy >>>>>>>>>> trying to show off how big a fucking retard u can be.
which is the point of the context-dependent decider. halts() >>>>>>>>>>>> is required to return /true/ only whereever both /possible/ >>>>>>>>>>>> and / truthful/ to do so.
So, if you want to try to talk about this, you first need to >>>>>>>>>>> try to develop a basic theory about context dependent
Computations, to see if it can actually be useful for anything. >>>>>>>>>>
No you haven't, unless you consider your claim that is the
equivalent of defining that 1 == 2 is a definition.
DESCRIBING what you want to do is NOT the same as DEFINING how >>>>>>>>> to do it.
arbitrarily reject it as "describing" which seems like a made up >>>>>>>> distinction here.
NO YOU HAVEN'T.
You have PRESUMED an ability on the machine that can not actually >>>>>>> be implemented on it without breaking it.
i'm intelligent enough to write down the machine description to
the tape when i see the operation REFLECT, and therefore accept
the defined ability
But is it the RIGHT machine description for the program in question? >>>>>
And where does it get the contents of the original tape?
i get that ur apparently too fucking retarded to do that, and
therefore don't accept it.
Nope, it seems you are too retarded to actually think about what
other say about your system. You suffer from the fallacy that you
assume you are right and thus ignore the definitions of what you
are talking about.
Your "Definition" is the equivalent of defining that for this
work, I will consider 1 to be equal to 2.
sometimes i really do feel like just buying a gun a shooting
myself, cause i really am stuck on a planet of fucking idiots. >>>>>>>>
y must u endlessly torture me so with ur fucking idiocracy?
I could say the same to you. Why are you so stuck on insisting on >>>>>>> things that are not.
Computations, as defined, can't change their answers for the same >>>>>>> input. PERIOD.
To insist they can is just to admit you are just a lunatic.
right, printing stack traces actually isn't part of computing.
every time we step thru debugging we're doing theoretically
indescribable magic, according to richard
And what does that have to do with what I said?
And yes, a routine looking at who called it is NOT part of
"Computing" per computation theory, as it can't matter.
It seems part of your problem is you don't actually know what you
are talking about.
Remember, Computing isn't directly about "Computers" as we
currently know them, but is more fundamental.
It seems you have forgotten that "Computing" as a term existed
BEFORE the computers you want to talk about.
blows my mind that u think a computing function that prints a stack
trace does something which cannot be done on and explained by a
turing machine
Well, try to define a Turing Machinne that does that.
Your first problem will be that Turing Machines don't have a stack to
dump.
i'm not sure y u think this mindnumbing gishgallop u shit out is
worth a continued response to
can u explain what my argument even is?
or are you basically just a fucking chatbot keying off one sentence
at a time?
No, but it seems you are just a idiot that refuses to learn the
meaning of the words you are using.
As I have pointed out several times, trying to relate a "Computation"
per COmputation Theory to behavior of modern computers is just an error.
well, that's just fucking retarded.
do you honestly think the behavior exhibiting within modern computing
somehow exists outside the theory of computing???
Sure does, at least the way you are talking about it.
Not that surprising when you remember that they didn't exist when the
theory was developed.
On 11/1/25 1:26 PM, Kaz Kylheku wrote:
On 2025-11-01, dart200 <[email protected]d> wrote:
On 11/1/25 9:37 AM, Kaz Kylheku wrote:The result of combining partial deciders will always be a decider
that can be shown not to be total.
The can is indeed always kicked down the road.
great! so ur own answered question of why i'm not particularly excited
by partial deciders, and want a way to /effectively compute/ whether an input machine halts not
do we need to have this discussion again kaz, or???
On 2025-11-03, dart200 <[email protected]d> wrote:
On 11/1/25 1:26 PM, Kaz Kylheku wrote:
On 2025-11-01, dart200 <[email protected]d> wrote:
On 11/1/25 9:37 AM, Kaz Kylheku wrote:The result of combining partial deciders will always be a decider
that can be shown not to be total.
The can is indeed always kicked down the road.
great! so ur own answered question of why i'm not particularly excited
by partial deciders, and want a way to /effectively compute/ whether an
input machine halts not
That's mainly just to lay to rest the stuff about paradoxes.
There is a real can, a real road, and you can kick one farther
down the other.
do we need to have this discussion again kaz, or???
Not unless you're a retired coding technician with anterograde amnesia,
and signs of dementia.
On 11/2/25 10:29 PM, dart200 wrote:
^^^^^^^^^^... RTMs themselves don't just then solve the halting
problem.
... RTMs allow for context-aware computing, which we can use to
propose a context-aware decider, that can proactively avoid succumbing
to semantic paradoxes
But they CAN'T solve the Halting Problem as defined, as the input for
the problem is to be a computation, and the decider needs to be a
computation that always gives the right answer.
On 03/11/2025 04:22, Richard Damon wrote:
On 11/2/25 10:29 PM, dart200 wrote:
[I seem to be doing more than my fair share of snipping]
^^^^^^^^^^... RTMs themselves don't just then solve the halting
problem.
"Don't just" is normally reserved here to trigger an inference in the
message interpreter that the message emitter thinks they do at least as
much. O.o
... RTMs allow for context-aware computing, which we can use to
propose a context-aware decider, that can proactively avoid succumbing
to semantic paradoxes
But they CAN'T solve the Halting Problem as defined, as the input for
the problem is to be a computation, and the decider needs to be a
computation that always gives the right answer.
It's still a computation by the word's meaning in computation theory but indeed they can't be programmed with a universal halt decider as far as
I understand the theory. I think that's conventional and undisputed by Olcott, at least.
It looks like dart200 thinks they /can/ be so programmed!
[I seem to be doing more than my fair share of snipping]
--
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.
what i'm proposing obviously will look very much like TMs in many if not
most computatation. in fact: any computation can run on a TM will in
fact be run the same on an RTM.
the differences in RTMs only come up in computations that aren't
directly expressible on TMs
On 11/1/25 1:26 PM, Kaz Kylheku wrote:
The result of combining partial deciders will always be a decider
that can be shown not to be total.
The can is indeed always kicked down the road.
my proposal is not kicking the can down the road. it's not attempting to resolve the problem with TMs, that problem will simply remain.
it's solving the problem within computing theory more generally by
proposing an update to TMs adding full reflection, such it can robustly handle what previously would have been a semantic paradox.
do we need to have this discussion again kaz, or???
Not unless you're a retired coding technician with anterograde amnesia,
and signs of dementia.
On 03/11/2025 04:22, Richard Damon wrote:
On 11/2/25 10:29 PM, dart200 wrote:
[I seem to be doing more than my fair share of snipping]
^^^^^^^^^^... RTMs themselves don't just then solve the halting
problem.
"Don't just" is normally reserved here to trigger an inference in the
message interpreter that the message emitter thinks they do at least as
much. O.o
... RTMs allow for context-aware computing, which we can use to
propose a context-aware decider, that can proactively avoid succumbing
to semantic paradoxes
But they CAN'T solve the Halting Problem as defined, as the input for
the problem is to be a computation, and the decider needs to be a
computation that always gives the right answer.
It's still a computation by the word's meaning in computation theory but indeed they can't be programmed with a universal halt decider as far as
I understand the theory. I think that's conventional and undisputed by Olcott, at least.
It looks like dart200 thinks they /can/ be so programmed!
[I seem to be doing more than my fair share of snipping]
--
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.
On 03/11/2025 01:05, dart200 wrote:
what i'm proposing obviously will look very much like TMs in many if not
most computatation. in fact: any computation can run on a TM will in
fact be run the same on an RTM.
An RTM is an example of a TM.
ITYM "any computation that can run on a TM will in fact be run the same
on its corresponding RTMs." But that's more of a constraint on the
meaning of "RTM" and "corresponding" so I would check the definition of
RTM carefully before using that alternative wording. In fact I would
expect it to be found overly specific. Maybe "any computation that can
run on a TM will in fact be run the same on those RTMs that extend it."
but that really just defines a concept I might ascribe as a meaning for "extend".
the differences in RTMs only come up in computations that aren't
directly expressible on TMs
ITYM "aren't directly expressible for other TMs".
On 11/3/25 10:17 AM, Tristan Wibberley wrote:
An RTM is an example of a TM.
*extension* of
if you have a machine description that /only/ uses the subset of
operations found on a TM (HEAD_LEFT, HEAD_RIGHT, WRITE_SYMBOL), then it
will run *exactly* the same on an RTM as a TM.
On 03/11/2025 19:38, dart200 wrote:
if you have a machine description that /only/ uses the subset of
operations found on a TM (HEAD_LEFT, HEAD_RIGHT, WRITE_SYMBOL), then it
will run *exactly* the same on an RTM as a TM.
My understanding of the term "TM" is that it's short for "Turing
Machine" which refers to a class of machines including those with other operations in addition to those you mention. Is that an inaccurate understanding?
--
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.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,076 |
| Nodes: | 10 (1 / 9) |
| Uptime: | 78:39:19 |
| Calls: | 13,805 |
| Files: | 186,990 |
| D/L today: |
5,990 files (1,958M bytes) |
| Messages: | 2,443,207 |