| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 26 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 48:48:40 |
| Calls: | 632 |
| Files: | 1,187 |
| D/L today: |
3 files (4,227K bytes) |
| Messages: | 177,138 |
sure it computes /something/ but does that something allow for any additional computation ability?
no,
and that's what he's failing to understand
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow for any
additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
On 10/10/25 5:52 PM, olcott wrote:
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow for any
additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
yeah you showed the same thing martin and kleene both did back in 1952,
and you haven't understood what turing shown in 1936 (no one here does actually)
but what ur not doing in spite of all of this is actually showing what
we can /effectively compute/ with ur hypothesis.
keyword being /effective/.
doesn't matter that ur hypothesis produces *some* answer, it needs to / effectively/ answer a question, and you haven't defined what that
question is ...
or more importantly why the fuck care about that question being answered.
ur lack in understanding what /effectively compute/ means
On 10/10/2025 8:07 PM, dart200 wrote:
On 10/10/25 5:52 PM, olcott wrote:
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow for any
additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
yeah you showed the same thing martin and kleene both did back in
1952, and you haven't understood what turing shown in 1936 (no one
here does actually)
That is possibly correct.
but what ur not doing in spite of all of this is actually showing what
we can /effectively compute/ with ur hypothesis.
Sure I am. HHH(DD) can effectively compute that it
must abort its simulation of DD to prevent its own
non-termination behavior.
keyword being /effective/.
doesn't matter that ur hypothesis produces *some* answer, it needs
to / effectively/ answer a question, and you haven't defined what that
question is ...
Do I need to abort the simulation of my input
to prevent my own non-termination?
or more importantly why the fuck care about that question being answered.
ur lack in understanding what /effectively compute/ means
That is not the term-of-the-art.
Before the precise definition of computable functions,
mathematicians often used the informal term effectively
calculable.
https://en.wikipedia.org/wiki/Computable_function
On 10/10/25 6:26 PM, olcott wrote:
On 10/10/2025 8:07 PM, dart200 wrote:
On 10/10/25 5:52 PM, olcott wrote:
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow for any
additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
yeah you showed the same thing martin and kleene both did back in
1952, and you haven't understood what turing shown in 1936 (no one
here does actually)
That is possibly correct.
but what ur not doing in spite of all of this is actually showing
what we can /effectively compute/ with ur hypothesis.
Sure I am. HHH(DD) can effectively compute that it
must abort its simulation of DD to prevent its own
non-termination behavior.
keyword being /effective/.
doesn't matter that ur hypothesis produces *some* answer, it needs
to / effectively/ answer a question, and you haven't defined what
that question is ...
Do I need to abort the simulation of my input
to prevent my own non-termination?
when HHH decides on DD1 (which uses the HHH1 decider instead of HHH),
then it's not answering that fucking question now is it???
the question it answers needs to be in regards to *all* the input, not
just a particular DD input...
so wtf is HHH computing then???
or more importantly why the fuck care about that question being
answered.
ur lack in understanding what /effectively compute/ means
That is not the term-of-the-art.
it is very much term-of-the-art for the actual problem turing brought up
in the initial paper on the matter, which isn't entirely represented by
the simple halting paradox that you spent 22 years on.
Before the precise definition of computable functions,
mathematicians often used the informal term effectively
calculable.
https://en.wikipedia.org/wiki/Computable_function
On 10/10/25 6:26 PM, olcott wrote:
On 10/10/2025 8:07 PM, dart200 wrote:
On 10/10/25 5:52 PM, olcott wrote:
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow for any
additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
yeah you showed the same thing martin and kleene both did back in
1952, and you haven't understood what turing shown in 1936 (no one
here does actually)
That is possibly correct.
but what ur not doing in spite of all of this is actually showing
what we can /effectively compute/ with ur hypothesis.
Sure I am. HHH(DD) can effectively compute that it
must abort its simulation of DD to prevent its own
non-termination behavior.
keyword being /effective/.
doesn't matter that ur hypothesis produces *some* answer, it needs
to / effectively/ answer a question, and you haven't defined what
that question is ...
Do I need to abort the simulation of my input
to prevent my own non-termination?
when HHH decides on DD1 (which uses the HHH1 decider instead of HHH),
then it's not answering that fucking question now is it???
the question it answers needs to be in regards to *all* the input, not
just a particular DD input...
so wtf is HHH computing then???
or more importantly why the fuck care about that question being
answered.
ur lack in understanding what /effectively compute/ means
That is not the term-of-the-art.
it is very much term-of-the-art for the actual problem turing brought up
in the initial paper on the matter, which isn't entirely represented by
the simple halting paradox that you spent 22 years on.
Before the precise definition of computable functions,
mathematicians often used the informal term effectively
calculable.
https://en.wikipedia.org/wiki/Computable_function
On 10/10/2025 9:21 PM, dart200 wrote:
On 10/10/25 6:26 PM, olcott wrote:
On 10/10/2025 8:07 PM, dart200 wrote:
On 10/10/25 5:52 PM, olcott wrote:
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow for any >>>>>> additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
yeah you showed the same thing martin and kleene both did back in
1952, and you haven't understood what turing shown in 1936 (no one
here does actually)
That is possibly correct.
but what ur not doing in spite of all of this is actually showing
what we can /effectively compute/ with ur hypothesis.
Sure I am. HHH(DD) can effectively compute that it
must abort its simulation of DD to prevent its own
non-termination behavior.
keyword being /effective/.
doesn't matter that ur hypothesis produces *some* answer, it needs
to / effectively/ answer a question, and you haven't defined what
that question is ...
Do I need to abort the simulation of my input
to prevent my own non-termination?
when HHH decides on DD1 (which uses the HHH1 decider instead of HHH),
then it's not answering that fucking question now is it???
the question it answers needs to be in regards to *all* the input, not
just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
or more importantly why the fuck care about that question being
answered.
ur lack in understanding what /effectively compute/ means
That is not the term-of-the-art.
it is very much term-of-the-art for the actual problem turing brought
up in the initial paper on the matter, which isn't entirely
represented by the simple halting paradox that you spent 22 years on.
No one calls it that now.
Before the precise definition of computable functions,
mathematicians often used the informal term effectively
calculable.
https://en.wikipedia.org/wiki/Computable_function
On 10/10/2025 9:21 PM, dart200 wrote:So you just admitted that HHH is not a halt decider because it is not computing the mapping that is required to be oneL
when HHH decides on DD1 (which uses the HHH1 decider instead of HHH),
then it's not answering that fucking question now is it???
the question it answers needs to be in regards to *all* the input, not
just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
On 10/10/25 9:26 PM, olcott wrote:
On 10/10/2025 9:21 PM, dart200 wrote:
On 10/10/25 6:26 PM, olcott wrote:
On 10/10/2025 8:07 PM, dart200 wrote:
On 10/10/25 5:52 PM, olcott wrote:
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow for
any additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
yeah you showed the same thing martin and kleene both did back in
1952, and you haven't understood what turing shown in 1936 (no one
here does actually)
That is possibly correct.
but what ur not doing in spite of all of this is actually showing
what we can /effectively compute/ with ur hypothesis.
Sure I am. HHH(DD) can effectively compute that it
must abort its simulation of DD to prevent its own
non-termination behavior.
keyword being /effective/.
doesn't matter that ur hypothesis produces *some* answer, it needs
to / effectively/ answer a question, and you haven't defined what
that question is ...
Do I need to abort the simulation of my input
to prevent my own non-termination?
when HHH decides on DD1 (which uses the HHH1 decider instead of HHH),
then it's not answering that fucking question now is it???
the question it answers needs to be in regards to *all* the input,
not just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
and why do i care whether HHH(DD) needs to abort on the input? it
doesn't mean the input is non-halting, as DD() run from anywhere but
within HHH(DD) halts.
or more importantly why the fuck care about that question being
answered.
ur lack in understanding what /effectively compute/ means
That is not the term-of-the-art.
it is very much term-of-the-art for the actual problem turing brought
up in the initial paper on the matter, which isn't entirely
represented by the simple halting paradox that you spent 22 years on.
No one calls it that now.
they do when they talk about why turing created the halting paradox in
the first place. u just never got that far into the theory.
Before the precise definition of computable functions,
mathematicians often used the informal term effectively
calculable.
https://en.wikipedia.org/wiki/Computable_function
On 10/11/2025 12:26 AM, olcott wrote:
On 10/10/2025 9:21 PM, dart200 wrote:
when HHH decides on DD1 (which uses the HHH1 decider instead of HHH),
then it's not answering that fucking question now is it???
the question it answers needs to be in regards to *all* the input,
not just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
So you just admitted that HHH is not a halt decider because it is not computing the mapping that is required to be oneL
Given any algorithm (i.e. a fixed immutable sequence of instructions) X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes the following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed directly
On 10/11/2025 7:00 AM, dbush wrote:
On 10/11/2025 12:26 AM, olcott wrote:
On 10/10/2025 9:21 PM, dart200 wrote:
when HHH decides on DD1 (which uses the HHH1 decider instead of
HHH), then it's not answering that fucking question now is it???
the question it answers needs to be in regards to *all* the input,
not just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
So you just admitted that HHH is not a halt decider because it is not
computing the mapping that is required to be oneL
*This just seems forever over-your-head*
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
Given any algorithm (i.e. a fixed immutable sequence of instructions)
X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes the
following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
On 10/11/2025 12:26 AM, olcott wrote:
It is computing: Do I need to abort this inputSo you just admitted that HHH is not a halt decider because it is
to prevent my own non-termination?-a Yes means
non-halting no means halting.
not computing the mapping that is required to be one
On 10/11/2025 8:13 AM, olcott wrote:
On 10/11/2025 7:00 AM, dbush wrote:
On 10/11/2025 12:26 AM, olcott wrote:
On 10/10/2025 9:21 PM, dart200 wrote:
when HHH decides on DD1 (which uses the HHH1 decider instead of
HHH), then it's not answering that fucking question now is it???
the question it answers needs to be in regards to *all* the input,
not just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
So you just admitted that HHH is not a halt decider because it is not
computing the mapping that is required to be oneL
*This just seems forever over-your-head*
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
And it true by the meaning of the words that a finite string description
of a Turing machine specifies all of the semantic properties of the
machine it describes, including whether it halts when executed directly.
On 10/11/2025 7:36 AM, dbush wrote:This constitutes your admission that halt deciders compute the mapping
On 10/11/2025 8:13 AM, olcott wrote:
On 10/11/2025 7:00 AM, dbush wrote:
On 10/11/2025 12:26 AM, olcott wrote:
On 10/10/2025 9:21 PM, dart200 wrote:
when HHH decides on DD1 (which uses the HHH1 decider instead of
HHH), then it's not answering that fucking question now is it???
the question it answers needs to be in regards to *all* the input, >>>>>> not just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
So you just admitted that HHH is not a halt decider because it is
not computing the mapping that is required to be oneL
*This just seems forever over-your-head*
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
And it true by the meaning of the words that a finite string
description of a Turing machine specifies all of the semantic
properties of the machine it describes, including whether it halts
when executed directly.
<repeat of previously refuted point / copy paste reply>
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow for any
additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
On 10/10/2025 9:21 PM, dart200 wrote:
On 10/10/25 6:26 PM, olcott wrote:
On 10/10/2025 8:07 PM, dart200 wrote:
On 10/10/25 5:52 PM, olcott wrote:
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow for any >>>>>> additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
yeah you showed the same thing martin and kleene both did back in
1952, and you haven't understood what turing shown in 1936 (no one
here does actually)
That is possibly correct.
but what ur not doing in spite of all of this is actually showing
what we can /effectively compute/ with ur hypothesis.
Sure I am. HHH(DD) can effectively compute that it
must abort its simulation of DD to prevent its own
non-termination behavior.
keyword being /effective/.
doesn't matter that ur hypothesis produces *some* answer, it needs
to / effectively/ answer a question, and you haven't defined what
that question is ...
Do I need to abort the simulation of my input
to prevent my own non-termination?
when HHH decides on DD1 (which uses the HHH1 decider instead of HHH),
then it's not answering that fucking question now is it???
the question it answers needs to be in regards to *all* the input, not
just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
or more importantly why the fuck care about that question being
answered.
ur lack in understanding what /effectively compute/ means
That is not the term-of-the-art.
it is very much term-of-the-art for the actual problem turing brought
up in the initial paper on the matter, which isn't entirely
represented by the simple halting paradox that you spent 22 years on.
No one calls it that now.
Before the precise definition of computable functions,
mathematicians often used the informal term effectively
calculable.
https://en.wikipedia.org/wiki/Computable_function
On 10/10/25 9:26 PM, olcott wrote:
On 10/10/2025 9:21 PM, dart200 wrote:
On 10/10/25 6:26 PM, olcott wrote:
On 10/10/2025 8:07 PM, dart200 wrote:
On 10/10/25 5:52 PM, olcott wrote:
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow for
any additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
yeah you showed the same thing martin and kleene both did back in
1952, and you haven't understood what turing shown in 1936 (no one
here does actually)
That is possibly correct.
but what ur not doing in spite of all of this is actually showing
what we can /effectively compute/ with ur hypothesis.
Sure I am. HHH(DD) can effectively compute that it
must abort its simulation of DD to prevent its own
non-termination behavior.
keyword being /effective/.
doesn't matter that ur hypothesis produces *some* answer, it needs
to / effectively/ answer a question, and you haven't defined what
that question is ...
Do I need to abort the simulation of my input
to prevent my own non-termination?
when HHH decides on DD1 (which uses the HHH1 decider instead of HHH),
then it's not answering that fucking question now is it???
the question it answers needs to be in regards to *all* the input,
not just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
yeah but when HHH is deciding on another program that loops forever
without calling HHH ... that's not the case, now is it?
or more importantly why the fuck care about that question being
answered.
ur lack in understanding what /effectively compute/ means
That is not the term-of-the-art.
it is very much term-of-the-art for the actual problem turing brought
up in the initial paper on the matter, which isn't entirely
represented by the simple halting paradox that you spent 22 years on.
No one calls it that now.
Before the precise definition of computable functions,
mathematicians often used the informal term effectively
calculable.
https://en.wikipedia.org/wiki/Computable_function
On 10/11/2025 1:49 AM, dart200 wrote:
On 10/10/25 9:26 PM, olcott wrote:
On 10/10/2025 9:21 PM, dart200 wrote:
On 10/10/25 6:26 PM, olcott wrote:
On 10/10/2025 8:07 PM, dart200 wrote:
On 10/10/25 5:52 PM, olcott wrote:
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow for >>>>>>>> any additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
yeah you showed the same thing martin and kleene both did back in >>>>>> 1952, and you haven't understood what turing shown in 1936 (no one >>>>>> here does actually)
That is possibly correct.
but what ur not doing in spite of all of this is actually showing >>>>>> what we can /effectively compute/ with ur hypothesis.
Sure I am. HHH(DD) can effectively compute that it
must abort its simulation of DD to prevent its own
non-termination behavior.
keyword being /effective/.
doesn't matter that ur hypothesis produces *some* answer, it needs >>>>>> to / effectively/ answer a question, and you haven't defined what >>>>>> that question is ...
Do I need to abort the simulation of my input
to prevent my own non-termination?
when HHH decides on DD1 (which uses the HHH1 decider instead of
HHH), then it's not answering that fucking question now is it???
the question it answers needs to be in regards to *all* the input,
not just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
and why do i care whether HHH(DD) needs to abort on the input? it
doesn't mean the input is non-halting, as DD() run from anywhere but
within HHH(DD) halts.
If the input is a denial of service attack
that targets a specific DOS detector the
DOS detector catches this and prevents the
attack. On every other input it is just an
ordinary halt decider.
Besides an operating system level halt decider
this is the best halt decider than anyone can
ever create.
On 10/11/2025 5:05 AM, olcott wrote:
On 10/11/2025 1:49 AM, dart200 wrote:
On 10/10/25 9:26 PM, olcott wrote:
On 10/10/2025 9:21 PM, dart200 wrote:
On 10/10/25 6:26 PM, olcott wrote:
On 10/10/2025 8:07 PM, dart200 wrote:
On 10/10/25 5:52 PM, olcott wrote:
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow for >>>>>>>>> any additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
yeah you showed the same thing martin and kleene both did back in >>>>>>> 1952, and you haven't understood what turing shown in 1936 (no
one here does actually)
That is possibly correct.
but what ur not doing in spite of all of this is actually showing >>>>>>> what we can /effectively compute/ with ur hypothesis.
Sure I am. HHH(DD) can effectively compute that it
must abort its simulation of DD to prevent its own
non-termination behavior.
keyword being /effective/.
doesn't matter that ur hypothesis produces *some* answer, it
needs to / effectively/ answer a question, and you haven't
defined what that question is ...
Do I need to abort the simulation of my input
to prevent my own non-termination?
when HHH decides on DD1 (which uses the HHH1 decider instead of
HHH), then it's not answering that fucking question now is it???
the question it answers needs to be in regards to *all* the input,
not just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
and why do i care whether HHH(DD) needs to abort on the input? it
doesn't mean the input is non-halting, as DD() run from anywhere but
within HHH(DD) halts.
If the input is a denial of service attack
that targets a specific DOS detector the
DOS detector catches this and prevents the
attack. On every other input it is just an
ordinary halt decider.
Besides an operating system level halt decider
this is the best halt decider than anyone can
ever create.
Huh? You never created any Kernel code or anything. No way. I would bet against it. Would I be wrong?
[...]
On 10/12/2025 6:01 PM, Chris M. Thomasson wrote:
On 10/11/2025 5:05 AM, olcott wrote:
On 10/11/2025 1:49 AM, dart200 wrote:
On 10/10/25 9:26 PM, olcott wrote:
On 10/10/2025 9:21 PM, dart200 wrote:
On 10/10/25 6:26 PM, olcott wrote:
On 10/10/2025 8:07 PM, dart200 wrote:
On 10/10/25 5:52 PM, olcott wrote:
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow for >>>>>>>>>> any additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
yeah you showed the same thing martin and kleene both did back >>>>>>>> in 1952, and you haven't understood what turing shown in 1936 >>>>>>>> (no one here does actually)
That is possibly correct.
but what ur not doing in spite of all of this is actually
showing what we can /effectively compute/ with ur hypothesis.
Sure I am. HHH(DD) can effectively compute that it
must abort its simulation of DD to prevent its own
non-termination behavior.
keyword being /effective/.
doesn't matter that ur hypothesis produces *some* answer, it
needs to / effectively/ answer a question, and you haven't
defined what that question is ...
Do I need to abort the simulation of my input
to prevent my own non-termination?
when HHH decides on DD1 (which uses the HHH1 decider instead of
HHH), then it's not answering that fucking question now is it???
the question it answers needs to be in regards to *all* the input, >>>>>> not just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
and why do i care whether HHH(DD) needs to abort on the input? it
doesn't mean the input is non-halting, as DD() run from anywhere but
within HHH(DD) halts.
If the input is a denial of service attack
that targets a specific DOS detector the
DOS detector catches this and prevents the
attack. On every other input it is just an
ordinary halt decider.
Besides an operating system level halt decider
this is the best halt decider than anyone can
ever create.
Huh? You never created any Kernel code or anything. No way. I would
bet against it. Would I be wrong?
[...]
I wrote the entire x86utm operating system
including cooperative multi-tasking so that
HHH can simulate itself simulating DD to
an arbitrary depth.
On 10/12/2025 4:04 PM, olcott wrote:
On 10/12/2025 6:01 PM, Chris M. Thomasson wrote:
On 10/11/2025 5:05 AM, olcott wrote:
On 10/11/2025 1:49 AM, dart200 wrote:
On 10/10/25 9:26 PM, olcott wrote:
On 10/10/2025 9:21 PM, dart200 wrote:
On 10/10/25 6:26 PM, olcott wrote:
On 10/10/2025 8:07 PM, dart200 wrote:
On 10/10/25 5:52 PM, olcott wrote:
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow >>>>>>>>>>> for any additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
yeah you showed the same thing martin and kleene both did back >>>>>>>>> in 1952, and you haven't understood what turing shown in 1936 >>>>>>>>> (no one here does actually)
That is possibly correct.
but what ur not doing in spite of all of this is actually
showing what we can /effectively compute/ with ur hypothesis. >>>>>>>>>
Sure I am. HHH(DD) can effectively compute that it
must abort its simulation of DD to prevent its own
non-termination behavior.
keyword being /effective/.
doesn't matter that ur hypothesis produces *some* answer, it >>>>>>>>> needs to / effectively/ answer a question, and you haven't
defined what that question is ...
Do I need to abort the simulation of my input
to prevent my own non-termination?
when HHH decides on DD1 (which uses the HHH1 decider instead of >>>>>>> HHH), then it's not answering that fucking question now is it??? >>>>>>>
the question it answers needs to be in regards to *all* the
input, not just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
and why do i care whether HHH(DD) needs to abort on the input? it
doesn't mean the input is non-halting, as DD() run from anywhere
but within HHH(DD) halts.
If the input is a denial of service attack
that targets a specific DOS detector the
DOS detector catches this and prevents the
attack. On every other input it is just an
ordinary halt decider.
Besides an operating system level halt decider
this is the best halt decider than anyone can
ever create.
Huh? You never created any Kernel code or anything. No way. I would
bet against it. Would I be wrong?
[...]
I wrote the entire x86utm operating system
including cooperative multi-tasking so that
HHH can simulate itself simulating DD to
an arbitrary depth.
Oh cool. Can I interface with it? Does it boot up into a prompt or something?
On 10/12/2025 8:36 PM, Chris M. Thomasson wrote:
On 10/12/2025 4:04 PM, olcott wrote:
On 10/12/2025 6:01 PM, Chris M. Thomasson wrote:
On 10/11/2025 5:05 AM, olcott wrote:
On 10/11/2025 1:49 AM, dart200 wrote:
On 10/10/25 9:26 PM, olcott wrote:
On 10/10/2025 9:21 PM, dart200 wrote:
On 10/10/25 6:26 PM, olcott wrote:
On 10/10/2025 8:07 PM, dart200 wrote:
On 10/10/25 5:52 PM, olcott wrote:
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow >>>>>>>>>>>> for any additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
yeah you showed the same thing martin and kleene both did back >>>>>>>>>> in 1952, and you haven't understood what turing shown in 1936 >>>>>>>>>> (no one here does actually)
That is possibly correct.
but what ur not doing in spite of all of this is actually >>>>>>>>>> showing what we can /effectively compute/ with ur hypothesis. >>>>>>>>>>
Sure I am. HHH(DD) can effectively compute that it
must abort its simulation of DD to prevent its own
non-termination behavior.
keyword being /effective/.
doesn't matter that ur hypothesis produces *some* answer, it >>>>>>>>>> needs to / effectively/ answer a question, and you haven't >>>>>>>>>> defined what that question is ...
Do I need to abort the simulation of my input
to prevent my own non-termination?
when HHH decides on DD1 (which uses the HHH1 decider instead of >>>>>>>> HHH), then it's not answering that fucking question now is it??? >>>>>>>>
the question it answers needs to be in regards to *all* the
input, not just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
and why do i care whether HHH(DD) needs to abort on the input? it >>>>>> doesn't mean the input is non-halting, as DD() run from anywhere
but within HHH(DD) halts.
If the input is a denial of service attack
that targets a specific DOS detector the
DOS detector catches this and prevents the
attack. On every other input it is just an
ordinary halt decider.
Besides an operating system level halt decider
this is the best halt decider than anyone can
ever create.
Huh? You never created any Kernel code or anything. No way. I would
bet against it. Would I be wrong?
[...]
I wrote the entire x86utm operating system
including cooperative multi-tasking so that
HHH can simulate itself simulating DD to
an arbitrary depth.
Oh cool. Can I interface with it? Does it boot up into a prompt or
something?
It runs under Windows command line. It takes a
COFF object file as input. It enables one C
function to emulate the x86 code of another C
function in Debug Step mode. This is how
termination analyzer HHH works with DD input.
https://github.com/plolcott/x86utm
On 10/12/2025 6:54 PM, olcott wrote:
On 10/12/2025 8:36 PM, Chris M. Thomasson wrote:
On 10/12/2025 4:04 PM, olcott wrote:
On 10/12/2025 6:01 PM, Chris M. Thomasson wrote:
On 10/11/2025 5:05 AM, olcott wrote:
On 10/11/2025 1:49 AM, dart200 wrote:
On 10/10/25 9:26 PM, olcott wrote:
On 10/10/2025 9:21 PM, dart200 wrote:
On 10/10/25 6:26 PM, olcott wrote:
On 10/10/2025 8:07 PM, dart200 wrote:
On 10/10/25 5:52 PM, olcott wrote:
On 10/10/2025 7:49 PM, dart200 wrote:
sure it computes /something/ but does that something allow >>>>>>>>>>>>> for any additional computation ability?
no,
and that's what he's failing to understand
I am failing to understand nothing about this.
I already showed that I understood the conventional
halting problem is impossible 21 years ago.
yeah you showed the same thing martin and kleene both did >>>>>>>>>>> back in 1952, and you haven't understood what turing shown in >>>>>>>>>>> 1936 (no one here does actually)
That is possibly correct.
but what ur not doing in spite of all of this is actually >>>>>>>>>>> showing what we can /effectively compute/ with ur hypothesis. >>>>>>>>>>>
Sure I am. HHH(DD) can effectively compute that it
must abort its simulation of DD to prevent its own
non-termination behavior.
keyword being /effective/.
doesn't matter that ur hypothesis produces *some* answer, it >>>>>>>>>>> needs to / effectively/ answer a question, and you haven't >>>>>>>>>>> defined what that question is ...
Do I need to abort the simulation of my input
to prevent my own non-termination?
when HHH decides on DD1 (which uses the HHH1 decider instead of >>>>>>>>> HHH), then it's not answering that fucking question now is it??? >>>>>>>>>
the question it answers needs to be in regards to *all* the >>>>>>>>> input, not just a particular DD input...
so wtf is HHH computing then???
It is computing: Do I need to abort this input
to prevent my own non-termination?-a Yes means
non-halting no means halting.
and why do i care whether HHH(DD) needs to abort on the input? it >>>>>>> doesn't mean the input is non-halting, as DD() run from anywhere >>>>>>> but within HHH(DD) halts.
If the input is a denial of service attack
that targets a specific DOS detector the
DOS detector catches this and prevents the
attack. On every other input it is just an
ordinary halt decider.
Besides an operating system level halt decider
this is the best halt decider than anyone can
ever create.
Huh? You never created any Kernel code or anything. No way. I would >>>>> bet against it. Would I be wrong?
[...]
I wrote the entire x86utm operating system
including cooperative multi-tasking so that
HHH can simulate itself simulating DD to
an arbitrary depth.
Oh cool. Can I interface with it? Does it boot up into a prompt or
something?
It runs under Windows command line. It takes a
COFF object file as input. It enables one C
function to emulate the x86 code of another C
function in Debug Step mode. This is how
termination analyzer HHH works with DD input.
https://github.com/plolcott/x86utm
Strange. Why not make it take a C program as input, compile it, then it
has all it needs? So, I can pass in any program to it and it will
simulate and and tell me if it halts or not?