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 4 of 5 — ← Prev page 1 2 3 [4] 5 Next page →
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-15 10:23 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4kbkv$3h3iu$2@dont-email.me> |
| In reply to | #107197 |
On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
> Op 15.jun.2024 om 16:48 schreef olcott:
>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>
>>> 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.
Not at all. The original definition still applies when it
is made more generic.
01 int D(ptr p)
02 {
03 int Halt_Status = H(p, p);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
D correctly simulated by H has isomorphic behavior to DDD
correctly simulated by HH, both get stuck in recursive
simulation.
--
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:39 -0400 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4kck3$2218$17@i2pn2.org> |
| In reply to | #107200 |
On 6/15/24 11:23 AM, olcott wrote:
> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>> Op 15.jun.2024 om 16:48 schreef olcott:
>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>
>>>> 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.
>
> Not at all. The original definition still applies when it
> is made more generic.
>
> 01 int D(ptr p)
> 02 {
> 03 int Halt_Status = H(p, p);
> 04 if (Halt_Status)
> 05 HERE: goto HERE;
> 06 return Halt_Status;
> 07 }
>
> D correctly simulated by H has isomorphic behavior to DDD
> correctly simulated by HH, both get stuck in recursive
> simulation.
>
>
They only get stuck, if HH itself gets stuck, and such an HH is then not
a DECIDER.
Reminder of the FACT you keep of trying to forget, is that if HH is to
be a "Halt Decider" its answer needs to match the actual behavior of the
direct execution of the input. And, if it isn't a Halt Decider, it can't
be disproving the proof you claim to be working on.
All you are doing is prove that you don't understand your definitions.
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-16 08:21 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4m09f$3tvpi$1@dont-email.me> |
| In reply to | #107200 |
Op 15.jun.2024 om 17:23 schreef olcott:
> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>> Op 15.jun.2024 om 16:48 schreef olcott:
>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>
>>>> 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.
>
> Not at all. The original definition still applies when it
> is made more generic.
>
> 01 int D(ptr p)
> 02 {
> 03 int Halt_Status = H(p, p);
> 04 if (Halt_Status)
> 05 HERE: goto HERE;
> 06 return Halt_Status;
> 07 }
>
> D correctly simulated by H has isomorphic behavior to DDD
> correctly simulated by HH, both get stuck in recursive
> simulation.
>
When asked what is a pathological program olcott replied:
Op 14.jun.2024 om 21:18 schreef olcott:
> 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 he defines a "pathological" program as a program that calls H.
All words about doing the opposite of what H predicts, have disappeared.
Everyone sees the difference, but he is stuck is rebuttal mode and
denies the change of definition.
His only excuse is that in both cases a recursive simulation is seen,
but that is not the point.
He had already proved earlier that in
int main()
{
return H(main, 0);
}
H produces a false negative, because main halts, whereas H reports
non-halting. No relation with doing the opposite of what H predicts.
This happens for DDD as well. Just a false negative. No relation with
doing the opposite of what H predicts.
Even in the case of D, it is just a false negative, because even olcott
admits that his simulation does not process the part where D does the
opposite of what H predicts.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-16 07:37 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4mmai$1qt6$1@dont-email.me> |
| In reply to | #107259 |
On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
> Op 15.jun.2024 om 17:23 schreef olcott:
>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>
>>>>> 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.
>>
>> Not at all. The original definition still applies when it
>> is made more generic.
>>
>> 01 int D(ptr p)
>> 02 {
>> 03 int Halt_Status = H(p, p);
>> 04 if (Halt_Status)
>> 05 HERE: goto HERE;
>> 06 return Halt_Status;
>> 07 }
>>
>> D correctly simulated by H has isomorphic behavior to DDD
>> correctly simulated by HH, both get stuck in recursive
>> simulation.
>>
>
> When asked what is a pathological program olcott replied:
> Op 14.jun.2024 om 21:18 schreef olcott:
>> 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 he defines a "pathological" program as a program that calls H.
> All words about doing the opposite of what H predicts, have disappeared.
> Everyone sees the difference, but he is stuck is rebuttal mode and
> denies the change of definition.
>
The code that "does the opposite" was never reachable by
a simulating halt decider thus does not change the problem
for a simulating halt decider when this code is removed.
By simplifying the problem we gain cognitive leverage. With
less details to pay attention to the while simplified problem
can be more deeply understood.
> His only excuse is that in both cases a recursive simulation is seen,
> but that is not the point.
> He had already proved earlier that in
>
> int main()
> {
> return H(main, 0);
> }
>
> H produces a false negative, because main halts, whereas H reports
The input does not halt and deciders are only accountable
for the behavior of their input. Until I invented a simulating
halt decider no one ever noticed that D correctly simulated by H
could have different behavior that the directly executed D(D).
No one ever noticed that the pathological relationship of D
calling its own decider changed the behavior of D because
everyone rejected simulation out-of-hand without review.
> non-halting. No relation with doing the opposite of what H predicts.
> This happens for DDD as well. Just a false negative. No relation with
> doing the opposite of what H predicts.
> Even in the case of D, it is just a false negative, because even olcott
> admits that his simulation does not process the part where D does the
> opposite of what H predicts.
--
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-16 13:30 -0400 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4n7fa$61l9$1@i2pn2.org> |
| In reply to | #107267 |
On 6/16/24 8:37 AM, olcott wrote:
> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>> Op 15.jun.2024 om 17:23 schreef olcott:
>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>
>>>>>> 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.
>>>
>>> Not at all. The original definition still applies when it
>>> is made more generic.
>>>
>>> 01 int D(ptr p)
>>> 02 {
>>> 03 int Halt_Status = H(p, p);
>>> 04 if (Halt_Status)
>>> 05 HERE: goto HERE;
>>> 06 return Halt_Status;
>>> 07 }
>>>
>>> D correctly simulated by H has isomorphic behavior to DDD
>>> correctly simulated by HH, both get stuck in recursive
>>> simulation.
>>>
>>
>> When asked what is a pathological program olcott replied:
>> Op 14.jun.2024 om 21:18 schreef olcott:
>>> 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 he defines a "pathological" program as a program that calls H.
>> All words about doing the opposite of what H predicts, have disappeared.
>> Everyone sees the difference, but he is stuck is rebuttal mode and
>> denies the change of definition.
>>
>
> The code that "does the opposite" was never reachable by
> a simulating halt decider thus does not change the problem
> for a simulating halt decider when this code is removed.
>
> By simplifying the problem we gain cognitive leverage. With
> less details to pay attention to the while simplified problem
> can be more deeply understood.
>
>> His only excuse is that in both cases a recursive simulation is seen,
>> but that is not the point.
>> He had already proved earlier that in
>>
>> int main()
>> {
>> return H(main, 0);
>> }
>>
>> H produces a false negative, because main halts, whereas H reports
>
> The input does not halt and deciders are only accountable
> for the behavior of their input. Until I invented a simulating
> halt decider no one ever noticed that D correctly simulated by H
> could have different behavior that the directly executed D(D).
inputs, which are just strings, don't HAVE behvior, only wht they
rerpresent.
By DEFINITION, the inputs to a Halt Decider represent the Macine being
asked about, and its input.
That Machine has behavior, and for these cases, it halts, so you H is
just proved incorrect in its answer. And that you are a liar.
And no one noticed that D correctly simulated by H could have a
different behavior, because it can't. That is just you lying to yourself
about what is correct.
>
> No one ever noticed that the pathological relationship of D
> calling its own decider changed the behavior of D because
> everyone rejected simulation out-of-hand without review.
Nope. I remember looking at them when I was young, so you are just being
the prototypical "russian" claiming you invented everything.
>
>> non-halting. No relation with doing the opposite of what H predicts.
>> This happens for DDD as well. Just a false negative. No relation with
>> doing the opposite of what H predicts.
>> Even in the case of D, it is just a false negative, because even
>> olcott admits that his simulation does not process the part where D
>> does the opposite of what H predicts.
>
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-16 21:08 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4nd7k$6b5r$1@dont-email.me> |
| In reply to | #107267 |
Op 16.jun.2024 om 14:37 schreef olcott:
> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>> Op 15.jun.2024 om 17:23 schreef olcott:
>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>
>>>>>> 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.
>>>
>>> Not at all. The original definition still applies when it
>>> is made more generic.
>>>
>>> 01 int D(ptr p)
>>> 02 {
>>> 03 int Halt_Status = H(p, p);
>>> 04 if (Halt_Status)
>>> 05 HERE: goto HERE;
>>> 06 return Halt_Status;
>>> 07 }
>>>
>>> D correctly simulated by H has isomorphic behavior to DDD
>>> correctly simulated by HH, both get stuck in recursive
>>> simulation.
>>>
>>
>> When asked what is a pathological program olcott replied:
>> Op 14.jun.2024 om 21:18 schreef olcott:
>>> 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 he defines a "pathological" program as a program that calls H.
>> All words about doing the opposite of what H predicts, have disappeared.
>> Everyone sees the difference, but he is stuck is rebuttal mode and
>> denies the change of definition.
>>
>
> The code that "does the opposite" was never reachable by
> a simulating halt decider thus does not change the problem
> for a simulating halt decider when this code is removed.
So, there was never a relation with the Linz proof, where the part that
does the opposite of what H predicts plays the essential role.
What remains is the fact that H is unable to simulate itself up to its
final state, which is called a "pathological" property of H.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-17 08:39 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4peaq$ln46$13@dont-email.me> |
| In reply to | #107292 |
On 6/16/2024 2:08 PM, Fred. Zwarts wrote:
> Op 16.jun.2024 om 14:37 schreef olcott:
>> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>>> Op 15.jun.2024 om 17:23 schreef olcott:
>>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>>
>>>>>>> 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.
>>>>
>>>> Not at all. The original definition still applies when it
>>>> is made more generic.
>>>>
>>>> 01 int D(ptr p)
>>>> 02 {
>>>> 03 int Halt_Status = H(p, p);
>>>> 04 if (Halt_Status)
>>>> 05 HERE: goto HERE;
>>>> 06 return Halt_Status;
>>>> 07 }
>>>>
>>>> D correctly simulated by H has isomorphic behavior to DDD
>>>> correctly simulated by HH, both get stuck in recursive
>>>> simulation.
>>>>
>>>
>>> When asked what is a pathological program olcott replied:
>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>> 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 he defines a "pathological" program as a program that calls H.
>>> All words about doing the opposite of what H predicts, have disappeared.
>>> Everyone sees the difference, but he is stuck is rebuttal mode and
>>> denies the change of definition.
>>>
>>
>> The code that "does the opposite" was never reachable by
>> a simulating halt decider thus does not change the problem
>> for a simulating halt decider when this code is removed.
>
> So, there was never a relation with the Linz proof, where the part that
> does the opposite of what H predicts plays the essential role.
>
This is the key essence of the pathological relationship in all
of the halting problem counter-example proofs including the Linz proof.
void DDD()
{
H0(DDD);
}
int main()
{
H0(DDD);
}
> What remains is the fact that H is unable to simulate itself up to its
> final state, which is called a "pathological" property of H.
>
H is always correct to abort the simulation of any input
that would cause itself to not terminate normally.
When this is construed as non-halting criteria then H is
always correct to reject all of these inputs as non-halting.
--
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-17 16:21 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4pgok$l7le$3@dont-email.me> |
| In reply to | #107324 |
Op 17.jun.2024 om 15:39 schreef olcott:
> On 6/16/2024 2:08 PM, Fred. Zwarts wrote:
>> Op 16.jun.2024 om 14:37 schreef olcott:
>>> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>>>> Op 15.jun.2024 om 17:23 schreef olcott:
>>>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>>>
>>>>>>>> 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.
>>>>>
>>>>> Not at all. The original definition still applies when it
>>>>> is made more generic.
>>>>>
>>>>> 01 int D(ptr p)
>>>>> 02 {
>>>>> 03 int Halt_Status = H(p, p);
>>>>> 04 if (Halt_Status)
>>>>> 05 HERE: goto HERE;
>>>>> 06 return Halt_Status;
>>>>> 07 }
>>>>>
>>>>> D correctly simulated by H has isomorphic behavior to DDD
>>>>> correctly simulated by HH, both get stuck in recursive
>>>>> simulation.
>>>>>
>>>>
>>>> When asked what is a pathological program olcott replied:
>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>> 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 he defines a "pathological" program as a program that calls H.
>>>> All words about doing the opposite of what H predicts, have
>>>> disappeared.
>>>> Everyone sees the difference, but he is stuck is rebuttal mode and
>>>> denies the change of definition.
>>>>
>>>
>>> The code that "does the opposite" was never reachable by
>>> a simulating halt decider thus does not change the problem
>>> for a simulating halt decider when this code is removed.
>>
>> So, there was never a relation with the Linz proof, where the part
>> that does the opposite of what H predicts plays the essential role.
>>
>
> This is the key essence of the pathological relationship in all
> of the halting problem counter-example proofs including the Linz proof.
>
> void DDD()
> {
> H0(DDD);
> }
>
> int main()
> {
> H0(DDD);
> }
>
>> What remains is the fact that H is unable to simulate itself up to its
>> final state, which is called a "pathological" property of H.
>>
>
> H is always correct to abort the simulation of any input
> that would cause itself to not terminate normally.
>
> When this is construed as non-halting criteria then H is
> always correct to reject all of these inputs as non-halting.
>
When! But that would be a big mistake to do. The inability of H0 to
simulate itself does not tell us anything about the halting behaviour of
the program.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-17 09:35 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4phin$mub6$3@dont-email.me> |
| In reply to | #107329 |
On 6/17/2024 9:21 AM, Fred. Zwarts wrote:
> Op 17.jun.2024 om 15:39 schreef olcott:
>> On 6/16/2024 2:08 PM, Fred. Zwarts wrote:
>>> Op 16.jun.2024 om 14:37 schreef olcott:
>>>> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>>>>> Op 15.jun.2024 om 17:23 schreef olcott:
>>>>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>>>>
>>>>>>>>> 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.
>>>>>>
>>>>>> Not at all. The original definition still applies when it
>>>>>> is made more generic.
>>>>>>
>>>>>> 01 int D(ptr p)
>>>>>> 02 {
>>>>>> 03 int Halt_Status = H(p, p);
>>>>>> 04 if (Halt_Status)
>>>>>> 05 HERE: goto HERE;
>>>>>> 06 return Halt_Status;
>>>>>> 07 }
>>>>>>
>>>>>> D correctly simulated by H has isomorphic behavior to DDD
>>>>>> correctly simulated by HH, both get stuck in recursive
>>>>>> simulation.
>>>>>>
>>>>>
>>>>> When asked what is a pathological program olcott replied:
>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>> 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 he defines a "pathological" program as a program that calls H.
>>>>> All words about doing the opposite of what H predicts, have
>>>>> disappeared.
>>>>> Everyone sees the difference, but he is stuck is rebuttal mode and
>>>>> denies the change of definition.
>>>>>
>>>>
>>>> The code that "does the opposite" was never reachable by
>>>> a simulating halt decider thus does not change the problem
>>>> for a simulating halt decider when this code is removed.
>>>
>>> So, there was never a relation with the Linz proof, where the part
>>> that does the opposite of what H predicts plays the essential role.
>>>
>>
>> This is the key essence of the pathological relationship in all
>> of the halting problem counter-example proofs including the Linz proof.
>>
>> void DDD()
>> {
>> H0(DDD);
>> }
>>
>> int main()
>> {
>> H0(DDD);
>> }
>>
>>> What remains is the fact that H is unable to simulate itself up to
>>> its final state, which is called a "pathological" property of H.
>>>
>>
>> H is always correct to abort the simulation of any input
>> that would cause itself to not terminate normally.
>>
>> When this is construed as non-halting criteria then H is
>> always correct to reject all of these inputs as non-halting.
>>
>
> When! But that would be a big mistake to do. The inability of H0 to
> simulate itself does not tell us anything about the halting behaviour of
> the program.
>
Your view here is merely ignorant of the fact that deciders
must report on the behavior specified by their inputs.
It is incorrect to assume against the facts when DDD correctly
simulated by H0 calls a simulated H0(DDD) that this call will
return to the correctly simulated DDD.
--
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-17 16:51 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4pihr$l7le$6@dont-email.me> |
| In reply to | #107332 |
Op 17.jun.2024 om 16:35 schreef olcott:
> On 6/17/2024 9:21 AM, Fred. Zwarts wrote:
>> Op 17.jun.2024 om 15:39 schreef olcott:
>>> On 6/16/2024 2:08 PM, Fred. Zwarts wrote:
>>>> Op 16.jun.2024 om 14:37 schreef olcott:
>>>>> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>>>>>> Op 15.jun.2024 om 17:23 schreef olcott:
>>>>>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>>>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>>>>>
>>>>>>>>>> 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.
>>>>>>>
>>>>>>> Not at all. The original definition still applies when it
>>>>>>> is made more generic.
>>>>>>>
>>>>>>> 01 int D(ptr p)
>>>>>>> 02 {
>>>>>>> 03 int Halt_Status = H(p, p);
>>>>>>> 04 if (Halt_Status)
>>>>>>> 05 HERE: goto HERE;
>>>>>>> 06 return Halt_Status;
>>>>>>> 07 }
>>>>>>>
>>>>>>> D correctly simulated by H has isomorphic behavior to DDD
>>>>>>> correctly simulated by HH, both get stuck in recursive
>>>>>>> simulation.
>>>>>>>
>>>>>>
>>>>>> When asked what is a pathological program olcott replied:
>>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>>> 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 he defines a "pathological" program as a program that calls H.
>>>>>> All words about doing the opposite of what H predicts, have
>>>>>> disappeared.
>>>>>> Everyone sees the difference, but he is stuck is rebuttal mode and
>>>>>> denies the change of definition.
>>>>>>
>>>>>
>>>>> The code that "does the opposite" was never reachable by
>>>>> a simulating halt decider thus does not change the problem
>>>>> for a simulating halt decider when this code is removed.
>>>>
>>>> So, there was never a relation with the Linz proof, where the part
>>>> that does the opposite of what H predicts plays the essential role.
>>>>
>>>
>>> This is the key essence of the pathological relationship in all
>>> of the halting problem counter-example proofs including the Linz proof.
>>>
>>> void DDD()
>>> {
>>> H0(DDD);
>>> }
>>>
>>> int main()
>>> {
>>> H0(DDD);
>>> }
>>>
>>>> What remains is the fact that H is unable to simulate itself up to
>>>> its final state, which is called a "pathological" property of H.
>>>>
>>>
>>> H is always correct to abort the simulation of any input
>>> that would cause itself to not terminate normally.
>>>
>>> When this is construed as non-halting criteria then H is
>>> always correct to reject all of these inputs as non-halting.
>>>
>>
>> When! But that would be a big mistake to do. The inability of H0 to
>> simulate itself does not tell us anything about the halting behaviour
>> of the program.
>>
>
> Your view here is merely ignorant of the fact that deciders
> must report on the behavior specified by their inputs.
>
> It is incorrect to assume against the facts when DDD correctly
> simulated by H0 calls a simulated H0(DDD) that this call will
> return to the correctly simulated DDD.
It is incorrect to assume that a failing simulator reports anything,
except it own failure.
So, you may wish that it reports about DDD, but that is irrelevant.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-17 10:22 +0300 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4oo7t$hpjr$1@dont-email.me> |
| In reply to | #107267 |
On 2024-06-16 12:37:38 +0000, olcott said:
> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>> Op 15.jun.2024 om 17:23 schreef olcott:
>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>
>>>>>> 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.
>>>
>>> Not at all. The original definition still applies when it
>>> is made more generic.
>>>
>>> 01 int D(ptr p)
>>> 02 {
>>> 03 int Halt_Status = H(p, p);
>>> 04 if (Halt_Status)
>>> 05 HERE: goto HERE;
>>> 06 return Halt_Status;
>>> 07 }
>>>
>>> D correctly simulated by H has isomorphic behavior to DDD
>>> correctly simulated by HH, both get stuck in recursive
>>> simulation.
>>>
>>
>> When asked what is a pathological program olcott replied:
>> Op 14.jun.2024 om 21:18 schreef olcott:
>>> 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 he defines a "pathological" program as a program that calls H.
>> All words about doing the opposite of what H predicts, have disappeared.
>> Everyone sees the difference, but he is stuck is rebuttal mode and
>> denies the change of definition.
>>
>
> The code that "does the opposite" was never reachable by
> a simulating halt decider thus does not change the problem
> for a simulating halt decider when this code is removed.
>
> By simplifying the problem we gain cognitive leverage. With
> less details to pay attention to the while simplified problem
> can be more deeply understood.
>
>> His only excuse is that in both cases a recursive simulation is seen,
>> but that is not the point.
>> He had already proved earlier that in
>>
>> int main()
>> {
>> return H(main, 0);
>> }
>>
>> H produces a false negative, because main halts, whereas H reports
>
> The input does not halt and deciders are only accountable
> for the behavior of their input.
If the above main does not halt then H it calls is not a decider.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-17 08:07 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4pcds$ln46$4@dont-email.me> |
| In reply to | #107305 |
On 6/17/2024 2:22 AM, Mikko wrote:
> On 2024-06-16 12:37:38 +0000, olcott said:
>
>> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>>> Op 15.jun.2024 om 17:23 schreef olcott:
>>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>>
>>>>>>> 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.
>>>>
>>>> Not at all. The original definition still applies when it
>>>> is made more generic.
>>>>
>>>> 01 int D(ptr p)
>>>> 02 {
>>>> 03 int Halt_Status = H(p, p);
>>>> 04 if (Halt_Status)
>>>> 05 HERE: goto HERE;
>>>> 06 return Halt_Status;
>>>> 07 }
>>>>
>>>> D correctly simulated by H has isomorphic behavior to DDD
>>>> correctly simulated by HH, both get stuck in recursive
>>>> simulation.
>>>>
>>>
>>> When asked what is a pathological program olcott replied:
>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>> 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 he defines a "pathological" program as a program that calls H.
>>> All words about doing the opposite of what H predicts, have disappeared.
>>> Everyone sees the difference, but he is stuck is rebuttal mode and
>>> denies the change of definition.
>>>
>>
>> The code that "does the opposite" was never reachable by
>> a simulating halt decider thus does not change the problem
>> for a simulating halt decider when this code is removed.
>>
>> By simplifying the problem we gain cognitive leverage. With
>> less details to pay attention to the while simplified problem
>> can be more deeply understood.
>>
>>> His only excuse is that in both cases a recursive simulation is seen,
>>> but that is not the point.
>>> He had already proved earlier that in
>>>
>>> int main()
>>> {
>>> return H(main, 0);
>>> }
>>>
>>> H produces a false negative, because main halts, whereas H reports
>>
>> The input does not halt and deciders are only accountable
>> for the behavior of their input.
>
> If the above main does not halt then H it calls is not a decider.
>
That is merely a more difficult to understand
example of this simplest possible case.
void DDD()
{
H0(DDD);
}
int main()
{
H0(DDD);
}
--
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 | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-18 10:54 +0300 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4reg1$18e6d$1@dont-email.me> |
| In reply to | #107314 |
On 2024-06-17 13:07:08 +0000, olcott said:
> On 6/17/2024 2:22 AM, Mikko wrote:
>> On 2024-06-16 12:37:38 +0000, olcott said:
>>
>>> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>>>> Op 15.jun.2024 om 17:23 schreef olcott:
>>>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>>>
>>>>>>>> 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.
>>>>>
>>>>> Not at all. The original definition still applies when it
>>>>> is made more generic.
>>>>>
>>>>> 01 int D(ptr p)
>>>>> 02 {
>>>>> 03 int Halt_Status = H(p, p);
>>>>> 04 if (Halt_Status)
>>>>> 05 HERE: goto HERE;
>>>>> 06 return Halt_Status;
>>>>> 07 }
>>>>>
>>>>> D correctly simulated by H has isomorphic behavior to DDD
>>>>> correctly simulated by HH, both get stuck in recursive
>>>>> simulation.
>>>>>
>>>>
>>>> When asked what is a pathological program olcott replied:
>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>> 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 he defines a "pathological" program as a program that calls H.
>>>> All words about doing the opposite of what H predicts, have disappeared.
>>>> Everyone sees the difference, but he is stuck is rebuttal mode and
>>>> denies the change of definition.
>>>>
>>>
>>> The code that "does the opposite" was never reachable by
>>> a simulating halt decider thus does not change the problem
>>> for a simulating halt decider when this code is removed.
>>>
>>> By simplifying the problem we gain cognitive leverage. With
>>> less details to pay attention to the while simplified problem
>>> can be more deeply understood.
>>>
>>>> His only excuse is that in both cases a recursive simulation is seen,
>>>> but that is not the point.
>>>> He had already proved earlier that in
>>>>
>>>> int main()
>>>> {
>>>> return H(main, 0);
>>>> }
>>>>
>>>> H produces a false negative, because main halts, whereas H reports
>>>
>>> The input does not halt and deciders are only accountable
>>> for the behavior of their input.
>>
>> If the above main does not halt then H it calls is not a decider.
>>
>
> That is merely a more difficult to understand
> example of this simplest possible case.
>
> void DDD()
> {
> H0(DDD);
> }
>
> int main()
> {
> H0(DDD);
> }
The only parts that are not easy to understand are H and H0 because
they are not shown. The rest of both examples are simple enough.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-18 07:55 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4s04r$1boeu$4@dont-email.me> |
| In reply to | #107353 |
On 6/18/2024 2:54 AM, Mikko wrote:
> On 2024-06-17 13:07:08 +0000, olcott said:
>
>> On 6/17/2024 2:22 AM, Mikko wrote:
>>> On 2024-06-16 12:37:38 +0000, olcott said:
>>>
>>>> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>>>>> Op 15.jun.2024 om 17:23 schreef olcott:
>>>>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>>>>
>>>>>>>>> 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.
>>>>>>
>>>>>> Not at all. The original definition still applies when it
>>>>>> is made more generic.
>>>>>>
>>>>>> 01 int D(ptr p)
>>>>>> 02 {
>>>>>> 03 int Halt_Status = H(p, p);
>>>>>> 04 if (Halt_Status)
>>>>>> 05 HERE: goto HERE;
>>>>>> 06 return Halt_Status;
>>>>>> 07 }
>>>>>>
>>>>>> D correctly simulated by H has isomorphic behavior to DDD
>>>>>> correctly simulated by HH, both get stuck in recursive
>>>>>> simulation.
>>>>>>
>>>>>
>>>>> When asked what is a pathological program olcott replied:
>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>> 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 he defines a "pathological" program as a program that calls H.
>>>>> All words about doing the opposite of what H predicts, have
>>>>> disappeared.
>>>>> Everyone sees the difference, but he is stuck is rebuttal mode and
>>>>> denies the change of definition.
>>>>>
>>>>
>>>> The code that "does the opposite" was never reachable by
>>>> a simulating halt decider thus does not change the problem
>>>> for a simulating halt decider when this code is removed.
>>>>
>>>> By simplifying the problem we gain cognitive leverage. With
>>>> less details to pay attention to the while simplified problem
>>>> can be more deeply understood.
>>>>
>>>>> His only excuse is that in both cases a recursive simulation is
>>>>> seen, but that is not the point.
>>>>> He had already proved earlier that in
>>>>>
>>>>> int main()
>>>>> {
>>>>> return H(main, 0);
>>>>> }
>>>>>
>>>>> H produces a false negative, because main halts, whereas H reports
>>>>
>>>> The input does not halt and deciders are only accountable
>>>> for the behavior of their input.
>>>
>>> If the above main does not halt then H it calls is not a decider.
>>>
>>
>> That is merely a more difficult to understand
>> example of this simplest possible case.
>>
>> void DDD()
>> {
>> H0(DDD);
>> }
>>
>> int main()
>> {
>> H0(DDD);
>> }
>
> The only parts that are not easy to understand are H and H0 because
> they are not shown. The rest of both examples are simple enough.
>
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
H0(DDD);
}
int main()
{
H0(Infinite_Loop);
H0(Infinite_Recursion);
H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that
when H0 emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.
If you don't understand that the above is correct then you
either don't know what an x86 emulator is or don't know C
well enough.
--
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-18 11:16 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4rj8m$180pg$2@dont-email.me> |
| In reply to | #107314 |
Op 17.jun.2024 om 15:07 schreef olcott:
> On 6/17/2024 2:22 AM, Mikko wrote:
>> On 2024-06-16 12:37:38 +0000, olcott said:
>>
>>> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>>>> Op 15.jun.2024 om 17:23 schreef olcott:
>>>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>>>
>>>>>>>> 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.
>>>>>
>>>>> Not at all. The original definition still applies when it
>>>>> is made more generic.
>>>>>
>>>>> 01 int D(ptr p)
>>>>> 02 {
>>>>> 03 int Halt_Status = H(p, p);
>>>>> 04 if (Halt_Status)
>>>>> 05 HERE: goto HERE;
>>>>> 06 return Halt_Status;
>>>>> 07 }
>>>>>
>>>>> D correctly simulated by H has isomorphic behavior to DDD
>>>>> correctly simulated by HH, both get stuck in recursive
>>>>> simulation.
>>>>>
>>>>
>>>> When asked what is a pathological program olcott replied:
>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>> 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 he defines a "pathological" program as a program that calls H.
>>>> All words about doing the opposite of what H predicts, have
>>>> disappeared.
>>>> Everyone sees the difference, but he is stuck is rebuttal mode and
>>>> denies the change of definition.
>>>>
>>>
>>> The code that "does the opposite" was never reachable by
>>> a simulating halt decider thus does not change the problem
>>> for a simulating halt decider when this code is removed.
>>>
>>> By simplifying the problem we gain cognitive leverage. With
>>> less details to pay attention to the while simplified problem
>>> can be more deeply understood.
>>>
>>>> His only excuse is that in both cases a recursive simulation is
>>>> seen, but that is not the point.
>>>> He had already proved earlier that in
>>>>
>>>> int main()
>>>> {
>>>> return H(main, 0);
>>>> }
>>>>
>>>> H produces a false negative, because main halts, whereas H reports
>>>
>>> The input does not halt and deciders are only accountable
>>> for the behavior of their input.
>>
>> If the above main does not halt then H it calls is not a decider.
>>
>
> That is merely a more difficult to understand
> example of this simplest possible case.
>
> void DDD()
> {
> H0(DDD);
> }
>
> int main()
> {
> H0(DDD);
> }
>
No, the other case is is simpler:
int main()
{
return H(main, 0);
}
DDD is an unneeded complication. These four lines are sufficient to see
that there is no other reason for the false negative than H itself.
We understand that you do not like the simplest example, because it
shows that the reasoning that there is a difference between main calling
DDD(), or calling H0(DDD) is futile. In the simplest case this futile
trick is not possible.
Therefore, we see that the whole problem is that H, or H0 is unable to
simulate itself sufficiently far enough to see the real behaviour. It
always aborts one cycle too early and, therefore, produces false negatives.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-18 07:43 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4rvcv$1boeu$1@dont-email.me> |
| In reply to | #107357 |
On 6/18/2024 4:16 AM, Fred. Zwarts wrote:
> Op 17.jun.2024 om 15:07 schreef olcott:
>> On 6/17/2024 2:22 AM, Mikko wrote:
>>> On 2024-06-16 12:37:38 +0000, olcott said:
>>>
>>>> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>>>>> Op 15.jun.2024 om 17:23 schreef olcott:
>>>>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>>>>
>>>>>>>>> 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.
>>>>>>
>>>>>> Not at all. The original definition still applies when it
>>>>>> is made more generic.
>>>>>>
>>>>>> 01 int D(ptr p)
>>>>>> 02 {
>>>>>> 03 int Halt_Status = H(p, p);
>>>>>> 04 if (Halt_Status)
>>>>>> 05 HERE: goto HERE;
>>>>>> 06 return Halt_Status;
>>>>>> 07 }
>>>>>>
>>>>>> D correctly simulated by H has isomorphic behavior to DDD
>>>>>> correctly simulated by HH, both get stuck in recursive
>>>>>> simulation.
>>>>>>
>>>>>
>>>>> When asked what is a pathological program olcott replied:
>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>> 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 he defines a "pathological" program as a program that calls H.
>>>>> All words about doing the opposite of what H predicts, have
>>>>> disappeared.
>>>>> Everyone sees the difference, but he is stuck is rebuttal mode and
>>>>> denies the change of definition.
>>>>>
>>>>
>>>> The code that "does the opposite" was never reachable by
>>>> a simulating halt decider thus does not change the problem
>>>> for a simulating halt decider when this code is removed.
>>>>
>>>> By simplifying the problem we gain cognitive leverage. With
>>>> less details to pay attention to the while simplified problem
>>>> can be more deeply understood.
>>>>
>>>>> His only excuse is that in both cases a recursive simulation is
>>>>> seen, but that is not the point.
>>>>> He had already proved earlier that in
>>>>>
>>>>> int main()
>>>>> {
>>>>> return H(main, 0);
>>>>> }
>>>>>
>>>>> H produces a false negative, because main halts, whereas H reports
>>>>
>>>> The input does not halt and deciders are only accountable
>>>> for the behavior of their input.
>>>
>>> If the above main does not halt then H it calls is not a decider.
>>>
>>
>> That is merely a more difficult to understand
>> example of this simplest possible case.
>>
>> void DDD()
>> {
>> H0(DDD);
>> }
>>
>> int main()
>> {
>> H0(DDD);
>> }
>>
>
> No, the other case is is simpler:
>
> int main()
> {
> return H(main, 0);
> }
>
> DDD is an unneeded complication. These four lines are sufficient to see
> that there is no other reason for the false negative than H itself.
>
> We understand that you do not like the simplest example, because it
> shows that the reasoning that there is a difference between main calling
> DDD(), or calling H0(DDD) is futile. In the simplest case this futile
> trick is not possible.
> Therefore, we see that the whole problem is that H, or H0 is unable to
> simulate itself sufficiently far enough to see the real behaviour. It
> always aborts one cycle too early and, therefore, produces false negatives.
The is merely your lack or programming skill. The outer H0 always
has at least one more execution trace than any of the inner ones
thus if it does not abort none of them do.
--
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-18 17:25 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4s8st$1dcrb$2@dont-email.me> |
| In reply to | #107362 |
Op 18.jun.2024 om 14:43 schreef olcott:
> On 6/18/2024 4:16 AM, Fred. Zwarts wrote:
>> Op 17.jun.2024 om 15:07 schreef olcott:
>>> On 6/17/2024 2:22 AM, Mikko wrote:
>>>> On 2024-06-16 12:37:38 +0000, olcott said:
>>>>
>>>>> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>>>>>> Op 15.jun.2024 om 17:23 schreef olcott:
>>>>>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>>>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>>>>>
>>>>>>>>>> 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.
>>>>>>>
>>>>>>> Not at all. The original definition still applies when it
>>>>>>> is made more generic.
>>>>>>>
>>>>>>> 01 int D(ptr p)
>>>>>>> 02 {
>>>>>>> 03 int Halt_Status = H(p, p);
>>>>>>> 04 if (Halt_Status)
>>>>>>> 05 HERE: goto HERE;
>>>>>>> 06 return Halt_Status;
>>>>>>> 07 }
>>>>>>>
>>>>>>> D correctly simulated by H has isomorphic behavior to DDD
>>>>>>> correctly simulated by HH, both get stuck in recursive
>>>>>>> simulation.
>>>>>>>
>>>>>>
>>>>>> When asked what is a pathological program olcott replied:
>>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>>> 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 he defines a "pathological" program as a program that calls H.
>>>>>> All words about doing the opposite of what H predicts, have
>>>>>> disappeared.
>>>>>> Everyone sees the difference, but he is stuck is rebuttal mode and
>>>>>> denies the change of definition.
>>>>>>
>>>>>
>>>>> The code that "does the opposite" was never reachable by
>>>>> a simulating halt decider thus does not change the problem
>>>>> for a simulating halt decider when this code is removed.
>>>>>
>>>>> By simplifying the problem we gain cognitive leverage. With
>>>>> less details to pay attention to the while simplified problem
>>>>> can be more deeply understood.
>>>>>
>>>>>> His only excuse is that in both cases a recursive simulation is
>>>>>> seen, but that is not the point.
>>>>>> He had already proved earlier that in
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> return H(main, 0);
>>>>>> }
>>>>>>
>>>>>> H produces a false negative, because main halts, whereas H reports
>>>>>
>>>>> The input does not halt and deciders are only accountable
>>>>> for the behavior of their input.
>>>>
>>>> If the above main does not halt then H it calls is not a decider.
>>>>
>>>
>>> That is merely a more difficult to understand
>>> example of this simplest possible case.
>>>
>>> void DDD()
>>> {
>>> H0(DDD);
>>> }
>>>
>>> int main()
>>> {
>>> H0(DDD);
>>> }
>>>
>>
>> No, the other case is is simpler:
>>
>> int main()
>> {
>> return H(main, 0);
>> }
>>
>> DDD is an unneeded complication. These four lines are sufficient to
>> see that there is no other reason for the false negative than H itself.
>>
>> We understand that you do not like the simplest example, because it
>> shows that the reasoning that there is a difference between main
>> calling DDD(), or calling H0(DDD) is futile. In the simplest case this
>> futile trick is not possible.
>> Therefore, we see that the whole problem is that H, or H0 is unable to
>> simulate itself sufficiently far enough to see the real behaviour. It
>> always aborts one cycle too early and, therefore, produces false
>> negatives.
>
> The is merely your lack or programming skill. The outer H0 always
> has at least one more execution trace than any of the inner ones
> thus if it does not abort none of them do.
>
Very good olcott! We agree on this point. At least you understand
something of programming. This means that if H0 aborts, it will do that
always one cycle too early. So, it does not see that its simulated self
would also abort and halt. So, indeed, an abort may be required, but
then it is a wild guess, a wrong one, that it is non-halting, because
the reality is that it would halt.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-18 10:39 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4s9mt$1dk9i$2@dont-email.me> |
| In reply to | #107370 |
On 6/18/2024 10:25 AM, Fred. Zwarts wrote:
> Op 18.jun.2024 om 14:43 schreef olcott:
>> On 6/18/2024 4:16 AM, Fred. Zwarts wrote:
>>> Op 17.jun.2024 om 15:07 schreef olcott:
>>>> On 6/17/2024 2:22 AM, Mikko wrote:
>>>>> On 2024-06-16 12:37:38 +0000, olcott said:
>>>>>
>>>>>> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>>>>>>> Op 15.jun.2024 om 17:23 schreef olcott:
>>>>>>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>>>>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>>>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>>>>>>
>>>>>>>>>>> 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.
>>>>>>>>
>>>>>>>> Not at all. The original definition still applies when it
>>>>>>>> is made more generic.
>>>>>>>>
>>>>>>>> 01 int D(ptr p)
>>>>>>>> 02 {
>>>>>>>> 03 int Halt_Status = H(p, p);
>>>>>>>> 04 if (Halt_Status)
>>>>>>>> 05 HERE: goto HERE;
>>>>>>>> 06 return Halt_Status;
>>>>>>>> 07 }
>>>>>>>>
>>>>>>>> D correctly simulated by H has isomorphic behavior to DDD
>>>>>>>> correctly simulated by HH, both get stuck in recursive
>>>>>>>> simulation.
>>>>>>>>
>>>>>>>
>>>>>>> When asked what is a pathological program olcott replied:
>>>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>>>> 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 he defines a "pathological" program as a program that calls H.
>>>>>>> All words about doing the opposite of what H predicts, have
>>>>>>> disappeared.
>>>>>>> Everyone sees the difference, but he is stuck is rebuttal mode
>>>>>>> and denies the change of definition.
>>>>>>>
>>>>>>
>>>>>> The code that "does the opposite" was never reachable by
>>>>>> a simulating halt decider thus does not change the problem
>>>>>> for a simulating halt decider when this code is removed.
>>>>>>
>>>>>> By simplifying the problem we gain cognitive leverage. With
>>>>>> less details to pay attention to the while simplified problem
>>>>>> can be more deeply understood.
>>>>>>
>>>>>>> His only excuse is that in both cases a recursive simulation is
>>>>>>> seen, but that is not the point.
>>>>>>> He had already proved earlier that in
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> return H(main, 0);
>>>>>>> }
>>>>>>>
>>>>>>> H produces a false negative, because main halts, whereas H reports
>>>>>>
>>>>>> The input does not halt and deciders are only accountable
>>>>>> for the behavior of their input.
>>>>>
>>>>> If the above main does not halt then H it calls is not a decider.
>>>>>
>>>>
>>>> That is merely a more difficult to understand
>>>> example of this simplest possible case.
>>>>
>>>> void DDD()
>>>> {
>>>> H0(DDD);
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> H0(DDD);
>>>> }
>>>>
>>>
>>> No, the other case is is simpler:
>>>
>>> int main()
>>> {
>>> return H(main, 0);
>>> }
>>>
>>> DDD is an unneeded complication. These four lines are sufficient to
>>> see that there is no other reason for the false negative than H itself.
>>>
>>> We understand that you do not like the simplest example, because it
>>> shows that the reasoning that there is a difference between main
>>> calling DDD(), or calling H0(DDD) is futile. In the simplest case
>>> this futile trick is not possible.
>>> Therefore, we see that the whole problem is that H, or H0 is unable
>>> to simulate itself sufficiently far enough to see the real behaviour.
>>> It always aborts one cycle too early and, therefore, produces false
>>> negatives.
>>
>> The is merely your lack or programming skill. The outer H0 always
>> has at least one more execution trace than any of the inner ones
>> thus if it does not abort none of them do.
>>
>
> Very good olcott! We agree on this point. At least you understand
> something of programming.
I worked for the Airforce at the Airforce base with a secret
clearance on the NPOESS Satellite ingest in C++.
https://en.wikipedia.org/wiki/NPOESS
> This means that if H0 aborts, it will do that
> always one cycle too early.
*No that it not it*
http://al.howardknight.net/?STYPE=msgid&MSGI=%3Cv4pg5p%24morv%241%40raubtier-asyl.eternal-september.org%3E+
> So, it does not see that its simulated self
> would also abort and halt. So, indeed, an abort may be required, but
> then it is a wild guess, a wrong one, that it is non-halting, because
> the reality is that it would halt.
--
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-18 17:53 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4sahk$1dcrb$4@dont-email.me> |
| In reply to | #107373 |
Op 18.jun.2024 om 17:39 schreef olcott:
> On 6/18/2024 10:25 AM, Fred. Zwarts wrote:
>> Op 18.jun.2024 om 14:43 schreef olcott:
>>> On 6/18/2024 4:16 AM, Fred. Zwarts wrote:
>>>> Op 17.jun.2024 om 15:07 schreef olcott:
>>>>> On 6/17/2024 2:22 AM, Mikko wrote:
>>>>>> On 2024-06-16 12:37:38 +0000, olcott said:
>>>>>>
>>>>>>> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>>>>>>>> Op 15.jun.2024 om 17:23 schreef olcott:
>>>>>>>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>>>>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>> Not at all. The original definition still applies when it
>>>>>>>>> is made more generic.
>>>>>>>>>
>>>>>>>>> 01 int D(ptr p)
>>>>>>>>> 02 {
>>>>>>>>> 03 int Halt_Status = H(p, p);
>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>> 06 return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>>
>>>>>>>>> D correctly simulated by H has isomorphic behavior to DDD
>>>>>>>>> correctly simulated by HH, both get stuck in recursive
>>>>>>>>> simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> When asked what is a pathological program olcott replied:
>>>>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>>>>> 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 he defines a "pathological" program as a program that calls H.
>>>>>>>> All words about doing the opposite of what H predicts, have
>>>>>>>> disappeared.
>>>>>>>> Everyone sees the difference, but he is stuck is rebuttal mode
>>>>>>>> and denies the change of definition.
>>>>>>>>
>>>>>>>
>>>>>>> The code that "does the opposite" was never reachable by
>>>>>>> a simulating halt decider thus does not change the problem
>>>>>>> for a simulating halt decider when this code is removed.
>>>>>>>
>>>>>>> By simplifying the problem we gain cognitive leverage. With
>>>>>>> less details to pay attention to the while simplified problem
>>>>>>> can be more deeply understood.
>>>>>>>
>>>>>>>> His only excuse is that in both cases a recursive simulation is
>>>>>>>> seen, but that is not the point.
>>>>>>>> He had already proved earlier that in
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> return H(main, 0);
>>>>>>>> }
>>>>>>>>
>>>>>>>> H produces a false negative, because main halts, whereas H reports
>>>>>>>
>>>>>>> The input does not halt and deciders are only accountable
>>>>>>> for the behavior of their input.
>>>>>>
>>>>>> If the above main does not halt then H it calls is not a decider.
>>>>>>
>>>>>
>>>>> That is merely a more difficult to understand
>>>>> example of this simplest possible case.
>>>>>
>>>>> void DDD()
>>>>> {
>>>>> H0(DDD);
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> H0(DDD);
>>>>> }
>>>>>
>>>>
>>>> No, the other case is is simpler:
>>>>
>>>> int main()
>>>> {
>>>> return H(main, 0);
>>>> }
>>>>
>>>> DDD is an unneeded complication. These four lines are sufficient to
>>>> see that there is no other reason for the false negative than H itself.
>>>>
>>>> We understand that you do not like the simplest example, because it
>>>> shows that the reasoning that there is a difference between main
>>>> calling DDD(), or calling H0(DDD) is futile. In the simplest case
>>>> this futile trick is not possible.
>>>> Therefore, we see that the whole problem is that H, or H0 is unable
>>>> to simulate itself sufficiently far enough to see the real
>>>> behaviour. It always aborts one cycle too early and, therefore,
>>>> produces false negatives.
>>>
>>> The is merely your lack or programming skill. The outer H0 always
>>> has at least one more execution trace than any of the inner ones
>>> thus if it does not abort none of them do.
>>>
>>
>> Very good olcott! We agree on this point. At least you understand
>> something of programming.
>
> I worked for the Airforce at the Airforce base with a secret
> clearance on the NPOESS Satellite ingest in C++.
> https://en.wikipedia.org/wiki/NPOESS
Sorry to hear that, when did you loose those skills?
>
>> This means that if H0 aborts, it will do that always one cycle too early.
>
>
> *No that it not it*
> http://al.howardknight.net/?STYPE=msgid&MSGI=%3Cv4pg5p%24morv%241%40raubtier-asyl.eternal-september.org%3E+
So, just repeating a claim that was proved incorrect, by referring to a
similar claim without proof.
It are your own words that H0 always has at least one more execution
trace than any of the inner ones. This makes that it aborts one cycle
before the inner one would abort (if simulated correctly). So, it aborts
one cycle too early.
Very simple proof, if you don't see that, you lost many skills.
>
>> So, it does not see that its simulated self would also abort and halt.
>> So, indeed, an abort may be required, but then it is a wild guess, a
>> wrong one, that it is non-halting, because the reality is that it
>> would halt.
>
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-18 19:32 +0300 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4scrl$1edq0$1@dont-email.me> |
| In reply to | #107373 |
On 2024-06-18 15:39:09 +0000, olcott said:
> On 6/18/2024 10:25 AM, Fred. Zwarts wrote:
>> Op 18.jun.2024 om 14:43 schreef olcott:
>>> On 6/18/2024 4:16 AM, Fred. Zwarts wrote:
>>>> Op 17.jun.2024 om 15:07 schreef olcott:
>>>>> On 6/17/2024 2:22 AM, Mikko wrote:
>>>>>> On 2024-06-16 12:37:38 +0000, olcott said:
>>>>>>
>>>>>>> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>>>>>>>> Op 15.jun.2024 om 17:23 schreef olcott:
>>>>>>>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>>>>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>> Not at all. The original definition still applies when it
>>>>>>>>> is made more generic.
>>>>>>>>>
>>>>>>>>> 01 int D(ptr p)
>>>>>>>>> 02 {
>>>>>>>>> 03 int Halt_Status = H(p, p);
>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>> 06 return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>>
>>>>>>>>> D correctly simulated by H has isomorphic behavior to DDD
>>>>>>>>> correctly simulated by HH, both get stuck in recursive
>>>>>>>>> simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> When asked what is a pathological program olcott replied:
>>>>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>>>>> 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 he defines a "pathological" program as a program that calls H.
>>>>>>>> All words about doing the opposite of what H predicts, have disappeared.
>>>>>>>> Everyone sees the difference, but he is stuck is rebuttal mode and
>>>>>>>> denies the change of definition.
>>>>>>>>
>>>>>>>
>>>>>>> The code that "does the opposite" was never reachable by
>>>>>>> a simulating halt decider thus does not change the problem
>>>>>>> for a simulating halt decider when this code is removed.
>>>>>>>
>>>>>>> By simplifying the problem we gain cognitive leverage. With
>>>>>>> less details to pay attention to the while simplified problem
>>>>>>> can be more deeply understood.
>>>>>>>
>>>>>>>> His only excuse is that in both cases a recursive simulation is seen,
>>>>>>>> but that is not the point.
>>>>>>>> He had already proved earlier that in
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> return H(main, 0);
>>>>>>>> }
>>>>>>>>
>>>>>>>> H produces a false negative, because main halts, whereas H reports
>>>>>>>
>>>>>>> The input does not halt and deciders are only accountable
>>>>>>> for the behavior of their input.
>>>>>>
>>>>>> If the above main does not halt then H it calls is not a decider.
>>>>>>
>>>>>
>>>>> That is merely a more difficult to understand
>>>>> example of this simplest possible case.
>>>>>
>>>>> void DDD()
>>>>> {
>>>>> H0(DDD);
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> H0(DDD);
>>>>> }
>>>>>
>>>>
>>>> No, the other case is is simpler:
>>>>
>>>> int main()
>>>> {
>>>> return H(main, 0);
>>>> }
>>>>
>>>> DDD is an unneeded complication. These four lines are sufficient to see
>>>> that there is no other reason for the false negative than H itself.
>>>>
>>>> We understand that you do not like the simplest example, because it
>>>> shows that the reasoning that there is a difference between main
>>>> calling DDD(), or calling H0(DDD) is futile. In the simplest case this
>>>> futile trick is not possible.
>>>> Therefore, we see that the whole problem is that H, or H0 is unable to
>>>> simulate itself sufficiently far enough to see the real behaviour. It
>>>> always aborts one cycle too early and, therefore, produces false
>>>> negatives.
>>>
>>> The is merely your lack or programming skill. The outer H0 always
>>> has at least one more execution trace than any of the inner ones
>>> thus if it does not abort none of them do.
>>>
>>
>> Very good olcott! We agree on this point. At least you understand
>> something of programming.
>
> I worked for the Airforce at the Airforce base with a secret
> clearance on the NPOESS Satellite ingest in C++.
> https://en.wikipedia.org/wiki/NPOESS
That satellite mever flew.
--
Mikko
[toc] | [prev] | [next] | [standalone]
Page 4 of 5 — ← Prev page 1 2 3 [4] 5 Next page →
Back to top | Article view | comp.theory
csiph-web