On 8/18/2025 6:05 PM, Richard Heathfield wrote:
It is an easily verified fact, as you love to say, that if DD
calls HHH (as it does) and HHH calls DD (as, through
simulation, it effectively does) that HHH(DD) can never halt
naturally, so it will have to abort the recursion and report
its result as 0 - didn't halt.
Good.
Precisely /because/ that fact is so easily verified, it is safe
and correct for HHH to replace a simulated call to HHH(DD) with
a 0, catch that 0 return value, and continue with the simulation.
*That is cheating and you know it* Why lie?
On 8/18/2025 6:46 PM, Richard Heathfield wrote:
On 19/08/2025 00:28, olcott wrote:
On 8/18/2025 6:05 PM, Richard Heathfield wrote:
<snip>
It is an easily verified fact, as you love to say, that if DD
calls HHH (as it does) and HHH calls DD (as, through
simulation, it effectively does) that HHH(DD) can never halt
naturally, so it will have to abort the recursion and report
its result as 0 - didn't halt.
Good.
Precisely /because/ that fact is so easily verified, it is
safe and correct for HHH to replace a simulated call to
HHH(DD) with a 0, catch that 0 return value, and continue
with the simulation.
*That is cheating and you know it* Why lie?
Cheating?
What are you talking about? Don't be so bloody ridiculous.
If you didn't already know it is cheating
you
would not have said the prior paragraph.
On 8/18/2025 6:05 PM, Richard Heathfield wrote:
On 18/08/2025 23:46, olcott wrote:
On 8/18/2025 5:13 PM, Richard Heathfield wrote:
It is an easily verified fact, as you love to say, that if DD calls HHHGood.
(as it does) and HHH calls DD (as, through simulation, it effectively
does) that HHH(DD) can never halt naturally, so it will have to abort
the recursion and report its result as 0 - didn't halt.
Precisely /because/ that fact is so easily verified, it is safe and*That is cheating and you know it* Why lie?
correct for HHH to replace a simulated call to HHH(DD) with a 0, catch
that 0 return value, and continue with the simulation.
The rest of what you say is based on this same cheat.
--Since it is therefore possible for the simulation to continue after
all, it is erroneous to refrain.
HHH is therefore compelled to conclude:
(a) that the recursion will never halt unless aborted;
(b) the recursion must yield 0;
(c) DD must therefore skip the if and return 0 (meaning that it never
halts) while in the very act of halting.
In other words, even when/if you fix your simulator, it will still get
the answer wrong.
On 8/19/2025 3:06 AM, joes wrote:
Am Mon, 18 Aug 2025 18:28:06 -0500 schrieb olcott:
On 8/18/2025 6:05 PM, Richard Heathfield wrote:
On 18/08/2025 23:46, olcott wrote:
On 8/18/2025 5:13 PM, Richard Heathfield wrote:
It is an easily verified fact, as you love to say, that if DDGood.
calls HHH
(as it does) and HHH calls DD (as, through simulation, it
effectively
does) that HHH(DD) can never halt naturally, so it will have
to abort
the recursion and report its result as 0 - didn't halt.
Precisely /because/ that fact is so easily verified, it is*That is cheating and you know it* Why lie?
safe and
correct for HHH to replace a simulated call to HHH(DD) with a
0, catch
that 0 return value, and continue with the simulation.
The rest of what you say is based on this same cheat.
It’s not cheating. If we know the result, we can skip the whole
calculation. I can just write return 4 instead of 2+2.
That is the kind of changing the input that
changes the behavior specified by this input
that is cheating.
On 8/19/2025 3:06 AM, joes wrote:
Am Mon, 18 Aug 2025 18:28:06 -0500 schrieb olcott:
On 8/18/2025 6:05 PM, Richard Heathfield wrote:
On 18/08/2025 23:46, olcott wrote:
On 8/18/2025 5:13 PM, Richard Heathfield wrote:
That is the kind of changing the input that changes the behaviorPrecisely /because/ that fact is so easily verified, it is safe and*That is cheating and you know it* Why lie?
correct for HHH to replace a simulated call to HHH(DD) with a 0,
catch that 0 return value, and continue with the simulation.
The rest of what you say is based on this same cheat.
It’s not cheating. If we know the result, we can skip the whole
calculation. I can just write return 4 instead of 2+2.
specified by this input that is cheating.
On 8/19/2025 9:36 AM, Richard Heathfield wrote:
On 19/08/2025 15:29, olcott wrote:
On 8/19/2025 3:06 AM, joes wrote:
Am Mon, 18 Aug 2025 18:28:06 -0500 schrieb olcott:
On 8/18/2025 6:05 PM, Richard Heathfield wrote:
On 18/08/2025 23:46, olcott wrote:
On 8/18/2025 5:13 PM, Richard Heathfield wrote:
It is an easily verified fact, as you love to say, that ifGood.
DD calls HHH
(as it does) and HHH calls DD (as, through simulation, it
effectively
does) that HHH(DD) can never halt naturally, so it will
have to abort
the recursion and report its result as 0 - didn't halt.
Precisely /because/ that fact is so easily verified, it is*That is cheating and you know it* Why lie?
safe and
correct for HHH to replace a simulated call to HHH(DD) with
a 0, catch
that 0 return value, and continue with the simulation.
The rest of what you say is based on this same cheat.
It’s not cheating. If we know the result, we can skip the whole
calculation. I can just write return 4 instead of 2+2.
That is the kind of changing the input that
changes the behavior specified by this input
that is cheating.
How does it change the behaviour of DD?
It lets it reach unreachable code.
On 8/19/2025 10:24 AM, Richard Heathfield wrote:
On 19/08/2025 16:08, olcott wrote:
On 8/19/2025 9:36 AM, Richard Heathfield wrote:
On 19/08/2025 15:29, olcott wrote:
On 8/19/2025 3:06 AM, joes wrote:
Am Mon, 18 Aug 2025 18:28:06 -0500 schrieb olcott:
On 8/18/2025 6:05 PM, Richard Heathfield wrote:
On 18/08/2025 23:46, olcott wrote:
On 8/18/2025 5:13 PM, Richard Heathfield wrote:
It is an easily verified fact, as you love to say, thatGood.
if DD calls HHH
(as it does) and HHH calls DD (as, through simulation, it
effectively
does) that HHH(DD) can never halt naturally, so it will
have to abort
the recursion and report its result as 0 - didn't halt.
Precisely /because/ that fact is so easily verified, it*That is cheating and you know it* Why lie?
is safe and
correct for HHH to replace a simulated call to HHH(DD)
with a 0, catch
that 0 return value, and continue with the simulation.
The rest of what you say is based on this same cheat.
It’s not cheating. If we know the result, we can skip the
whole
calculation. I can just write return 4 instead of 2+2.
That is the kind of changing the input that
changes the behavior specified by this input
that is cheating.
How does it change the behaviour of DD?
It lets it reach unreachable code.
If the code is unreachable, it can't be reached, so you're wrong.
If the code is reached, it isn't unreachable, so you're wrong.
_Infinite_Loop()
[00002112] 55 push ebp
[00002113] 8bec mov ebp,esp
[00002115] ebfe jmp 00002115
[00002117] 5d pop ebp
[00002118] c3 ret
Size in bytes:(0007) [00002118]
Its "return" statement is unreachable without cheating.
On 8/19/2025 9:56 AM, joes wrote:
Am Tue, 19 Aug 2025 09:29:19 -0500 schrieb olcott:
On 8/19/2025 3:06 AM, joes wrote:
Am Mon, 18 Aug 2025 18:28:06 -0500 schrieb olcott:
On 8/18/2025 6:05 PM, Richard Heathfield wrote:
On 18/08/2025 23:46, olcott wrote:
On 8/18/2025 5:13 PM, Richard Heathfield wrote:
That is the kind of changing the input that changes the behaviorPrecisely /because/ that fact is so easily verified, it is safe and >>>>>> correct for HHH to replace a simulated call to HHH(DD) with a 0,*That is cheating and you know it* Why lie?
catch that 0 return value, and continue with the simulation.
The rest of what you say is based on this same cheat.
It’s not cheating. If we know the result, we can skip the whole
calculation. I can just write return 4 instead of 2+2.
specified by this input that is cheating.
Cheating is that HHH returns that DD would not halt *if it called
a non-aborting simulator*.
When 0 to ∞ instructions of DD are correctly
simulated by HHH this simulated DD never reaches
its own simulated "return" statement final halt state.
*This code correctly predicts that behavior*
Lines 996 through 1006 matches the
*recursive simulation non-halting behavior pattern* https://github.com/plolcott/x86utm/blob/master/Halt7.c
On 8/19/2025 3:06 AM, joes wrote:
Am Mon, 18 Aug 2025 18:28:06 -0500 schrieb olcott:
On 8/18/2025 6:05 PM, Richard Heathfield wrote:
On 18/08/2025 23:46, olcott wrote:
On 8/18/2025 5:13 PM, Richard Heathfield wrote:
It is an easily verified fact, as you love to say, that if DD calls HHH >>>> (as it does) and HHH calls DD (as, through simulation, it effectivelyGood.
does) that HHH(DD) can never halt naturally, so it will have to abort
the recursion and report its result as 0 - didn't halt.
Precisely /because/ that fact is so easily verified, it is safe and*That is cheating and you know it* Why lie?
correct for HHH to replace a simulated call to HHH(DD) with a 0, catch >>>> that 0 return value, and continue with the simulation.
The rest of what you say is based on this same cheat.
It’s not cheating. If we know the result, we can skip the whole
calculation. I can just write return 4 instead of 2+2.
That is the kind of changing the input that
changes the behavior specified by this input
that is cheating.
Since it is therefore possible for the simulation to continue after
all, it is erroneous to refrain.
HHH is therefore compelled to conclude:
(a) that the recursion will never halt unless aborted;
(b) the recursion must yield 0;
(c) DD must therefore skip the if and return 0 (meaning that it never
halts) while in the very act of halting.
In other words, even when/if you fix your simulator, it will still get >>>> the answer wrong.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 156:45:16 |
| Calls: | 10,384 |
| Calls today: | 1 |
| Files: | 14,056 |
| Messages: | 6,416,471 |