Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #106719 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2024-06-08 13:47 -0500 |
| Last post | 2024-06-10 23:32 -0400 |
| Articles | 20 on this page of 87 — 5 participants |
Back to article view | Back to comp.theory
Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-08 13:47 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-08 14:49 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-08 16:32 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-08 16:32 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-09 08:33 +0200
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-09 07:21 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-09 14:08 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-09 09:13 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-09 14:08 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Mikko <mikko.levanto@iki.fi> - 2024-06-10 10:48 +0300
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-10 10:09 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-10 23:32 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Mikko <mikko.levanto@iki.fi> - 2024-06-11 11:02 +0300
DDD correctly simulated by HH cannot possibly halt olcott <polcott333@gmail.com> - 2024-06-11 12:24 -0500
Re: DDD correctly simulated by HH cannot possibly halt Richard Damon <richard@damon-family.org> - 2024-06-11 21:46 -0400
Re: DDD correctly simulated by HH cannot possibly halt Mikko <mikko.levanto@iki.fi> - 2024-06-12 10:20 +0300
Re: DDD correctly simulated by HH cannot possibly halt olcott <polcott333@gmail.com> - 2024-06-12 10:17 -0500
Re: DDD correctly simulated by HH cannot possibly halt Mikko <mikko.levanto@iki.fi> - 2024-06-15 15:03 +0300
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Mikko <mikko.levanto@iki.fi> - 2024-06-15 14:59 +0300
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-10 00:17 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-10 09:09 +0200
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-10 08:52 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) joes <noreply@example.com> - 2024-06-10 15:35 +0000
Proof that D correctly simulated by H has different behavior than D(D) olcott <polcott333@gmail.com> - 2024-06-10 10:39 -0500
Re: Proof that D correctly simulated by H has different behavior than D(D) Richard Damon <richard@damon-family.org> - 2024-06-11 21:59 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-10 21:15 +0200
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-11 21:48 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) olcott <polcott333@gmail.com> - 2024-06-10 14:21 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-10 21:41 +0200
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) olcott <polcott333@gmail.com> - 2024-06-10 14:47 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-11 09:21 +0200
D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-11 12:07 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-12 08:18 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-12 09:47 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-12 20:19 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-12 13:24 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-12 21:13 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-12 14:20 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-12 21:46 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-12 14:53 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-13 10:15 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-13 07:44 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-13 21:33 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-13 14:41 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-14 11:59 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-14 07:49 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-14 21:00 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-14 14:18 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-14 22:03 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-14 15:46 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-15 11:03 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-15 07:12 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Richard Damon <richard@damon-family.org> - 2024-06-15 09:51 -0400
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-15 16:06 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-15 09:13 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Richard Damon <richard@damon-family.org> - 2024-06-15 10:29 -0400
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-15 16:37 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-15 09:48 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Richard Damon <richard@damon-family.org> - 2024-06-15 11:02 -0400
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-15 17:12 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-15 10:23 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Richard Damon <richard@damon-family.org> - 2024-06-15 11:39 -0400
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-16 08:21 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-16 07:37 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Richard Damon <richard@damon-family.org> - 2024-06-16 13:30 -0400
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-16 21:08 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-17 08:39 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-17 16:21 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-17 09:35 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-17 16:51 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Mikko <mikko.levanto@iki.fi> - 2024-06-17 10:22 +0300
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-17 08:07 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Mikko <mikko.levanto@iki.fi> - 2024-06-18 10:54 +0300
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-18 07:55 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-18 11:16 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-18 07:43 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-18 17:25 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-18 10:39 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-18 17:53 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Mikko <mikko.levanto@iki.fi> - 2024-06-18 19:32 +0300
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-18 11:41 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) Richard Damon <richard@damon-family.org> - 2024-06-11 22:17 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-10 07:16 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-10 12:54 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) joes <noreply@example.com> - 2024-06-10 18:21 +0000
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-10 13:48 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-10 23:32 -0400
Page 3 of 5 — ← Prev page 1 2 [3] 4 5 Next page →
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-13 10:15 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4e9qm$25ks0$1@dont-email.me> |
| In reply to | #106998 |
Op 12.jun.2024 om 21:53 schreef olcott: > On 6/12/2024 2:46 PM, Fred. Zwarts wrote: >> Op 12.jun.2024 om 21:20 schreef olcott: >>> On 6/12/2024 2:13 PM, Fred. Zwarts wrote: >>>> Op 12.jun.2024 om 20:24 schreef olcott: >>>>> On 6/12/2024 1:19 PM, Fred. Zwarts wrote: >>>>>> Op 12.jun.2024 om 16:47 schreef olcott: >>>>>>>> >>>>>>>> There is no infinite nested simulation detected, >>>>>>> >>>>>>> If I am wrong then a specific sequence of steps of D correctly >>>>>>> simulated by H where D terminates normally can be provided. >>>>>> >>>>>> No infinite execution has been detected, >>>>> >>>>> You seem to simply not understand that D correctly simulated >>>>> by H would eventually crash due to out-of-memory error. >>>>> >>>> >>>> Exactly. A correct H simulated by H does not exist. But, again, you >>>> misses the point. It was in the part that you omitted. >>>> So, again: >>>> >>>> No infinite execution has been detected, only a premature abortion. >>> >>> On 5/29/2021 2:26 PM, olcott wrote: >>> https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ >>> >>> If that was true then you could provide every step of D correctly >>> simulated by H such that D simulated by H reaches its own simulated >>> "ret" instruction. >> >> I said that each H is unable to hit its target, so how could it reach >> the "ret" instruction of D? Please, think before you reply. > > It is a binary choice either D correctly simulated by H can > possibly terminate normally by reaching its "ret" instruction > or not. Your attempt to twist these words to make it look like > there is more than these two possibilities is either ignorant > or deceptive. > Please, take some more attention to what I said. Read, then think, before you reply. I said that H is not able to reach its own "ret" when it is simulating itself. So, no disagreement with that. That proves that H misses its target. The abort is too early. The target is just some steps further. It does not mean that the target is at infinity. It is like an archer who is asked to hit a target twice as far as his bow can reach. His bow reaches 50m and the target is at 100m. He misses. Then he uses a new bow that reaches 100m, but now the target is at 200m. He is able to reach the old target, but again he misses the target for the new bow. He can continue with a stronger bow, but if the bow reaches further, the target is also further away. But note, the target is never at infinity. Similarly, the target of the simulator is never at infinity, but always some steps further that the simulation goes. You can make a simulator that simulates further, which can reach the target of the old simulator, but it is unable to reach its own target. So, there is no infinite recursion, but the simulation always misses the target. The simulation is never able to simulate itself up to the end. It always aborts prematurely. So, your claim proves that it is not a good idea to simulate H by itself. It will always miss the target.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-13 07:44 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4epji$28g4v$2@dont-email.me> |
| In reply to | #107049 |
On 6/13/2024 3:15 AM, Fred. Zwarts wrote:
> Op 12.jun.2024 om 21:53 schreef olcott:
>> On 6/12/2024 2:46 PM, Fred. Zwarts wrote:
>>> Op 12.jun.2024 om 21:20 schreef olcott:
>>>>
>>>> On 5/29/2021 2:26 PM, olcott wrote:
>>>> https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ
>>>>
>>>> If that was true then you could provide every step of D correctly
>>>> simulated by H such that D simulated by H reaches its own simulated
>>>> "ret" instruction.
>>>
>>> I said that each H is unable to hit its target, so how could it reach
>>> the "ret" instruction of D? Please, think before you reply.
>>
>> It is a binary choice either D correctly simulated by H can
>> possibly terminate normally by reaching its "ret" instruction
>> or not. Your attempt to twist these words to make it look like
>> there is more than these two possibilities is either ignorant
>> or deceptive.
>>
>
> Please, take some more attention to what I said. Read, then think,
> before you reply.
> I said that H is not able to reach its own "ret" when it is simulating
> itself.
That has always been totally irrelevant.
> So, no disagreement with that. That proves that H misses its
> target. The abort is too early. The target is just some steps further.
> It does not mean that the target is at infinity.
>
The outer H always has one more execution trace to base its halt
status decision on than any of the nested emulations. This means
that unless the outer H aborts its simulation then none of them do.
> It is like an archer who is asked to hit a target twice as far as his
> bow can reach. His bow reaches 50m and the target is at 100m. He misses.
> Then he uses a new bow that reaches 100m, but now the target is at 200m.
> He is able to reach the old target, but again he misses the target for
> the new bow. He can continue with a stronger bow, but if the bow reaches
> further, the target is also further away. But note, the target is never
> at infinity.
Sure just like Zeno's paradox where he "proved" that it is impossible to
cross a ten foot wide room in finite time.
> Similarly, the target of the simulator is never at infinity, but always
> some steps further that the simulation goes. You can make a simulator
> that simulates further, which can reach the target of the old simulator,
> but it is unable to reach its own target. So, there is no infinite
> recursion, but the simulation always misses the target. The simulation
> is never able to simulate itself up to the end. It always aborts
> prematurely.
> So, your claim proves that it is not a good idea to simulate H by
> itself. It will always miss the target.
*As soon as H sees the repeating state it stops*
*As soon as H sees the repeating state it stops*
*As soon as H sees the repeating state it stops*
*If you don't understand the infinite recursion example then*
*You lack the required prerequisite knowledge to understand me*
void Infinite_Recursion(u32 N)
{
Infinite_Recursion(N);
}
int main()
{
H(Infinite_Recursion, (ptr)5);
}
_Infinite_Recursion()
[00001ca3] 55 push ebp
[00001ca4] 8bec mov ebp,esp
[00001ca6] 8b4508 mov eax,[ebp+08]
[00001ca9] 50 push eax
[00001caa] e8f4ffffff call 00001ca3
[00001caf] 83c404 add esp,+04
[00001cb2] 5d pop ebp
[00001cb3] c3 ret
Size in bytes:(0017) [00001cb3]
_main()
[00001e23] 55 push ebp
[00001e24] 8bec mov ebp,esp
[00001e26] 6a05 push +05 ; push 5
[00001e28] 68a31c0000 push 00001ca3 ; push Infinite_Recursion
[00001e2d] e8e1f6ffff call 00001513 ; call H
[00001e32] 83c408 add esp,+08
[00001e35] eb04 jmp 00001e3b
[00001e37] 33c0 xor eax,eax
[00001e39] eb02 jmp 00001e3d
[00001e3b] 33c0 xor eax,eax
[00001e3d] 5d pop ebp
[00001e3e] c3 ret
Size in bytes:(0028) [00001e3e]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001e23][001031e9][00000000] 55 push ebp
[00001e24][001031e9][00000000] 8bec mov ebp,esp
[00001e26][001031e5][00000005] 6a05 push +05 ; push 5
[00001e28][001031e1][00001ca3] 68a31c0000 push 00001ca3 ; push
Infinite_Recursion
[00001e2d][001031dd][00001e32] e8e1f6ffff call 00001513 ; call H
H: Begin Simulation Execution Trace Stored at:113295
Address_of_H:1513
[00001ca3][00113281][00113285] 55 push ebp
[00001ca4][00113281][00113285] 8bec mov ebp,esp
[00001ca6][00113281][00113285] 8b4508 mov eax,[ebp+08]
[00001ca9][0011327d][00000005] 50 push eax ; push param
[00001caa][00113279][00001caf] e8f4ffffff call 00001ca3 ; call
Infinite_Recursion
[00001ca3][00113275][00113281] 55 push ebp
[00001ca4][00113275][00113281] 8bec mov ebp,esp
[00001ca6][00113275][00113281] 8b4508 mov eax,[ebp+08]
[00001ca9][00113271][00000005] 50 push eax ; push param
[00001caa][0011326d][00001caf] e8f4ffffff call 00001ca3 ; call
Infinite_Recursion
H: Infinite Recursion Detected Simulation Stopped
[00001e32][001031e9][00000000] 83c408 add esp,+08
[00001e35][001031e9][00000000] eb04 jmp 00001e3b
[00001e3b][001031e9][00000000] 33c0 xor eax,eax
[00001e3d][001031ed][00000018] 5d pop ebp
[00001e3e][001031f1][00000000] c3 ret
Number of Instructions Executed(1104) == 16 Pages
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-13 21:33 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4fhj3$2dce5$1@dont-email.me> |
| In reply to | #107058 |
Op 13.jun.2024 om 14:44 schreef olcott:
> On 6/13/2024 3:15 AM, Fred. Zwarts wrote:
>> Op 12.jun.2024 om 21:53 schreef olcott:
>>> On 6/12/2024 2:46 PM, Fred. Zwarts wrote:
>>>> Op 12.jun.2024 om 21:20 schreef olcott:
>>>>>
>>>>> On 5/29/2021 2:26 PM, olcott wrote:
>>>>> https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ
>>>>>
>>>>> If that was true then you could provide every step of D correctly
>>>>> simulated by H such that D simulated by H reaches its own simulated
>>>>> "ret" instruction.
>>>>
>>>> I said that each H is unable to hit its target, so how could it
>>>> reach the "ret" instruction of D? Please, think before you reply.
>>>
>>> It is a binary choice either D correctly simulated by H can
>>> possibly terminate normally by reaching its "ret" instruction
>>> or not. Your attempt to twist these words to make it look like
>>> there is more than these two possibilities is either ignorant
>>> or deceptive.
>>>
>>
>> Please, take some more attention to what I said. Read, then think,
>> before you reply.
>> I said that H is not able to reach its own "ret" when it is simulating
>> itself.
>
> That has always been totally irrelevant.
So, you think that if H does not reach its "ret", D can still reach its
"ret"?
Try to think. D does not reach its "ret", *because* "H" does not reach
its "ret".
>
>> So, no disagreement with that. That proves that H misses its target.
>> The abort is too early. The target is just some steps further. It does
>> not mean that the target is at infinity.
>>
>
> The outer H always has one more execution trace to base its halt
> status decision on than any of the nested emulations. This means
> that unless the outer H aborts its simulation then none of them do.
That is true. But it also means that H aborts one execution trace too
early. And since a simulation is unable to simulate itself, it is not
possible to do it correctly.
The H that simulates one execution trace is unable to see the abort of
its simulated self, because it needs two execution traces to see that.
The H that simulates two execution traces is unable to see the abort of
its simulated self, because it needs three execution traces to see that.
Etc.
The invariant is that they all abort one execution trace too early.
The other invariant is that there is never an infinite simulation recursion.
Conclusion is that it is impossible for such a simulator to correctly
simulate itself.
>
>> It is like an archer who is asked to hit a target twice as far as his
>> bow can reach. His bow reaches 50m and the target is at 100m. He misses.
>> Then he uses a new bow that reaches 100m, but now the target is at
>> 200m. He is able to reach the old target, but again he misses the
>> target for the new bow. He can continue with a stronger bow, but if
>> the bow reaches further, the target is also further away. But note,
>> the target is never at infinity.
>
> Sure just like Zeno's paradox where he "proved" that it is impossible to
> cross a ten foot wide room in finite time.
Strange twist of Zeno's paradox.
*You* try to "prove" similarly that there is an infinite recursion,
where H is only some steps away from its target.
>
>> Similarly, the target of the simulator is never at infinity, but
>> always some steps further that the simulation goes. You can make a
>> simulator that simulates further, which can reach the target of the
>> old simulator, but it is unable to reach its own target. So, there is
>> no infinite recursion, but the simulation always misses the target.
>> The simulation is never able to simulate itself up to the end. It
>> always aborts prematurely.
>> So, your claim proves that it is not a good idea to simulate H by
>> itself. It will always miss the target.
>
> *As soon as H sees the repeating state it stops*
> *As soon as H sees the repeating state it stops*
> *As soon as H sees the repeating state it stops*
Yes, it stops. But the conclusion is that there is repetition, but not
an infinite repetition, but the repetition is only one more than the
simulator could see. If it would simulate one execution trace more, it
would see its own abort. But it is not possible to do that with this
simulator. Another simulator, with more steps would see that, but than
there is another target for this new simulator when it would also try to
simulate itself.
>
> *If you don't understand the infinite recursion example then*
> *You lack the required prerequisite knowledge to understand me*
If you do not understand that there is a difference between an finite
number of repetitions and an infinite recursion, you miss the background
to talk about infinite recursions.
>
> void Infinite_Recursion(u32 N)
> {
> Infinite_Recursion(N);
> }
>
> int main()
> {
> H(Infinite_Recursion, (ptr)5);
> }
>
If you do not understand that the simulation of Infinite_Recursion by H
is totally different from H simulating itself, than you do not have the
competence to think about infinite recursion.
H has the requirement to halt. Infinite_Recursion does not have that
requirement. So, a correct simulation of H would also reach its "ret",
but that correct simulation cannot be done by H itself, because its
simulation runs one execution trace behind its simulator execution.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-13 14:41 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4fi0m$2dvk4$1@dont-email.me> |
| In reply to | #107081 |
On 6/13/2024 2:33 PM, Fred. Zwarts wrote: > Op 13.jun.2024 om 14:44 schreef olcott: >> On 6/13/2024 3:15 AM, Fred. Zwarts wrote: >>> Op 12.jun.2024 om 21:53 schreef olcott: >>>> On 6/12/2024 2:46 PM, Fred. Zwarts wrote: >>>>> Op 12.jun.2024 om 21:20 schreef olcott: >>>>>> >>>>>> On 5/29/2021 2:26 PM, olcott wrote: >>>>>> https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ >>>>>> >>>>>> If that was true then you could provide every step of D correctly >>>>>> simulated by H such that D simulated by H reaches its own simulated >>>>>> "ret" instruction. >>>>> >>>>> I said that each H is unable to hit its target, so how could it >>>>> reach the "ret" instruction of D? Please, think before you reply. >>>> >>>> It is a binary choice either D correctly simulated by H can >>>> possibly terminate normally by reaching its "ret" instruction >>>> or not. Your attempt to twist these words to make it look like >>>> there is more than these two possibilities is either ignorant >>>> or deceptive. >>>> >>> >>> Please, take some more attention to what I said. Read, then think, >>> before you reply. >>> I said that H is not able to reach its own "ret" when it is >>> simulating itself. >> >> That has always been totally irrelevant. > > So, you think that if H does not reach its "ret", D can still reach its > "ret"? > Try to think. D does not reach its "ret", *because* "H" does not reach > its "ret". > >> >>> So, no disagreement with that. That proves that H misses its target. >>> The abort is too early. The target is just some steps further. It >>> does not mean that the target is at infinity. >>> >> >> The outer H always has one more execution trace to base its halt >> status decision on than any of the nested emulations. This means >> that unless the outer H aborts its simulation then none of them do. > > That is true. But it also means that H aborts one execution trace too > early. No it never meant this. If H waits for some other H to abort their simulation then H waits forever. H is always at least one execution trace ahead of every other H. -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-14 11:59 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4h4ag$2q9hc$1@dont-email.me> |
| In reply to | #107082 |
Op 13.jun.2024 om 21:41 schreef olcott: > On 6/13/2024 2:33 PM, Fred. Zwarts wrote: >> Op 13.jun.2024 om 14:44 schreef olcott: >>> On 6/13/2024 3:15 AM, Fred. Zwarts wrote: >>>> Op 12.jun.2024 om 21:53 schreef olcott: >>>>> On 6/12/2024 2:46 PM, Fred. Zwarts wrote: >>>>>> Op 12.jun.2024 om 21:20 schreef olcott: >>>>>>> >>>>>>> On 5/29/2021 2:26 PM, olcott wrote: >>>>>>> https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ >>>>>>> >>>>>>> If that was true then you could provide every step of D correctly >>>>>>> simulated by H such that D simulated by H reaches its own simulated >>>>>>> "ret" instruction. >>>>>> >>>>>> I said that each H is unable to hit its target, so how could it >>>>>> reach the "ret" instruction of D? Please, think before you reply. >>>>> >>>>> It is a binary choice either D correctly simulated by H can >>>>> possibly terminate normally by reaching its "ret" instruction >>>>> or not. Your attempt to twist these words to make it look like >>>>> there is more than these two possibilities is either ignorant >>>>> or deceptive. >>>>> >>>> >>>> Please, take some more attention to what I said. Read, then think, >>>> before you reply. >>>> I said that H is not able to reach its own "ret" when it is >>>> simulating itself. >>> >>> That has always been totally irrelevant. >> >> So, you think that if H does not reach its "ret", D can still reach >> its "ret"? >> Try to think. D does not reach its "ret", *because* "H" does not reach >> its "ret". >> >>> >>>> So, no disagreement with that. That proves that H misses its target. >>>> The abort is too early. The target is just some steps further. It >>>> does not mean that the target is at infinity. >>>> >>> >>> The outer H always has one more execution trace to base its halt >>> status decision on than any of the nested emulations. This means >>> that unless the outer H aborts its simulation then none of them do. >> >> That is true. But it also means that H aborts one execution trace too >> early. > > No it never meant this. Yes, it does mean this. Using another simulator shows that even the simulated H reaches its "ret". It is only that H simulated by itself is aborted too early. Is that so difficult to understand for you? > If H waits for some other H to abort their > simulation then H waits forever. There is no other H. This H aborts too early. This H does not wait, so it does not help to dream of another H that waits. H does what it is programmed to do and aborts too early, because that is the fundamental problem of a simulator simulating itself. It will never see its final simulated state. > H is always at least one execution > trace ahead of every other H. Exactly! That is the reason why the abort one execution trace too early. It seems you start to see it. H will never see that it is only some steps from the final state of its simulation, because it aborts before it can see that. That does not mean that there is an infinitely repeated recursion, but that the recursion is only repeated one time more than can be simulated by H. That is the fundamental problem of a simulator simulating itself. You can try to simulate longer, but that does not help. The simulation invariant is that the abort is always one execution trace too early. The other invariant is that in an aborting simulator there is never an infinitely repeated recursion.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-14 07:49 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4he7s$2sdqr$4@dont-email.me> |
| In reply to | #107104 |
On 6/14/2024 4:59 AM, Fred. Zwarts wrote: > Op 13.jun.2024 om 21:41 schreef olcott: >> On 6/13/2024 2:33 PM, Fred. Zwarts wrote: >>> Op 13.jun.2024 om 14:44 schreef olcott: >>>> On 6/13/2024 3:15 AM, Fred. Zwarts wrote: >>>>> Op 12.jun.2024 om 21:53 schreef olcott: >>>>>> On 6/12/2024 2:46 PM, Fred. Zwarts wrote: >>>>>>> Op 12.jun.2024 om 21:20 schreef olcott: >>>>>>>> >>>>>>>> On 5/29/2021 2:26 PM, olcott wrote: >>>>>>>> https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ >>>>>>>> >>>>>>>> If that was true then you could provide every step of D correctly >>>>>>>> simulated by H such that D simulated by H reaches its own simulated >>>>>>>> "ret" instruction. >>>>>>> >>>>>>> I said that each H is unable to hit its target, so how could it >>>>>>> reach the "ret" instruction of D? Please, think before you reply. >>>>>> >>>>>> It is a binary choice either D correctly simulated by H can >>>>>> possibly terminate normally by reaching its "ret" instruction >>>>>> or not. Your attempt to twist these words to make it look like >>>>>> there is more than these two possibilities is either ignorant >>>>>> or deceptive. >>>>>> >>>>> >>>>> Please, take some more attention to what I said. Read, then think, >>>>> before you reply. >>>>> I said that H is not able to reach its own "ret" when it is >>>>> simulating itself. >>>> >>>> That has always been totally irrelevant. >>> >>> So, you think that if H does not reach its "ret", D can still reach >>> its "ret"? >>> Try to think. D does not reach its "ret", *because* "H" does not >>> reach its "ret". >>> >>>> >>>>> So, no disagreement with that. That proves that H misses its >>>>> target. The abort is too early. The target is just some steps >>>>> further. It does not mean that the target is at infinity. >>>>> >>>> >>>> The outer H always has one more execution trace to base its halt >>>> status decision on than any of the nested emulations. This means >>>> that unless the outer H aborts its simulation then none of them do. >>> >>> That is true. But it also means that H aborts one execution trace too >>> early. >> >> No it never meant this. > > Yes, it does mean this. Using another simulator Has a different sequence of configurations thus is not a valid counter-example. > shows that even the > simulated H reaches its "ret". I ran the actual code to verify the facts. HH1(DD,DD) does not have a pathological relationship to its input thus this input terminates normally. HH(DD,DD) does have a pathological relationship to its input thus this input CANNOT POSSIBLY terminate normally. > It is only that H simulated by itself is > aborted too early. Is that so difficult to understand for you? > Aborted too early is false. Unless HH(DD,DD) aborts pretty soon HH and DD crash due to out-of-memory error. >> If H waits for some other H to abort their >> simulation then H waits forever. > > There is no other H. Clearly you hardly understand anything that I have been saying. (a) HH(DD,DD) directly executed in main simulates its input. (b) The simulated DD calls a simulated HH(DD,DD) that (c) simulates another instance of DD... goto (b) HH aborts as soon as it can after seeing DD repeat all of itself states exactly once. If HH waited for fifteen cycles (and did not run out of memory) it would still see one more cycle than the next inner HH. Either the outermost HH aborts or none of them do. >This H aborts too early. This H does not wait, so > it does not help to dream of another H that waits. H does what it is > programmed to do and aborts too early, because that is the fundamental > problem of a simulator simulating itself. It will never see its final > simulated state. > >> H is always at least one execution >> trace ahead of every other H. > > Exactly! That is the reason why the abort one execution trace too early. > It seems you start to see it. H will never see that it is only some > steps from the final state of its simulation, because it aborts before > it can see that. > That does not mean that there is an infinitely repeated recursion, but > that the recursion is only repeated one time more than can be simulated > by H. That is the fundamental problem of a simulator simulating itself. > > You can try to simulate longer, but that does not help. The simulation > invariant is that the abort is always one execution trace too early. The > other invariant is that in an aborting simulator there is never an > infinitely repeated recursion. -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-14 21:00 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4i41a$30e5b$1@dont-email.me> |
| In reply to | #107110 |
Op 14.jun.2024 om 14:49 schreef olcott: > On 6/14/2024 4:59 AM, Fred. Zwarts wrote: >> Op 13.jun.2024 om 21:41 schreef olcott: >>> On 6/13/2024 2:33 PM, Fred. Zwarts wrote: >>>> Op 13.jun.2024 om 14:44 schreef olcott: >>>>> On 6/13/2024 3:15 AM, Fred. Zwarts wrote: >>>>>> Op 12.jun.2024 om 21:53 schreef olcott: >>>>>>> On 6/12/2024 2:46 PM, Fred. Zwarts wrote: >>>>>>>> Op 12.jun.2024 om 21:20 schreef olcott: >>>>>>>>> >>>>>>>>> On 5/29/2021 2:26 PM, olcott wrote: >>>>>>>>> https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ >>>>>>>>> >>>>>>>>> If that was true then you could provide every step of D correctly >>>>>>>>> simulated by H such that D simulated by H reaches its own >>>>>>>>> simulated >>>>>>>>> "ret" instruction. >>>>>>>> >>>>>>>> I said that each H is unable to hit its target, so how could it >>>>>>>> reach the "ret" instruction of D? Please, think before you reply. >>>>>>> >>>>>>> It is a binary choice either D correctly simulated by H can >>>>>>> possibly terminate normally by reaching its "ret" instruction >>>>>>> or not. Your attempt to twist these words to make it look like >>>>>>> there is more than these two possibilities is either ignorant >>>>>>> or deceptive. >>>>>>> >>>>>> >>>>>> Please, take some more attention to what I said. Read, then think, >>>>>> before you reply. >>>>>> I said that H is not able to reach its own "ret" when it is >>>>>> simulating itself. >>>>> >>>>> That has always been totally irrelevant. >>>> >>>> So, you think that if H does not reach its "ret", D can still reach >>>> its "ret"? >>>> Try to think. D does not reach its "ret", *because* "H" does not >>>> reach its "ret". >>>> >>>>> >>>>>> So, no disagreement with that. That proves that H misses its >>>>>> target. The abort is too early. The target is just some steps >>>>>> further. It does not mean that the target is at infinity. >>>>>> >>>>> >>>>> The outer H always has one more execution trace to base its halt >>>>> status decision on than any of the nested emulations. This means >>>>> that unless the outer H aborts its simulation then none of them do. >>>> >>>> That is true. But it also means that H aborts one execution trace >>>> too early. >>> >>> No it never meant this. >> >> Yes, it does mean this. Using another simulator > > Has a different sequence of configurations thus is not > a valid counter-example. > >> shows that even the simulated H reaches its "ret". > > I ran the actual code to verify the facts. > HH1(DD,DD) does not have a pathological relationship to its input > thus this input terminates normally. Your terminology is confusing. What you call a "pathological relationship" is that H must simulate itself. > > HH(DD,DD) does have a pathological relationship to its input > thus this input CANNOT POSSIBLY terminate normally. Yes, indeed! Well done! The input of HH(DD,DD) is aborted too early, because HH cannot possibly simulate itself up to its final state. That means that its simulation cannot terminate normally. > >> It is only that H simulated by itself is aborted too early. Is that so >> difficult to understand for you? >> > Aborted too early is false. > Unless HH(DD,DD) aborts pretty soon HH and DD crash due to > out-of-memory error. > >>> If H waits for some other H to abort their >>> simulation then H waits forever. >> >> There is no other H. > > Clearly you hardly understand anything that I have been saying. > (a) HH(DD,DD) directly executed in main simulates its input. > (b) The simulated DD calls a simulated HH(DD,DD) that > (c) simulates another instance of DD... goto (b) I understand that very well, a, b, c explain why HH is not able to simulate itself up to the end. You are proving my claims. Another way of saying the same thing is: 1) HH starts simulating DD 2) the simulated DD calls HH 3) The simulated HH ... goes 1. Both ways of saying show that DD and HH keep creating new instances of each other. If HH would halt, DD would halt too. But HH does not halt, even though that is a requirement. The reason is that HH is unable to simulate itself up to its final state. That is a limitation of a simulator: it cannot simulate itself up to the end. > HH aborts as soon as it can after seeing DD repeat all of > itself states exactly once. If HH waited for fifteen cycles > (and did not run out of memory) it would still see one > more cycle than the next inner HH. It does not matter whether HH waits one cycle or fifteen cycles. The first HH needs two cycles and the second HH needs 16 cycles to see the end of its simulated input. The invariant is, there is always a finite recursion only one cycle away from the abort and not at infinity. The abort is always one cycle too early. > > Either the outermost HH aborts or none of them do. Yes, that is exactly the problem. Well done! HH is unable to reach the abort of the inner HH, even if it is only one cycle further. You are proving what I said, that HH is unable to simulate itself. The invariant is: there is always a finite recursion only one cycle away from the abort and not at infinity. The abort is always one cycle too early. > >> This H aborts too early. This H does not wait, so it does not help to >> dream of another H that waits. H does what it is programmed to do and >> aborts too early, because that is the fundamental problem of a >> simulator simulating itself. It will never see its final simulated state. >> >>> H is always at least one execution >>> trace ahead of every other H. >> >> Exactly! That is the reason why the abort one execution trace too >> early. It seems you start to see it. H will never see that it is only >> some steps from the final state of its simulation, because it aborts >> before it can see that. >> That does not mean that there is an infinitely repeated recursion, but >> that the recursion is only repeated one time more than can be >> simulated by H. That is the fundamental problem of a simulator >> simulating itself. >> >> You can try to simulate longer, but that does not help. The simulation >> invariant is that the abort is always one execution trace too early. >> The other invariant is that in an aborting simulator there is never an >> infinitely repeated recursion. >
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-14 14:18 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4i52u$30usa$1@dont-email.me> |
| In reply to | #107115 |
On 6/14/2024 2:00 PM, Fred. Zwarts wrote: > Op 14.jun.2024 om 14:49 schreef olcott: >> I ran the actual code to verify the facts. >> HH1(DD,DD) does not have a pathological relationship to its input >> thus this input terminates normally. > > Your terminology is confusing. What you call a "pathological > relationship" is that H must simulate itself. > *CONVENTIONAL TERMINOLOGY* For any program H that might determine whether programs halt, a "pathological" program D, called with some input, can pass its own source and its input to H and then specifically do the opposite of what H predicts D will do. No H can exist that handles this case. https://en.wikipedia.org/wiki/Halting_problem >> >> HH(DD,DD) does have a pathological relationship to its input >> thus this input CANNOT POSSIBLY terminate normally. > > Yes, indeed! Well done! The input of HH(DD,DD) is aborted too early, If the input is never aborted THEN IT NEVER TERMINATES. your coding skills must not be very good. > because HH cannot possibly simulate itself up to its final state. That > means that its simulation cannot terminate normally. > *It is D that calls H in recursive simulation* >> >>> It is only that H simulated by itself is aborted too early. Is that >>> so difficult to understand for you? >>> >> Aborted too early is false. >> Unless HH(DD,DD) aborts pretty soon HH and DD crash due to >> out-of-memory error. >> >>>> If H waits for some other H to abort their >>>> simulation then H waits forever. >>> >>> There is no other H. >> >> Clearly you hardly understand anything that I have been saying. >> (a) HH(DD,DD) directly executed in main simulates its input. >> (b) The simulated DD calls a simulated HH(DD,DD) that >> (c) simulates another instance of DD... goto (b) > I understand that very well, a, b, c explain why HH is not able to > simulate itself up to the end. You are proving my claims. > > Another way of saying the same thing is: > 1) HH starts simulating DD Until H sees that D correctly simulated by H cannot possibly terminate normally. -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-14 22:03 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4i7ne$311i2$1@dont-email.me> |
| In reply to | #107116 |
Op 14.jun.2024 om 21:18 schreef olcott:
> On 6/14/2024 2:00 PM, Fred. Zwarts wrote:
>> Op 14.jun.2024 om 14:49 schreef olcott:
>>> I ran the actual code to verify the facts.
>>> HH1(DD,DD) does not have a pathological relationship to its input
>>> thus this input terminates normally.
>>
>> Your terminology is confusing. What you call a "pathological
>> relationship" is that H must simulate itself.
>>
>
> *CONVENTIONAL TERMINOLOGY*
> For any program H that might determine whether programs halt, a
> "pathological" program D, called with some input, can pass its own
> source and its input to H and then specifically do the opposite of what
> H predicts D will do. No H can exist that handles this case.
> https://en.wikipedia.org/wiki/Halting_problem
The problem is that your simulator does not even reach the
"pathological" part of D. Further that every program that uses H has the
same problem. E.G.,
int main()
{
return H(main, 0);
}
It has no "pathological" part that does the opposite of what H returns.
But it has the same problem that H reports that it is not halting,
because H is trying to simulate itself.
Since the pathological part of D does not play a role in your claim, it
is less confusing to name the problem "H simulating itself".
>
>>>
>>> HH(DD,DD) does have a pathological relationship to its input
>>> thus this input CANNOT POSSIBLY terminate normally.
>>
>> Yes, indeed! Well done! The input of HH(DD,DD) is aborted too early,
>
> If the input is never aborted THEN IT NEVER TERMINATES.
(personal attach ignored)
Yes indeed! Very clever of you!
But it is aborted! Unfortunately, one cycle too early, one cycle before
it would see the abort of the simulated H. So, dreaming of an H that
never aborts does not tell us anything about the H that aborts.
>
>> because HH cannot possibly simulate itself up to its final state. That
>> means that its simulation cannot terminate normally.
>>
>
> *It is D that calls H in recursive simulation*
*And* it is H that starts new simulations of D in recursion. If the
simulated H would halt (as required), D would return.
It is a pity for H, but it is programmed to do that (and for a
simulator, there is probably no better way), so it will never see the
end of its own simulation and the return to D, let alone that it would
see the "pathological" part of D.
>
>>>
>>>> It is only that H simulated by itself is aborted too early. Is that
>>>> so difficult to understand for you?
>>>>
>>> Aborted too early is false.
>>> Unless HH(DD,DD) aborts pretty soon HH and DD crash due to
>>> out-of-memory error.
>>>
>>>>> If H waits for some other H to abort their
>>>>> simulation then H waits forever.
>>>>
>>>> There is no other H.
>>>
>>> Clearly you hardly understand anything that I have been saying.
>>> (a) HH(DD,DD) directly executed in main simulates its input.
>>> (b) The simulated DD calls a simulated HH(DD,DD) that
>>> (c) simulates another instance of DD... goto (b)
>> I understand that very well, a, b, c explain why HH is not able to
>> simulate itself up to the end. You are proving my claims.
>>
>> Another way of saying the same thing is:
>> 1) HH starts simulating DD
>
> Until H sees that D correctly simulated by H cannot
> possibly terminate normally.
Because H is unable to simulate itself correctly up to its final state.
So, since we seem to agree that a correct simulation of H by H would not
terminate, the only escape is an incorrect simulation which aborts the
simulation.
Unfortunately, this incorrect simulation aborts one cycle too early and
therefore misses the part where the simulated H would abort, return to
the "pathological" part of D and D would halt.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-14 15:46 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4ia6l$31vjj$1@dont-email.me> |
| In reply to | #107117 |
On 6/14/2024 3:03 PM, Fred. Zwarts wrote: > Op 14.jun.2024 om 21:18 schreef olcott: >> On 6/14/2024 2:00 PM, Fred. Zwarts wrote: >>> Op 14.jun.2024 om 14:49 schreef olcott: >>>> I ran the actual code to verify the facts. >>>> HH1(DD,DD) does not have a pathological relationship to its input >>>> thus this input terminates normally. >>> >>> Your terminology is confusing. What you call a "pathological >>> relationship" is that H must simulate itself. >>> >> >> *CONVENTIONAL TERMINOLOGY* >> For any program H that might determine whether programs halt, a >> "pathological" program D, called with some input, can pass its own >> source and its input to H and then specifically do the opposite of what >> H predicts D will do. No H can exist that handles this case. >> https://en.wikipedia.org/wiki/Halting_problem > > The problem is that your simulator does not even reach the > "pathological" part of D. That is not the problem that is the criterion measure of a solution. _D() [00000cfc](01) 55 push ebp [00000cfd](02) 8bec mov ebp,esp [00000cff](03) 8b4508 mov eax,[ebp+08] [00000d02](01) 50 push eax ; push D [00000d03](03) 8b4d08 mov ecx,[ebp+08] [00000d06](01) 51 push ecx ; push D [00000d07](05) e800feffff call 00000b0c ; call H [00000d0c](03) 83c408 add esp,+08 [00000d0f](02) 85c0 test eax,eax [00000d11](02) 7404 jz 00000d17 [00000d13](02) 33c0 xor eax,eax [00000d15](02) eb05 jmp 00000d1c [00000d17](05) b801000000 mov eax,00000001 [00000d1c](01) 5d pop ebp [00000d1d](01) c3 ret Size in bytes:(0034) [00000d1d] This is just over-your-head. I give up. -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-15 11:03 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4jlds$3cq2s$1@dont-email.me> |
| In reply to | #107118 |
Op 14.jun.2024 om 22:46 schreef olcott:
> On 6/14/2024 3:03 PM, Fred. Zwarts wrote:
>> Op 14.jun.2024 om 21:18 schreef olcott:
>>> On 6/14/2024 2:00 PM, Fred. Zwarts wrote:
>>>> Op 14.jun.2024 om 14:49 schreef olcott:
>>>>> I ran the actual code to verify the facts.
>>>>> HH1(DD,DD) does not have a pathological relationship to its input
>>>>> thus this input terminates normally.
>>>>
>>>> Your terminology is confusing. What you call a "pathological
>>>> relationship" is that H must simulate itself.
>>>>
>>>
>>> *CONVENTIONAL TERMINOLOGY*
>>> For any program H that might determine whether programs halt, a
>>> "pathological" program D, called with some input, can pass its own
>>> source and its input to H and then specifically do the opposite of what
>>> H predicts D will do. No H can exist that handles this case.
>>> https://en.wikipedia.org/wiki/Halting_problem
>>
>> The problem is that your simulator does not even reach the
>> "pathological" part of D.
>
> That is not the problem that is the criterion measure of a solution.
You are using the wrong criterion, because this wrong criterion also
also applies to other programs, without a "pathological" part.
int main()
{
return H(main, 0);
}
where you proved that H reports a false negative.
So, your criterion has no relation with "pathological" programs.
>
> _D()
> [00000cfc](01) 55 push ebp
> [00000cfd](02) 8bec mov ebp,esp
> [00000cff](03) 8b4508 mov eax,[ebp+08]
> [00000d02](01) 50 push eax ; push D
> [00000d03](03) 8b4d08 mov ecx,[ebp+08]
> [00000d06](01) 51 push ecx ; push D
> [00000d07](05) e800feffff call 00000b0c ; call H
> [00000d0c](03) 83c408 add esp,+08
> [00000d0f](02) 85c0 test eax,eax
> [00000d11](02) 7404 jz 00000d17
> [00000d13](02) 33c0 xor eax,eax
> [00000d15](02) eb05 jmp 00000d1c
> [00000d17](05) b801000000 mov eax,00000001
> [00000d1c](01) 5d pop ebp
> [00000d1d](01) c3 ret
> Size in bytes:(0034) [00000d1d]
Nice try, but completely beside the point.
Are you really unable to see this has no relation with a "pathological"
program that contradicts the result of H?
The only thing you have done so far is proving that no H exists that
correctly simulates itself up to its final state and therefore it is
unable to see the full behaviour of its input, because it always
prematurely aborts the simulation one cycle too early.
If you don't understand such simple facts, discussion makes no sense.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-15 07:12 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4k0fc$3f0hc$1@dont-email.me> |
| In reply to | #107147 |
On 6/15/2024 4:03 AM, Fred. Zwarts wrote:
> Op 14.jun.2024 om 22:46 schreef olcott:
>> On 6/14/2024 3:03 PM, Fred. Zwarts wrote:
>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>> On 6/14/2024 2:00 PM, Fred. Zwarts wrote:
>>>>> Op 14.jun.2024 om 14:49 schreef olcott:
>>>>>> I ran the actual code to verify the facts.
>>>>>> HH1(DD,DD) does not have a pathological relationship to its input
>>>>>> thus this input terminates normally.
>>>>>
>>>>> Your terminology is confusing. What you call a "pathological
>>>>> relationship" is that H must simulate itself.
>>>>>
>>>>
>>>> *CONVENTIONAL TERMINOLOGY*
>>>> For any program H that might determine whether programs halt, a
>>>> "pathological" program D, called with some input, can pass its own
>>>> source and its input to H and then specifically do the opposite of what
>>>> H predicts D will do. No H can exist that handles this case.
>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>
>>> The problem is that your simulator does not even reach the
>>> "pathological" part of D.
>>
>> That is not the problem that is the criterion measure of a solution.
>
> You are using the wrong criterion, because this wrong criterion also
> also applies to other programs, without a "pathological" part.
>
> int main()
> {
> return H(main, 0);
> }
>
> where you proved that H reports a false negative.
>
> So, your criterion has no relation with "pathological" programs.
>
This criteria works correctly for ALL input, including pathological
main(). Maybe if you were a PhD computer science professor you would
understand this.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>>
>> _D()
>> [00000cfc](01) 55 push ebp
>> [00000cfd](02) 8bec mov ebp,esp
>> [00000cff](03) 8b4508 mov eax,[ebp+08]
>> [00000d02](01) 50 push eax ; push D
>> [00000d03](03) 8b4d08 mov ecx,[ebp+08]
>> [00000d06](01) 51 push ecx ; push D
>> [00000d07](05) e800feffff call 00000b0c ; call H
>> [00000d0c](03) 83c408 add esp,+08
>> [00000d0f](02) 85c0 test eax,eax
>> [00000d11](02) 7404 jz 00000d17
>> [00000d13](02) 33c0 xor eax,eax
>> [00000d15](02) eb05 jmp 00000d1c
>> [00000d17](05) b801000000 mov eax,00000001
>> [00000d1c](01) 5d pop ebp
>> [00000d1d](01) c3 ret
>> Size in bytes:(0034) [00000d1d]
>
> Nice try, but completely beside the point.
> Are you really unable to see this has no relation with a "pathological"
> program that contradicts the result of H?
>
> The only thing you have done so far is proving that no H exists that
> correctly simulates itself up to its final state and therefore it is
> unable to see the full behaviour of its input, because it always
> prematurely aborts the simulation one cycle too early.
>
> If you don't understand such simple facts, discussion makes no sense.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-15 09:51 -0400 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4k69m$2218$4@i2pn2.org> |
| In reply to | #107156 |
On 6/15/24 8:12 AM, olcott wrote:
> On 6/15/2024 4:03 AM, Fred. Zwarts wrote:
>> Op 14.jun.2024 om 22:46 schreef olcott:
>>> On 6/14/2024 3:03 PM, Fred. Zwarts wrote:
>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>> On 6/14/2024 2:00 PM, Fred. Zwarts wrote:
>>>>>> Op 14.jun.2024 om 14:49 schreef olcott:
>>>>>>> I ran the actual code to verify the facts.
>>>>>>> HH1(DD,DD) does not have a pathological relationship to its input
>>>>>>> thus this input terminates normally.
>>>>>>
>>>>>> Your terminology is confusing. What you call a "pathological
>>>>>> relationship" is that H must simulate itself.
>>>>>>
>>>>>
>>>>> *CONVENTIONAL TERMINOLOGY*
>>>>> For any program H that might determine whether programs halt, a
>>>>> "pathological" program D, called with some input, can pass its own
>>>>> source and its input to H and then specifically do the opposite of
>>>>> what
>>>>> H predicts D will do. No H can exist that handles this case.
>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>
>>>> The problem is that your simulator does not even reach the
>>>> "pathological" part of D.
>>>
>>> That is not the problem that is the criterion measure of a solution.
>>
>> You are using the wrong criterion, because this wrong criterion also
>> also applies to other programs, without a "pathological" part.
>>
>> int main()
>> {
>> return H(main, 0);
>> }
>>
>> where you proved that H reports a false negative.
>>
>> So, your criterion has no relation with "pathological" programs.
>>
>
> This criteria works correctly for ALL input, including pathological
> main(). Maybe if you were a PhD computer science professor you would
> understand this.
>
> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
> If simulating halt decider H correctly simulates its input D
> until H correctly determines that its simulated D would never
> stop running unless aborted then
>
> H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>
>
But since Professor Sipser mens by "A correct simulaiton: a simulation
that actually reflects the behavior of the direct execution of the
input, which means a simulation that NEVER aborts its operation until it
reaches a final state, and H doesn't show that, or correctly that that
sort of simulation of *THIS* input wouldn't halt (since D(D) Halts since
H(D,D) returns 0) H can't use the first paragraph (whose conditions are
not satisfied) to do the operations of the second, which it does anyway,
and thus makes itself wrong.
And shows you to be an ignorant liar.
>
>>>
>>> _D()
>>> [00000cfc](01) 55 push ebp
>>> [00000cfd](02) 8bec mov ebp,esp
>>> [00000cff](03) 8b4508 mov eax,[ebp+08]
>>> [00000d02](01) 50 push eax ; push D
>>> [00000d03](03) 8b4d08 mov ecx,[ebp+08]
>>> [00000d06](01) 51 push ecx ; push D
>>> [00000d07](05) e800feffff call 00000b0c ; call H
>>> [00000d0c](03) 83c408 add esp,+08
>>> [00000d0f](02) 85c0 test eax,eax
>>> [00000d11](02) 7404 jz 00000d17
>>> [00000d13](02) 33c0 xor eax,eax
>>> [00000d15](02) eb05 jmp 00000d1c
>>> [00000d17](05) b801000000 mov eax,00000001
>>> [00000d1c](01) 5d pop ebp
>>> [00000d1d](01) c3 ret
>>> Size in bytes:(0034) [00000d1d]
>>
>> Nice try, but completely beside the point.
>> Are you really unable to see this has no relation with a
>> "pathological" program that contradicts the result of H?
>>
>> The only thing you have done so far is proving that no H exists that
>> correctly simulates itself up to its final state and therefore it is
>> unable to see the full behaviour of its input, because it always
>> prematurely aborts the simulation one cycle too early.
>>
>> If you don't understand such simple facts, discussion makes no sense.
>
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-15 16:06 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4k74f$3g29j$1@dont-email.me> |
| In reply to | #107156 |
Op 15.jun.2024 om 14:12 schreef olcott:
> On 6/15/2024 4:03 AM, Fred. Zwarts wrote:
>> Op 14.jun.2024 om 22:46 schreef olcott:
>>> On 6/14/2024 3:03 PM, Fred. Zwarts wrote:
>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>> On 6/14/2024 2:00 PM, Fred. Zwarts wrote:
>>>>>> Op 14.jun.2024 om 14:49 schreef olcott:
>>>>>>> I ran the actual code to verify the facts.
>>>>>>> HH1(DD,DD) does not have a pathological relationship to its input
>>>>>>> thus this input terminates normally.
>>>>>>
>>>>>> Your terminology is confusing. What you call a "pathological
>>>>>> relationship" is that H must simulate itself.
>>>>>>
>>>>>
>>>>> *CONVENTIONAL TERMINOLOGY*
>>>>> For any program H that might determine whether programs halt, a
>>>>> "pathological" program D, called with some input, can pass its own
>>>>> source and its input to H and then specifically do the opposite of
>>>>> what
>>>>> H predicts D will do. No H can exist that handles this case.
>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>
>>>> The problem is that your simulator does not even reach the
>>>> "pathological" part of D.
>>>
>>> That is not the problem that is the criterion measure of a solution.
>>
>> You are using the wrong criterion, because this wrong criterion also
>> also applies to other programs, without a "pathological" part.
>>
>> int main()
>> {
>> return H(main, 0);
>> }
>>
>> where you proved that H reports a false negative.
>>
>> So, your criterion has no relation with "pathological" programs.
>>
>
> This criteria works correctly for ALL input, including pathological
> main().
You are twisting your own words,because main is not "pathological".
You do not even understand you own definition of "pathological":
Op 14.jun.2024 om 21:18 schreef olcott:
>
> *CONVENTIONAL TERMINOLOGY*
> For any program H that might determine whether programs halt, a
> "pathological" program D, called with some input, can pass its own
> source and its input to H and then specifically do the opposite of what
> H predicts D will do. No H can exist that handles this case.
No high level programming skills are needed to see that there is no part
where main 'then specifically do the opposite of what H predicts it will
do'.
It seems that you are changing the definition of "pathological" to 'any
program for which H returns a false negative', which then becomes a
tautology.
> Maybe if you were a PhD computer science professor you would
> understand this.
Many people without a PhD understand your are continuously changing
definitions. No PhD needed. I am sorry for you if you don't grasp it.
(Btw, I never refer to my PhD, because I think arguments should
convince, not authority.)
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-15 09:13 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4k7he$3gc4t$1@dont-email.me> |
| In reply to | #107179 |
On 6/15/2024 9:06 AM, Fred. Zwarts wrote:
> Op 15.jun.2024 om 14:12 schreef olcott:
>> On 6/15/2024 4:03 AM, Fred. Zwarts wrote:
>>> Op 14.jun.2024 om 22:46 schreef olcott:
>>>> On 6/14/2024 3:03 PM, Fred. Zwarts wrote:
>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>> On 6/14/2024 2:00 PM, Fred. Zwarts wrote:
>>>>>>> Op 14.jun.2024 om 14:49 schreef olcott:
>>>>>>>> I ran the actual code to verify the facts.
>>>>>>>> HH1(DD,DD) does not have a pathological relationship to its input
>>>>>>>> thus this input terminates normally.
>>>>>>>
>>>>>>> Your terminology is confusing. What you call a "pathological
>>>>>>> relationship" is that H must simulate itself.
>>>>>>>
>>>>>>
>>>>>> *CONVENTIONAL TERMINOLOGY*
>>>>>> For any program H that might determine whether programs halt, a
>>>>>> "pathological" program D, called with some input, can pass its own
>>>>>> source and its input to H and then specifically do the opposite of
>>>>>> what
>>>>>> H predicts D will do. No H can exist that handles this case.
>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>
>>>>> The problem is that your simulator does not even reach the
>>>>> "pathological" part of D.
>>>>
>>>> That is not the problem that is the criterion measure of a solution.
>>>
>>> You are using the wrong criterion, because this wrong criterion also
>>> also applies to other programs, without a "pathological" part.
>>>
>>> int main()
>>> {
>>> return H(main, 0);
>>> }
>>>
>>> where you proved that H reports a false negative.
>>>
>>> So, your criterion has no relation with "pathological" programs.
>>>
>>
>> This criteria works correctly for ALL input, including pathological
>> main().
>
> You are twisting your own words,because main is not "pathological".
> You do not even understand you own definition of "pathological":
>
> Op 14.jun.2024 om 21:18 schreef olcott:
>>
>> *CONVENTIONAL TERMINOLOGY*
>> For any program H that might determine whether programs halt, a
>> "pathological" program D, called with some input, can pass its own
>> source and its input to H and then specifically do the opposite of what
>> H predicts D will do. No H can exist that handles this case.
>
> No high level programming skills are needed to see that there is no part
> where main 'then specifically do the opposite of what H predicts it will
> do'.
>
> It seems that you are changing the definition of "pathological" to 'any
> program for which H returns a false negative', which then becomes a
> tautology.
>
Any function that calls H specifies recursive simulation.
>> Maybe if you were a PhD computer science professor you would
>> understand this.
>
> Many people without a PhD understand your are continuously changing
> definitions. No PhD needed. I am sorry for you if you don't grasp it.
> (Btw, I never refer to my PhD, because I think arguments should
> convince, not authority.)
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-15 10:29 -0400 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4k8fh$2218$13@i2pn2.org> |
| In reply to | #107180 |
On 6/15/24 10:13 AM, olcott wrote:
> On 6/15/2024 9:06 AM, Fred. Zwarts wrote:
>> Op 15.jun.2024 om 14:12 schreef olcott:
>>> On 6/15/2024 4:03 AM, Fred. Zwarts wrote:
>>>> Op 14.jun.2024 om 22:46 schreef olcott:
>>>>> On 6/14/2024 3:03 PM, Fred. Zwarts wrote:
>>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>>> On 6/14/2024 2:00 PM, Fred. Zwarts wrote:
>>>>>>>> Op 14.jun.2024 om 14:49 schreef olcott:
>>>>>>>>> I ran the actual code to verify the facts.
>>>>>>>>> HH1(DD,DD) does not have a pathological relationship to its input
>>>>>>>>> thus this input terminates normally.
>>>>>>>>
>>>>>>>> Your terminology is confusing. What you call a "pathological
>>>>>>>> relationship" is that H must simulate itself.
>>>>>>>>
>>>>>>>
>>>>>>> *CONVENTIONAL TERMINOLOGY*
>>>>>>> For any program H that might determine whether programs halt, a
>>>>>>> "pathological" program D, called with some input, can pass its own
>>>>>>> source and its input to H and then specifically do the opposite
>>>>>>> of what
>>>>>>> H predicts D will do. No H can exist that handles this case.
>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>
>>>>>> The problem is that your simulator does not even reach the
>>>>>> "pathological" part of D.
>>>>>
>>>>> That is not the problem that is the criterion measure of a solution.
>>>>
>>>> You are using the wrong criterion, because this wrong criterion also
>>>> also applies to other programs, without a "pathological" part.
>>>>
>>>> int main()
>>>> {
>>>> return H(main, 0);
>>>> }
>>>>
>>>> where you proved that H reports a false negative.
>>>>
>>>> So, your criterion has no relation with "pathological" programs.
>>>>
>>>
>>> This criteria works correctly for ALL input, including pathological
>>> main().
>>
>> You are twisting your own words,because main is not "pathological".
>> You do not even understand you own definition of "pathological":
>>
>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>
>>> *CONVENTIONAL TERMINOLOGY*
>>> For any program H that might determine whether programs halt, a
>>> "pathological" program D, called with some input, can pass its own
>>> source and its input to H and then specifically do the opposite of what
>>> H predicts D will do. No H can exist that handles this case.
>>
>> No high level programming skills are needed to see that there is no
>> part where main 'then specifically do the opposite of what H predicts
>> it will do'.
>>
>> It seems that you are changing the definition of "pathological" to
>> 'any program for which H returns a false negative', which then becomes
>> a tautology.
>>
>
> Any function that calls H specifies recursive simulation.
But not necessarily INFINITE recursive simulation.
For example:
int test(ptr x) {
return 0;
}
int infinite_loop(ptr x) {
while(1) continue;
return 0;
}
int D0(ptr x) {
H(test, test);
return 1;
}
int main() {
H(D0,D0);
return 0;
}
are you claiming that just because D calls H(test,test) that this makes
D non-halting due to recursive simulation?
OR if D instead calls H on infinite_loop that H has been programmed to
detect makes D non-halting due to recursive simulation.
Basic principle, if D calls H on an input that H will eather be able to
simulate to the end, or that H decides to abort its simulation of, such
a call should not be indication of "non-halting" behavior.
the call to H(test, test) or H(infinite_loop, infinite_loop) are not
fundamentally different than the call the H(D0,D0) on this basis.
And thus for the above non-pathological D0, it should be expected that
H, if it is a proper decider, should be able to get the answer, since it
is possible.
The fact that you H never get to the point of seeing the difference
between non-pathological D0 and the pathological D means that H isn't
doing the best job it can. and maybe your approach is just flawed.
Thus, we show that the mear fact that D calls H(D,D) is NOT by itself
proper ground for calling the input non-halting, but is based on
INCORRECT LOGIC.
>
>>> Maybe if you were a PhD computer science professor you would
>>> understand this.
>>
>> Many people without a PhD understand your are continuously changing
>> definitions. No PhD needed. I am sorry for you if you don't grasp it.
>> (Btw, I never refer to my PhD, because I think arguments should
>> convince, not authority.)
>
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-15 16:37 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4k8us$3g29j$3@dont-email.me> |
| In reply to | #107180 |
Op 15.jun.2024 om 16:13 schreef olcott:
> On 6/15/2024 9:06 AM, Fred. Zwarts wrote:
>> Op 15.jun.2024 om 14:12 schreef olcott:
>>> On 6/15/2024 4:03 AM, Fred. Zwarts wrote:
>>>> Op 14.jun.2024 om 22:46 schreef olcott:
>>>>> On 6/14/2024 3:03 PM, Fred. Zwarts wrote:
>>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>>> On 6/14/2024 2:00 PM, Fred. Zwarts wrote:
>>>>>>>> Op 14.jun.2024 om 14:49 schreef olcott:
>>>>>>>>> I ran the actual code to verify the facts.
>>>>>>>>> HH1(DD,DD) does not have a pathological relationship to its input
>>>>>>>>> thus this input terminates normally.
>>>>>>>>
>>>>>>>> Your terminology is confusing. What you call a "pathological
>>>>>>>> relationship" is that H must simulate itself.
>>>>>>>>
>>>>>>>
>>>>>>> *CONVENTIONAL TERMINOLOGY*
>>>>>>> For any program H that might determine whether programs halt, a
>>>>>>> "pathological" program D, called with some input, can pass its own
>>>>>>> source and its input to H and then specifically do the opposite
>>>>>>> of what
>>>>>>> H predicts D will do. No H can exist that handles this case.
>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>
>>>>>> The problem is that your simulator does not even reach the
>>>>>> "pathological" part of D.
>>>>>
>>>>> That is not the problem that is the criterion measure of a solution.
>>>>
>>>> You are using the wrong criterion, because this wrong criterion also
>>>> also applies to other programs, without a "pathological" part.
>>>>
>>>> int main()
>>>> {
>>>> return H(main, 0);
>>>> }
>>>>
>>>> where you proved that H reports a false negative.
>>>>
>>>> So, your criterion has no relation with "pathological" programs.
>>>>
>>>
>>> This criteria works correctly for ALL input, including pathological
>>> main().
>>
>> You are twisting your own words,because main is not "pathological".
>> You do not even understand you own definition of "pathological":
>>
>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>
>>> *CONVENTIONAL TERMINOLOGY*
>>> For any program H that might determine whether programs halt, a
>>> "pathological" program D, called with some input, can pass its own
>>> source and its input to H and then specifically do the opposite of what
>>> H predicts D will do. No H can exist that handles this case.
>>
>> No high level programming skills are needed to see that there is no
>> part where main 'then specifically do the opposite of what H predicts
>> it will do'.
>>
>> It seems that you are changing the definition of "pathological" to
>> 'any program for which H returns a false negative', which then becomes
>> a tautology.
>>
>
> Any function that calls H specifies recursive simulation.
Is this the new definition of "pathological"?
Again a change of definition. No words any more about doing the opposite
of what H predicts. Words you used in the definition only a few lines
above have disappeared.
So, with this new definition, we agree that the fact that D does the
opposite of what H returns is irrelevant.
This means that you only prove that there are programs that halt, for
which the simulation by H does not reach its final state, because H is
unable to reach its own simulated final state. H then aborts and reports
non-halting. A false negative.
Further, it is not the function that specifies recursive simulation. The
function does not even know about recursion. It is H that starts the
recursive simulation, with the effect that its must simulate itself.
More important, it does not specify infinite recursion. Only if H does
not halt, as required, an infinite recursion happens.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-15 09:48 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4k9kk$3gc4t$6@dont-email.me> |
| In reply to | #107185 |
On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
> Op 15.jun.2024 om 16:13 schreef olcott:
>> On 6/15/2024 9:06 AM, Fred. Zwarts wrote:
>>> Op 15.jun.2024 om 14:12 schreef olcott:
>>>> On 6/15/2024 4:03 AM, Fred. Zwarts wrote:
>>>>> Op 14.jun.2024 om 22:46 schreef olcott:
>>>>>> On 6/14/2024 3:03 PM, Fred. Zwarts wrote:
>>>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>>>> On 6/14/2024 2:00 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 14.jun.2024 om 14:49 schreef olcott:
>>>>>>>>>> I ran the actual code to verify the facts.
>>>>>>>>>> HH1(DD,DD) does not have a pathological relationship to its input
>>>>>>>>>> thus this input terminates normally.
>>>>>>>>>
>>>>>>>>> Your terminology is confusing. What you call a "pathological
>>>>>>>>> relationship" is that H must simulate itself.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *CONVENTIONAL TERMINOLOGY*
>>>>>>>> For any program H that might determine whether programs halt, a
>>>>>>>> "pathological" program D, called with some input, can pass its own
>>>>>>>> source and its input to H and then specifically do the opposite
>>>>>>>> of what
>>>>>>>> H predicts D will do. No H can exist that handles this case.
>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>
>>>>>>> The problem is that your simulator does not even reach the
>>>>>>> "pathological" part of D.
>>>>>>
>>>>>> That is not the problem that is the criterion measure of a solution.
>>>>>
>>>>> You are using the wrong criterion, because this wrong criterion
>>>>> also also applies to other programs, without a "pathological" part.
>>>>>
>>>>> int main()
>>>>> {
>>>>> return H(main, 0);
>>>>> }
>>>>>
>>>>> where you proved that H reports a false negative.
>>>>>
>>>>> So, your criterion has no relation with "pathological" programs.
>>>>>
>>>>
>>>> This criteria works correctly for ALL input, including pathological
>>>> main().
>>>
>>> You are twisting your own words,because main is not "pathological".
>>> You do not even understand you own definition of "pathological":
>>>
>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>
>>>> *CONVENTIONAL TERMINOLOGY*
>>>> For any program H that might determine whether programs halt, a
>>>> "pathological" program D, called with some input, can pass its own
>>>> source and its input to H and then specifically do the opposite of what
>>>> H predicts D will do. No H can exist that handles this case.
>>>
>>> No high level programming skills are needed to see that there is no
>>> part where main 'then specifically do the opposite of what H predicts
>>> it will do'.
>>>
>>> It seems that you are changing the definition of "pathological" to
>>> 'any program for which H returns a false negative', which then
>>> becomes a tautology.
>>>
>>
>> Any function that calls H specifies recursive simulation.
>
> Is this the new definition of "pathological"?
*It is the same thing that I have been saying all along*
00 typedef void (*ptr)(); // pointer to void function
01
02 int HH(ptr P, ptr I);
03
04 void DDD(int (*x)())
05 {
06 HH(x, x);
07 return;
08 }
09
10 int main()
11 {
12 HH(DDD,DDD);
13 }
Line 12 main()
invokes HH(DDD,DDD); that simulates DDD()
*REPEAT UNTIL outer HH aborts*
Line 06 simulated DDD()
invokes simulated HH(DDD,DDD); that simulates DDD()
DDD correctly simulated by HH never reaches its own "return"
instruction and halts.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-15 11:02 -0400 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4kae8$2219$3@i2pn2.org> |
| In reply to | #107190 |
On 6/15/24 10:48 AM, olcott wrote:
> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>> Op 15.jun.2024 om 16:13 schreef olcott:
>>> On 6/15/2024 9:06 AM, Fred. Zwarts wrote:
>>>> Op 15.jun.2024 om 14:12 schreef olcott:
>>>>> On 6/15/2024 4:03 AM, Fred. Zwarts wrote:
>>>>>> Op 14.jun.2024 om 22:46 schreef olcott:
>>>>>>> On 6/14/2024 3:03 PM, Fred. Zwarts wrote:
>>>>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>>>>> On 6/14/2024 2:00 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 14.jun.2024 om 14:49 schreef olcott:
>>>>>>>>>>> I ran the actual code to verify the facts.
>>>>>>>>>>> HH1(DD,DD) does not have a pathological relationship to its
>>>>>>>>>>> input
>>>>>>>>>>> thus this input terminates normally.
>>>>>>>>>>
>>>>>>>>>> Your terminology is confusing. What you call a "pathological
>>>>>>>>>> relationship" is that H must simulate itself.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *CONVENTIONAL TERMINOLOGY*
>>>>>>>>> For any program H that might determine whether programs halt, a
>>>>>>>>> "pathological" program D, called with some input, can pass its own
>>>>>>>>> source and its input to H and then specifically do the opposite
>>>>>>>>> of what
>>>>>>>>> H predicts D will do. No H can exist that handles this case.
>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>
>>>>>>>> The problem is that your simulator does not even reach the
>>>>>>>> "pathological" part of D.
>>>>>>>
>>>>>>> That is not the problem that is the criterion measure of a solution.
>>>>>>
>>>>>> You are using the wrong criterion, because this wrong criterion
>>>>>> also also applies to other programs, without a "pathological" part.
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> return H(main, 0);
>>>>>> }
>>>>>>
>>>>>> where you proved that H reports a false negative.
>>>>>>
>>>>>> So, your criterion has no relation with "pathological" programs.
>>>>>>
>>>>>
>>>>> This criteria works correctly for ALL input, including pathological
>>>>> main().
>>>>
>>>> You are twisting your own words,because main is not "pathological".
>>>> You do not even understand you own definition of "pathological":
>>>>
>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>
>>>>> *CONVENTIONAL TERMINOLOGY*
>>>>> For any program H that might determine whether programs halt, a
>>>>> "pathological" program D, called with some input, can pass its own
>>>>> source and its input to H and then specifically do the opposite of
>>>>> what
>>>>> H predicts D will do. No H can exist that handles this case.
>>>>
>>>> No high level programming skills are needed to see that there is no
>>>> part where main 'then specifically do the opposite of what H
>>>> predicts it will do'.
>>>>
>>>> It seems that you are changing the definition of "pathological" to
>>>> 'any program for which H returns a false negative', which then
>>>> becomes a tautology.
>>>>
>>>
>>> Any function that calls H specifies recursive simulation.
>>
>> Is this the new definition of "pathological"?
>
> *It is the same thing that I have been saying all along*
>
> 00 typedef void (*ptr)(); // pointer to void function
> 01
> 02 int HH(ptr P, ptr I);
> 03
> 04 void DDD(int (*x)())
> 05 {
> 06 HH(x, x);
> 07 return;
> 08 }
> 09
> 10 int main()
> 11 {
> 12 HH(DDD,DDD);
> 13 }
>
> Line 12 main()
> invokes HH(DDD,DDD); that simulates DDD()
>
> *REPEAT UNTIL outer HH aborts*
> Line 06 simulated DDD()
> invokes simulated HH(DDD,DDD); that simulates DDD()
But that also means that when the input program is run, the HH called by
DDD will ALSO abort and return 0, so the input is properly halting.
>
> DDD correctly simulated by HH never reaches its own "return"
> instruction and halts.
>
So it Halts but doesn't POOP.
Maybe your HH is a proper POOP decider, but who cares.
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-15 17:12 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4kb18$3gpbj$1@dont-email.me> |
| In reply to | #107190 |
Op 15.jun.2024 om 16:48 schreef olcott:
> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>> Op 15.jun.2024 om 16:13 schreef olcott:
>>> On 6/15/2024 9:06 AM, Fred. Zwarts wrote:
>>>> Op 15.jun.2024 om 14:12 schreef olcott:
>>>>> On 6/15/2024 4:03 AM, Fred. Zwarts wrote:
>>>>>> Op 14.jun.2024 om 22:46 schreef olcott:
>>>>>>> On 6/14/2024 3:03 PM, Fred. Zwarts wrote:
>>>>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>>>>> On 6/14/2024 2:00 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 14.jun.2024 om 14:49 schreef olcott:
>>>>>>>>>>> I ran the actual code to verify the facts.
>>>>>>>>>>> HH1(DD,DD) does not have a pathological relationship to its
>>>>>>>>>>> input
>>>>>>>>>>> thus this input terminates normally.
>>>>>>>>>>
>>>>>>>>>> Your terminology is confusing. What you call a "pathological
>>>>>>>>>> relationship" is that H must simulate itself.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *CONVENTIONAL TERMINOLOGY*
>>>>>>>>> For any program H that might determine whether programs halt, a
>>>>>>>>> "pathological" program D, called with some input, can pass its own
>>>>>>>>> source and its input to H and then specifically do the opposite
>>>>>>>>> of what
>>>>>>>>> H predicts D will do. No H can exist that handles this case.
>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>
>>>>>>>> The problem is that your simulator does not even reach the
>>>>>>>> "pathological" part of D.
>>>>>>>
>>>>>>> That is not the problem that is the criterion measure of a solution.
>>>>>>
>>>>>> You are using the wrong criterion, because this wrong criterion
>>>>>> also also applies to other programs, without a "pathological" part.
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> return H(main, 0);
>>>>>> }
>>>>>>
>>>>>> where you proved that H reports a false negative.
>>>>>>
>>>>>> So, your criterion has no relation with "pathological" programs.
>>>>>>
>>>>>
>>>>> This criteria works correctly for ALL input, including pathological
>>>>> main().
>>>>
>>>> You are twisting your own words,because main is not "pathological".
>>>> You do not even understand you own definition of "pathological":
>>>>
>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>
>>>>> *CONVENTIONAL TERMINOLOGY*
>>>>> For any program H that might determine whether programs halt, a
>>>>> "pathological" program D, called with some input, can pass its own
>>>>> source and its input to H and then specifically do the opposite of
>>>>> what
>>>>> H predicts D will do. No H can exist that handles this case.
>>>>
>>>> No high level programming skills are needed to see that there is no
>>>> part where main 'then specifically do the opposite of what H
>>>> predicts it will do'.
>>>>
>>>> It seems that you are changing the definition of "pathological" to
>>>> 'any program for which H returns a false negative', which then
>>>> becomes a tautology.
>>>>
>>>
>>> Any function that calls H specifies recursive simulation.
>>
>> Is this the new definition of "pathological"?
>
> *It is the same thing that I have been saying all along*
>
> 00 typedef void (*ptr)(); // pointer to void function
> 01
> 02 int HH(ptr P, ptr I);
> 03
> 04 void DDD(int (*x)())
> 05 {
> 06 HH(x, x);
> 07 return;
> 08 }
> 09
> 10 int main()
> 11 {
> 12 HH(DDD,DDD);
> 13 }
>
> Line 12 main()
> invokes HH(DDD,DDD); that simulates DDD()
>
> *REPEAT UNTIL outer HH aborts*
> Line 06 simulated DDD()
> invokes simulated HH(DDD,DDD); that simulates DDD()
>
> DDD correctly simulated by HH never reaches its own "return"
> instruction and halts.
So, you agree that you are changing definitions. The part in your
definition above "and then specifically do the opposite of what H
predicts D will do" has completely disappeared.
Don't you see that it is almost impossible to talk with someone who is
continuously changing definitions?
But when using this new definition, we agree that the fact that D does
the opposite of what H returns is irrelevant.
This means that you only prove that there are programs (like your DDD,
and my main) that halt, for which the simulation by H does not reach its
final state, because H is unable to reach its own simulated final state.
H then aborts and reports non-halting. A false negative.
[toc] | [prev] | [next] | [standalone]
Page 3 of 5 — ← Prev page 1 2 [3] 4 5 Next page →
Back to top | Article view | comp.theory
csiph-web