Hi!
In the case of pathological input, Peter's SHD only needs to report a
correct halting result *as if* the simulation was run to completion:
whether we abort, or continue until we run out of stack space makes no difference: we are detecting INFINITE recursion which can be viewed as non- halting.
On 18/05/2025 01:11, Mr Flibble wrote:
Hi!
In the case of pathological input, Peter's SHD only needs to report a
correct halting result *as if* the simulation was run to completion:
Right. If the simulation is run to completion, that's like a UTM
simulating the input, and equivalent to asking whether the input halts.
This is the case for all inputs, not just "pathological" ones, whatever
they are exactly.
PO's DD() calls an "embedded HHH" which aborts its simulation. If that
DD is simulated to completion it halts, so that is what his SHD needs to report. PO has verified this directly, and has published the traces
showing DD halting when simulated to completion.
whether we abort, or continue until we run out of stack space makes no
difference: we are detecting INFINITE recursion which can be viewed as
non-
halting.
Eh? PO does have a couple of SHDs that simulate his DD to completion,
and they all show DD halting!
There's no infinite recursion, only some level of finite recursive
simulation.
PO gets confused, because his SHD HHH simply /doesn't/ simulate DD to completion. It aborts, and then decides non-halting. That's the
reverse of what you said in the first paragraph. So your thread title
is misleading - PO is actually *incorrect*. I've corrected the title to avoid confusion.
On 18/05/2025 02:10, Mr Flibble wrote:
On Sun, 18 May 2025 02:06:43 +0100, Mike Terry wrote:
On 18/05/2025 01:11, Mr Flibble wrote:
Hi!
In the case of pathological input, Peter's SHD only needs to report a
correct halting result *as if* the simulation was run to completion:
Right. If the simulation is run to completion, that's like a UTM
simulating the input, and equivalent to asking whether the input
halts. This is the case for all inputs, not just "pathological" ones,
whatever they are exactly.
PO's DD() calls an "embedded HHH" which aborts its simulation. If
that DD is simulated to completion it halts, so that is what his SHD
needs to report. PO has verified this directly, and has published the
traces showing DD halting when simulated to completion.
whether we abort, or continue until we run out of stack space makes
no difference: we are detecting INFINITE recursion which can be
viewed as non-
halting.
Eh? PO does have a couple of SHDs that simulate his DD to completion,
and they all show DD halting!
There's no infinite recursion, only some level of finite recursive
simulation.
PO gets confused, because his SHD HHH simply /doesn't/ simulate DD to
completion. It aborts, and then decides non-halting. That's the
reverse of what you said in the first paragraph. So your thread title
is misleading - PO is actually *incorrect*. I've corrected the title
to avoid confusion.
No, halting the simulation is NOT THE SAME as a halting result of
HALTING for what is being simulated. I have changed the subject title
back, you jackass.
Where did I say it was the same? /YOU/ said above that PO's SHD should decide *as if* the simulation was run to completion. [your
highlighting]. If DD is simulated to completion it halts,
so by your logic his SHD should decide halting. Instead it decides neverhalts.
On Sun, 18 May 2025 02:06:43 +0100, Mike Terry wrote:
On 18/05/2025 01:11, Mr Flibble wrote:
Hi!
In the case of pathological input, Peter's SHD only needs to report a
correct halting result *as if* the simulation was run to completion:
Right. If the simulation is run to completion, that's like a UTM
simulating the input, and equivalent to asking whether the input halts.
This is the case for all inputs, not just "pathological" ones, whatever
they are exactly.
PO's DD() calls an "embedded HHH" which aborts its simulation. If that
DD is simulated to completion it halts, so that is what his SHD needs to
report. PO has verified this directly, and has published the traces
showing DD halting when simulated to completion.
whether we abort, or continue until we run out of stack space makes no
difference: we are detecting INFINITE recursion which can be viewed as
non-
halting.
Eh? PO does have a couple of SHDs that simulate his DD to completion,
and they all show DD halting!
There's no infinite recursion, only some level of finite recursive
simulation.
PO gets confused, because his SHD HHH simply /doesn't/ simulate DD to
completion. It aborts, and then decides non-halting. That's the
reverse of what you said in the first paragraph. So your thread title
is misleading - PO is actually *incorrect*. I've corrected the title to
avoid confusion.
No, halting the simulation is NOT THE SAME as a halting result of HALTING
for what is being simulated. I have changed the subject title back, you jackass.
On Sun, 18 May 2025 02:42:58 +0100, Mike Terry wrote:
On 18/05/2025 02:10, Mr Flibble wrote:
On Sun, 18 May 2025 02:06:43 +0100, Mike Terry wrote:
On 18/05/2025 01:11, Mr Flibble wrote:
Hi!
In the case of pathological input, Peter's SHD only needs to report a >>>>> correct halting result *as if* the simulation was run to completion:
Right. If the simulation is run to completion, that's like a UTM
simulating the input, and equivalent to asking whether the input
halts. This is the case for all inputs, not just "pathological" ones,
whatever they are exactly.
PO's DD() calls an "embedded HHH" which aborts its simulation. If
that DD is simulated to completion it halts, so that is what his SHD
needs to report. PO has verified this directly, and has published the >>>> traces showing DD halting when simulated to completion.
whether we abort, or continue until we run out of stack space makes
no difference: we are detecting INFINITE recursion which can be
viewed as non-
halting.
Eh? PO does have a couple of SHDs that simulate his DD to completion, >>>> and they all show DD halting!
There's no infinite recursion, only some level of finite recursive >>>> simulation.
PO gets confused, because his SHD HHH simply /doesn't/ simulate DD to
completion. It aborts, and then decides non-halting. That's the
reverse of what you said in the first paragraph. So your thread title >>>> is misleading - PO is actually *incorrect*. I've corrected the title
to avoid confusion.
No, halting the simulation is NOT THE SAME as a halting result of
HALTING for what is being simulated. I have changed the subject title
back, you jackass.
Where did I say it was the same? /YOU/ said above that PO's SHD should
decide *as if* the simulation was run to completion. [your
highlighting]. If DD is simulated to completion it halts,
so by your logic his SHD should decide halting. Instead it decides
neverhalts.
No, if an IDEAL simulation runs to completion it NEVER completes as the recursion is INFINITE however a practical simulator has finite resources
(and a valid decider must decide in finite time) so cannot run forever so instead we abort the simulation early if we detect infinite recursion with
a correct halting result of NON-HALTING. This is in accordance with Flibble's Law.
/Flibble
On 5/17/2025 8:10 PM, Mr Flibble wrote:STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
On Sun, 18 May 2025 02:06:43 +0100, Mike Terry wrote:
On 18/05/2025 01:11, Mr Flibble wrote:
Hi!
In the case of pathological input, Peter's SHD only needs to report a
correct halting result *as if* the simulation was run to completion:
Right. If the simulation is run to completion, that's like a UTM
simulating the input, and equivalent to asking whether the input
halts. This is the case for all inputs, not just "pathological" ones,
whatever they are exactly.
PO's DD() calls an "embedded HHH" which aborts its simulation. If
that DD is simulated to completion it halts, so that is what his SHD
needs to report. PO has verified this directly, and has published the
traces showing DD halting when simulated to completion.
whether we abort, or continue until we run out of stack space makes
no difference: we are detecting INFINITE recursion which can be
viewed as non-
halting.
Eh? PO does have a couple of SHDs that simulate his DD to completion,
and they all show DD halting!
There's no infinite recursion, only some level of finite recursive
simulation.
PO gets confused, because his SHD HHH simply /doesn't/ simulate DD to
completion. It aborts, and then decides non-halting. That's the
reverse of what you said in the first paragraph. So your thread title
is misleading - PO is actually *incorrect*. I've corrected the title
to avoid confusion.
No, halting the simulation is NOT THE SAME as a halting result of
HALTING for what is being simulated. I have changed the subject title
back, you jackass.
/Flibble
He is only terribly wrong on this one point. Mike has by far the most complete understanding of my work than anyone else in the world.
He may have never heard of the *Strawman Fallacy*
Description: Substituting a person’s actual position or argument with a distorted, exaggerated, or misrepresented version of the position of the argument. https://www.logicallyfallacious.com/logicalfallacies/Strawman-Fallacy
He even showed exactly how the words Professor Sipser agreed to do
derive a correct simulating termination analyzer.
On 5/14/2025 7:36 PM, Mike Terry wrote:
https://al.howardknight.net/?
Before Mike's succinct and correct reply all of my reviewers were having
fun playing sadistic head games insisting on only talking in endless
circles.
On 5/17/2025 8:42 PM, Mike Terry wrote:
On 18/05/2025 02:10, Mr Flibble wrote:
On Sun, 18 May 2025 02:06:43 +0100, Mike Terry wrote:
On 18/05/2025 01:11, Mr Flibble wrote:
Hi!
In the case of pathological input, Peter's SHD only needs to report a >>>>> correct halting result *as if* the simulation was run to completion:
Right. If the simulation is run to completion, that's like a UTM
simulating the input, and equivalent to asking whether the input halts. >>>> This is the case for all inputs, not just "pathological" ones, whatever >>>> they are exactly.
PO's DD() calls an "embedded HHH" which aborts its simulation. If that >>>> DD is simulated to completion it halts, so that is what his SHD
needs to
report. PO has verified this directly, and has published the traces
showing DD halting when simulated to completion.
whether we abort, or continue until we run out of stack space makes no >>>>> difference: we are detecting INFINITE recursion which can be viewed as >>>>> non-
halting.
Eh? PO does have a couple of SHDs that simulate his DD to completion, >>>> and they all show DD halting!
There's no infinite recursion, only some level of finite recursive >>>> simulation.
PO gets confused, because his SHD HHH simply /doesn't/ simulate DD to
completion. It aborts, and then decides non-halting. That's the
reverse of what you said in the first paragraph. So your thread title >>>> is misleading - PO is actually *incorrect*. I've corrected the
title to
avoid confusion.
No, halting the simulation is NOT THE SAME as a halting result of
HALTING
for what is being simulated. I have changed the subject title back, you >>> jackass.
Where did I say it was the same? /YOU/ said above that PO's SHD
should decide *as if* the simulation was run to completion. [your
highlighting]. If DD is simulated to completion it halts, so by your
logic his SHD should decide halting. Instead it decides neverhalts.
Mike.
void DDD()
{
HHH(DDD);
return;
}
*DDD simulated by HHH HAS NO COMPLETION*
In the case of pathological input, Peter's SHD only needs to report a
correct halting result *as if* the simulation was run to completion:
whether we abort, or continue until we run out of stack space makes no difference:
we are detecting INFINITE recursion which can be viewed as non-
halting.
On 5/17/2025 9:06 PM, Mike Terry wrote:
On 18/05/2025 02:51, Mr Flibble wrote:
On Sun, 18 May 2025 02:42:58 +0100, Mike Terry wrote:
On 18/05/2025 02:10, Mr Flibble wrote:
On Sun, 18 May 2025 02:06:43 +0100, Mike Terry wrote:
On 18/05/2025 01:11, Mr Flibble wrote:
Hi!Right. If the simulation is run to completion, that's like a UTM >>>>>> simulating the input, and equivalent to asking whether the input
In the case of pathological input, Peter's SHD only needs to report a >>>>>>> correct halting result *as if* the simulation was run to completion: >>>>>>
halts. This is the case for all inputs, not just "pathological" ones, >>>>>> whatever they are exactly.
PO's DD() calls an "embedded HHH" which aborts its simulation. If >>>>>> that DD is simulated to completion it halts, so that is what his SHD >>>>>> needs to report. PO has verified this directly, and has published the >>>>>> traces showing DD halting when simulated to completion.
whether we abort, or continue until we run out of stack space makes >>>>>>> no difference: we are detecting INFINITE recursion which can be
viewed as non-
halting.
Eh? PO does have a couple of SHDs that simulate his DD to completion, >>>>>> and they all show DD halting!
There's no infinite recursion, only some level of finite recursive
simulation.
PO gets confused, because his SHD HHH simply /doesn't/ simulate DD to >>>>>> completion. It aborts, and then decides non-halting. That's the >>>>>> reverse of what you said in the first paragraph. So your thread title >>>>>> is misleading - PO is actually *incorrect*. I've corrected the title >>>>>> to avoid confusion.
No, halting the simulation is NOT THE SAME as a halting result of
HALTING for what is being simulated. I have changed the subject title >>>>> back, you jackass.
Where did I say it was the same? /YOU/ said above that PO's SHD should >>>> decide *as if* the simulation was run to completion. [your
highlighting]. If DD is simulated to completion it halts,
so by your logic his SHD should decide halting. Instead it decides
neverhalts.
No, if an IDEAL simulation runs to completion it NEVER completes as the
recursion is INFINITE however a practical simulator has finite resources >>> (and a valid decider must decide in finite time) so cannot run forever so >>> instead we abort the simulation early if we detect infinite recursion with >>> a correct halting result of NON-HALTING. This is in accordance with
Flibble's Law.
/Flibble
As I said above, the recursion in the case of PO's DD is NOT INFINITE.
void DDD()
{
HHH(DDD);
return;
}
On 5/17/2025 9:06 PM, Mike Terry wrote:
On 18/05/2025 02:51, Mr Flibble wrote:
On Sun, 18 May 2025 02:42:58 +0100, Mike Terry wrote:
On 18/05/2025 02:10, Mr Flibble wrote:
On Sun, 18 May 2025 02:06:43 +0100, Mike Terry wrote:
On 18/05/2025 01:11, Mr Flibble wrote:
Hi!Right. If the simulation is run to completion, that's like a UTM >>>>>> simulating the input, and equivalent to asking whether the input
In the case of pathological input, Peter's SHD only needs to
report a
correct halting result *as if* the simulation was run to completion: >>>>>>
halts. This is the case for all inputs, not just "pathological" ones, >>>>>> whatever they are exactly.
PO's DD() calls an "embedded HHH" which aborts its simulation. If >>>>>> that DD is simulated to completion it halts, so that is what his SHD >>>>>> needs to report. PO has verified this directly, and has published >>>>>> the
traces showing DD halting when simulated to completion.
whether we abort, or continue until we run out of stack space makes >>>>>>> no difference: we are detecting INFINITE recursion which can be
viewed as non-
halting.
Eh? PO does have a couple of SHDs that simulate his DD to
completion,
and they all show DD halting!
There's no infinite recursion, only some level of finite
recursive
simulation.
PO gets confused, because his SHD HHH simply /doesn't/ simulate DD to >>>>>> completion. It aborts, and then decides non-halting. That's the >>>>>> reverse of what you said in the first paragraph. So your thread
title
is misleading - PO is actually *incorrect*. I've corrected the title >>>>>> to avoid confusion.
No, halting the simulation is NOT THE SAME as a halting result of
HALTING for what is being simulated. I have changed the subject title >>>>> back, you jackass.
Where did I say it was the same? /YOU/ said above that PO's SHD should >>>> decide *as if* the simulation was run to completion. [your
highlighting]. If DD is simulated to completion it halts,
so by your logic his SHD should decide halting. Instead it decides
neverhalts.
No, if an IDEAL simulation runs to completion it NEVER completes as the
recursion is INFINITE however a practical simulator has finite resources >>> (and a valid decider must decide in finite time) so cannot run
forever so
instead we abort the simulation early if we detect infinite recursion
with
a correct halting result of NON-HALTING. This is in accordance with
Flibble's Law.
/Flibble
As I said above, the recursion in the case of PO's DD is NOT INFINITE.
void DDD()
{
HHH(DDD);
return;
}
Then show how *DDD SIMULATED BY HHH* halts.
*Its like you don't even know what recursion is*
On 5/17/2025 8:42 PM, Mike Terry wrote:
On 18/05/2025 02:10, Mr Flibble wrote:
On Sun, 18 May 2025 02:06:43 +0100, Mike Terry wrote:
On 18/05/2025 01:11, Mr Flibble wrote:
Hi!
In the case of pathological input, Peter's SHD only needs to report a >>>>> correct halting result *as if* the simulation was run to completion:
Right. If the simulation is run to completion, that's like a UTM
simulating the input, and equivalent to asking whether the input halts. >>>> This is the case for all inputs, not just "pathological" ones, whatever >>>> they are exactly.
PO's DD() calls an "embedded HHH" which aborts its simulation. If that >>>> DD is simulated to completion it halts, so that is what his SHD needs to >>>> report. PO has verified this directly, and has published the traces
showing DD halting when simulated to completion.
whether we abort, or continue until we run out of stack space makes no >>>>> difference: we are detecting INFINITE recursion which can be viewed as >>>>> non-
halting.
Eh? PO does have a couple of SHDs that simulate his DD to completion, >>>> and they all show DD halting!
There's no infinite recursion, only some level of finite recursive >>>> simulation.
PO gets confused, because his SHD HHH simply /doesn't/ simulate DD to
completion. It aborts, and then decides non-halting. That's the
reverse of what you said in the first paragraph. So your thread title >>>> is misleading - PO is actually *incorrect*. I've corrected the title to >>>> avoid confusion.
No, halting the simulation is NOT THE SAME as a halting result of HALTING >>> for what is being simulated. I have changed the subject title back, you >>> jackass.
Where did I say it was the same? /YOU/ said above that PO's SHD should
decide *as if* the simulation was run to completion. [your
highlighting]. If DD is simulated to completion it halts, so by your
logic his SHD should decide halting. Instead it decides neverhalts.
Mike.
void DDD()
{
HHH(DDD);
return;
}
*DDD simulated by HHH HAS NO COMPLETION*
*DDD simulated by HHH1 IS THE STRAWMAN FALLACY*
changing the words of the argument and then
rebutting these changed words.
Strawman Fallacy
Description: Substituting a person’s actual position or argument
with a distorted, exaggerated, or misrepresented version of the
position of the argument.
https://www.logicallyfallacious.com/logicalfallacies/Strawman-Fallacy
On Sat, 17 May 2025 21:28:23 -0500, olcott wrote:
On 5/17/2025 8:10 PM, Mr Flibble wrote:STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
On Sun, 18 May 2025 02:06:43 +0100, Mike Terry wrote:
On 18/05/2025 01:11, Mr Flibble wrote:
Hi!
In the case of pathological input, Peter's SHD only needs to report a >>>>> correct halting result *as if* the simulation was run to completion:
Right. If the simulation is run to completion, that's like a UTM
simulating the input, and equivalent to asking whether the input
halts. This is the case for all inputs, not just "pathological" ones,
whatever they are exactly.
PO's DD() calls an "embedded HHH" which aborts its simulation. If
that DD is simulated to completion it halts, so that is what his SHD
needs to report. PO has verified this directly, and has published the >>>> traces showing DD halting when simulated to completion.
whether we abort, or continue until we run out of stack space makes
no difference: we are detecting INFINITE recursion which can be
viewed as non-
halting.
Eh? PO does have a couple of SHDs that simulate his DD to completion, >>>> and they all show DD halting!
There's no infinite recursion, only some level of finite recursive
simulation.
PO gets confused, because his SHD HHH simply /doesn't/ simulate DD to
completion. It aborts, and then decides non-halting. That's the
reverse of what you said in the first paragraph. So your thread title >>>> is misleading - PO is actually *incorrect*. I've corrected the title
to avoid confusion.
No, halting the simulation is NOT THE SAME as a halting result of
HALTING for what is being simulated. I have changed the subject title
back, you jackass.
/Flibble
He is only terribly wrong on this one point. Mike has by far the most
complete understanding of my work than anyone else in the world.
He may have never heard of the *Strawman Fallacy*
Description: Substituting a person’s actual position or argument with a
distorted, exaggerated, or misrepresented version of the position of the
argument.
https://www.logicallyfallacious.com/logicalfallacies/Strawman-Fallacy
He even showed exactly how the words Professor Sipser agreed to do
derive a correct simulating termination analyzer.
On 5/14/2025 7:36 PM, Mike Terry wrote:
https://al.howardknight.net/?
Before Mike's succinct and correct reply all of my reviewers were having
fun playing sadistic head games insisting on only talking in endless
circles.
Yes, I am getting that impression too: this is the problem with learn by
rote vs genuine understanding, no critical thinking.
On 5/17/2025 9:06 PM, Mike Terry wrote:
On 18/05/2025 02:51, Mr Flibble wrote:
On Sun, 18 May 2025 02:42:58 +0100, Mike Terry wrote:
On 18/05/2025 02:10, Mr Flibble wrote:
On Sun, 18 May 2025 02:06:43 +0100, Mike Terry wrote:
On 18/05/2025 01:11, Mr Flibble wrote:
Hi!Right. If the simulation is run to completion, that's like a UTM >>>>>> simulating the input, and equivalent to asking whether the input
In the case of pathological input, Peter's SHD only needs to
report a
correct halting result *as if* the simulation was run to completion: >>>>>>
halts. This is the case for all inputs, not just "pathological" ones, >>>>>> whatever they are exactly.
PO's DD() calls an "embedded HHH" which aborts its simulation. If >>>>>> that DD is simulated to completion it halts, so that is what his SHD >>>>>> needs to report. PO has verified this directly, and has published >>>>>> the
traces showing DD halting when simulated to completion.
whether we abort, or continue until we run out of stack space makes >>>>>>> no difference: we are detecting INFINITE recursion which can be
viewed as non-
halting.
Eh? PO does have a couple of SHDs that simulate his DD to
completion,
and they all show DD halting!
There's no infinite recursion, only some level of finite
recursive
simulation.
PO gets confused, because his SHD HHH simply /doesn't/ simulate DD to >>>>>> completion. It aborts, and then decides non-halting. That's the >>>>>> reverse of what you said in the first paragraph. So your thread
title
is misleading - PO is actually *incorrect*. I've corrected the title >>>>>> to avoid confusion.
No, halting the simulation is NOT THE SAME as a halting result of
HALTING for what is being simulated. I have changed the subject title >>>>> back, you jackass.
Where did I say it was the same? /YOU/ said above that PO's SHD should >>>> decide *as if* the simulation was run to completion. [your
highlighting]. If DD is simulated to completion it halts,
so by your logic his SHD should decide halting. Instead it decides
neverhalts.
No, if an IDEAL simulation runs to completion it NEVER completes as the
recursion is INFINITE however a practical simulator has finite resources >>> (and a valid decider must decide in finite time) so cannot run
forever so
instead we abort the simulation early if we detect infinite recursion
with
a correct halting result of NON-HALTING. This is in accordance with
Flibble's Law.
/Flibble
As I said above, the recursion in the case of PO's DD is NOT INFINITE.
void DDD()
{
HHH(DDD);
return;
}
Then show how *DDD SIMULATED BY HHH* halts.
*Its like you don't even know what recursion is*
When I say that Donald Trump is a convicted
felon and you say "no you are wrong Pope Leo XIV
is not a convicted felon" you changed my words
and then rebutted the changed words.
Likewise with
DDD simulated by HHH
versus
DDD simulated by HHH1.
Hi!
In the case of pathological input, Peter's SHD only needs to report a
correct halting result *as if* the simulation was run to completion:
whether we abort, or continue until we run out of stack space makes no difference: we are detecting INFINITE recursion which can be viewed as non- halting.
This is valid due to Flibble's Law:
If a problem permits infinite behavior in its formulation, it permits infinite analysis of that behavior in its decidability scope.
/Flibble
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 715 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 15:49:33 |
| Calls: | 12,102 |
| Calls today: | 2 |
| Files: | 15,004 |
| Messages: | 6,518,054 |