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 | 7 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 5 of 5 — ← Prev page 1 2 3 4 [5]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-18 11:41 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4sdbe$1eb2f$6@dont-email.me> |
| In reply to | #107386 |
On 6/18/2024 11:32 AM, Mikko wrote:
> 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.
>
None-the-less it is a measure of my technical
competence. I worked for the Air Force weather
on another project for three years.
https://www.meteostar.com/solutionsmeteorology.html
This is when I got my secret clearance.
--
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-11 22:17 -0400 |
| Subject | Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) |
| Message-ID | <v4b0gf$3nf9m$6@i2pn2.org> |
| In reply to | #106910 |
On 6/10/24 3:21 PM, olcott wrote: > I cannot and will not tolerate the strawman deception > change-the-subject fake rebuttal. Of course, you think you are the only one that can do that. > > *I just proved that D correctly simulated by H has different* > *behavior than the directly executed D(D) and you ignored it* > Nope, you proved that H doesn't correctly simulate the input.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-10 07:16 -0400 |
| Message-ID | <v46na1$3ifov$1@i2pn2.org> |
| In reply to | #106863 |
On 6/10/24 1:17 AM, olcott wrote: > On 6/9/2024 1:33 AM, Fred. Zwarts wrote: >> Op 08.jun.2024 om 20:47 schreef olcott: >>> Before we can get to the behavior of the directly executed >>> DD(DD) we must first see that the Sipser approved criteria >>> have been met: >>> >>> <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> >>> >>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote: >>> > I don't think that is the shell game. PO really /has/ an H >>> > (it's trivial to do for this one case) that correctly determines >>> > that P(P) *would* never stop running *unless* aborted. >>> >>> Try to show how this DD correctly simulated by any HH ever >>> stops running without having its simulation aborted by HH. >> >> Stopping at your first error. So, we can focus on it. Your are asking >> a question that contradicts itself. >> A correct simulation of HH that aborts itself, should simulate up to >> the point where the simulated HH aborts. That is logically impossible. >> So, either it is a correct simulation and then we see that the >> simulated HH aborts and returns, or the simulation is incorrect, >> because it assumes incorrectly that things that happen (abort) do not >> happen. >> A premature conclusion. >> >> > > *No one has verified the actual facts of this for THREE YEARS* > *No one has verified the actual facts of this for THREE YEARS* > *No one has verified the actual facts of this for THREE YEARS* So, I guess you are admitting that you claim it as a verified fact is just a LIE. > > On 5/29/2021 2:26 PM, olcott wrote: > https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ > > THE ONLY POSSIBLE WAY for D simulated by H to have the same > behavior as the directly executed D(D) is for the instructions > of D to be incorrectly simulated by H (details provided below). So, I guess you are admitting that this means that "D correctly simulated by H" is NOT a possible equivalent statement for the behavior of the direct execution of the input as required by the Halting Problem, so you admit you have been LYING every time you imply that it is. > > _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] > > In order for D simulated by H to have the same behavior as the > directly executed D(D) H must ignore the instruction at machine > address [00000d07]. *That is an incorrect simulation of D* No, H can, and must, simulate the call instruction correctly. Your problem is that it turns out that the only way that a correct simulation by H to be an actual correct simulation that shows halting behavior, it can't answer and be a decider. > > H does not ignore that instruction and simulates itself simulating D. > The simulated H outputs its own execution trace of D. > > But your H DOES ignore the CORRECT behavior of that instruction, as a correct simulation of that instruction (by what ever type of simulation you want to do) must either continue it trace inot the function H (which none of your publish traces of the resutls of the simulation H does do) if the simulation instruction level, or it must show the effective behavior of the actaul function H, which is to return 0 (since you claim you H is correct, and correct to return 0). Neither of these is what your "correct simulation" of the input does, so it can not be a correct simulation of the input. Your H just doesn't "correctly simulate" that call instruction, but does invalid logic to conclude the wrong answer. It seems impossible for you claim that you have looked at the trace of H acuallly doing the x86 instruction trace of H to show that it was correctly determining what you claim, as your "250 page" trace turns out not to be that trace, and you admit you didn't look at it closely, and you JUST think you figured out how to get such a trace out. Thus, you could NOT have verified it 3 years ago. So, you have just been caught in a LIE.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-10 12:54 -0500 |
| Message-ID | <v47el8$idkr$1@dont-email.me> |
| In reply to | #106878 |
On 6/10/2024 6:16 AM, Richard Damon wrote: > On 6/10/24 1:17 AM, olcott wrote: >> On 6/9/2024 1:33 AM, Fred. Zwarts wrote: >>> Op 08.jun.2024 om 20:47 schreef olcott: >>>> Before we can get to the behavior of the directly executed >>>> DD(DD) we must first see that the Sipser approved criteria >>>> have been met: >>>> >>>> <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> >>>> >>>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote: >>>> > I don't think that is the shell game. PO really /has/ an H >>>> > (it's trivial to do for this one case) that correctly determines >>>> > that P(P) *would* never stop running *unless* aborted. >>>> >>>> Try to show how this DD correctly simulated by any HH ever >>>> stops running without having its simulation aborted by HH. >>> >>> Stopping at your first error. So, we can focus on it. Your are asking >>> a question that contradicts itself. >>> A correct simulation of HH that aborts itself, should simulate up to >>> the point where the simulated HH aborts. That is logically >>> impossible. So, either it is a correct simulation and then we see >>> that the simulated HH aborts and returns, or the simulation is >>> incorrect, because it assumes incorrectly that things that happen >>> (abort) do not happen. >>> A premature conclusion. >>> >>> >> >> *No one has verified the actual facts of this for THREE YEARS* >> *No one has verified the actual facts of this for THREE YEARS* >> *No one has verified the actual facts of this for THREE YEARS* > > > So, I guess you are admitting that you claim it as a verified fact is > just a LIE. > I should have said no reviewers here have verified these facts for THREE years. I have had four other reviewers that verified these facts that were not in this forum. You are ridiculously childish for saying that every tiny mistake is an intentional falsehood. >> >> On 5/29/2021 2:26 PM, olcott wrote: >> https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ >> >> THE ONLY POSSIBLE WAY for D simulated by H to have the same >> behavior as the directly executed D(D) is for the instructions >> of D to be incorrectly simulated by H (details provided below). > > So, I guess you are admitting that this means that "D correctly > simulated by H" is NOT a possible equivalent statement for the behavior > of the direct execution of the input as required by the Halting Problem, > so you admit you have been LYING every time you imply that it is. > > I am saying that no one here has bothered to carefully study the proof that I am correct in THREE SOLID YEARS. > >> >> _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] >> >> In order for D simulated by H to have the same behavior as the >> directly executed D(D) H must ignore the instruction at machine >> address [00000d07]. *That is an incorrect simulation of D* > > No, H can, and must, simulate the call instruction correctly. > The only way for D simulated by H to have the same behavior as the directly executed D(D) is for D simulated by H to skip over this call. > > Your problem is that it turns out that the only way that a correct > simulation by H to be an actual correct simulation that shows halting > behavior, it can't answer and be a decider. > <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> The above is self-evidently correct thus making it a verified fact and you and others disagree anyway. >> >> H does not ignore that instruction and simulates itself simulating D. >> The simulated H outputs its own execution trace of D. >> >> > > But your H DOES ignore the CORRECT behavior of that instruction, as a > correct simulation of that instruction (by what ever type of simulation > you want to do) must either continue it trace inot the function H (which > none of your publish traces of the resutls of the simulation H does do) > if the simulation instruction level, or it must show the effective > behavior of the actaul function H, which is to return 0 (since you claim > you H is correct, and correct to return 0). > > Neither of these is what your "correct simulation" of the input does, so > it can not be a correct simulation of the input. Your H just doesn't > "correctly simulate" that call instruction, but does invalid logic to > conclude the wrong answer. > > > It seems impossible for you claim that you have looked at the trace of H > acuallly doing the x86 instruction trace of H to show that it was > correctly determining what you claim, as your "250 page" trace turns out > not to be that trace, and you admit you didn't look at it closely, and > you JUST think you figured out how to get such a trace out. > There is no need to look at the trace of H correctly simulated by H when the trace of D correctly simulated by simulated H is proven to be correct. > Thus, you could NOT have verified it 3 years ago. > > So, you have just been caught in a LIE. I have just proven otherwise. -- 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 | joes <noreply@example.com> |
|---|---|
| Date | 2024-06-10 18:21 +0000 |
| Message-ID | <v47g6e$3ipmi$6@i2pn2.org> |
| In reply to | #106906 |
Am Mon, 10 Jun 2024 12:54:48 -0500 schrieb olcott: > On 6/10/2024 6:16 AM, Richard Damon wrote: >> On 6/10/24 1:17 AM, olcott wrote: >>> On 6/9/2024 1:33 AM, Fred. Zwarts wrote: >>>> Op 08.jun.2024 om 20:47 schreef olcott: >>>>> Try to show how this DD correctly simulated by any HH ever stops >>>>> running without having its simulation aborted by HH. >>>> >>>> Stopping at your first error. So, we can focus on it. Your are asking >>>> a question that contradicts itself. >>>> A correct simulation of HH that aborts itself, should simulate up to >>>> the point where the simulated HH aborts. That is logically >>>> impossible. So, either it is a correct simulation and then we see >>>> that the simulated HH aborts and returns, or the simulation is >>>> incorrect, because it assumes incorrectly that things that happen >>>> (abort) do not happen. Why does it need to abort, when its recursive simulation does the same and thus returns, not needing to be aborted? >> So, I guess you are admitting that this means that "D correctly >> simulated by H" is NOT a possible equivalent statement for the behavior >> of the direct execution of the input as required by the Halting >> Problem, >> so you admit you have been LYING every time you imply that it is. Are you saying that the simulation can be different from the direct execution? > The only way for D simulated by H to have the same behavior as the > directly executed D(D) is for D simulated by H to skip over this call. Does D(D) skip over this call? >> Your problem is that it turns out that the only way that a correct >> simulation by H to be an actual correct simulation that shows halting >> behavior, it can't answer and be a decider. > [no answer] >> But your H DOES ignore the CORRECT behavior of that instruction, as a >> correct simulation of that instruction (by what ever type of simulation >> you want to do) must either continue it trace into the function H >> (which none of your published traces of the results of the simulation H >> does do) if the simulation instruction level, or it must show the >> effective behavior of the actual function H, which is to return 0 >> (since you claim you H is correct, and correct to return 0). >> Neither of these is what your "correct simulation" of the input does, >> so it can not be a correct simulation of the input. Your H just doesn't >> "correctly simulate" that call instruction, but does invalid logic to >> conclude the wrong answer. >> It seems impossible for you claim that you have looked at the trace of >> H acually doing the x86 instruction trace of H to show that it was >> correctly determining what you claim, as your "250 page" trace turns >> out not to be that trace, and you admit you didn't look at it closely, >> and you JUST think you figured out how to get such a trace out. >> > There is no need to look at the trace of H correctly simulated by H when > the trace of D correctly simulated by simulated H is proven to be > correct. -- joes
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-10 13:48 -0500 |
| Message-ID | <v47hq8$itfd$1@dont-email.me> |
| In reply to | #106907 |
On 6/10/2024 1:21 PM, joes wrote:
> Am Mon, 10 Jun 2024 12:54:48 -0500 schrieb olcott:
>> On 6/10/2024 6:16 AM, Richard Damon wrote:
>>> On 6/10/24 1:17 AM, olcott wrote:
>>>> On 6/9/2024 1:33 AM, Fred. Zwarts wrote:
>>>>> Op 08.jun.2024 om 20:47 schreef olcott:
>
>>>>>> Try to show how this DD correctly simulated by any HH ever stops
>>>>>> running without having its simulation aborted by HH.
>>>>>
>>>>> Stopping at your first error. So, we can focus on it. Your are asking
>>>>> a question that contradicts itself.
>>>>> A correct simulation of HH that aborts itself, should simulate up to
>>>>> the point where the simulated HH aborts. That is logically
>>>>> impossible. So, either it is a correct simulation and then we see
>>>>> that the simulated HH aborts and returns, or the simulation is
>>>>> incorrect, because it assumes incorrectly that things that happen
>>>>> (abort) do not happen.
> Why does it need to abort, when its recursive simulation does the same
> and thus returns, not needing to be aborted?
>
void Infinite_Recursion(u32 N)
{
Infinite_Recursion(N);
}
*D correctly simulated by H is more complex yet isomorphic to the above*
*DDD is the simplest possible version of D*
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()
--
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-10 23:32 -0400 |
| Message-ID | <v48gh4$3kcoe$3@i2pn2.org> |
| In reply to | #106906 |
On 6/10/24 1:54 PM, olcott wrote: > On 6/10/2024 6:16 AM, Richard Damon wrote: >> On 6/10/24 1:17 AM, olcott wrote: >>> On 6/9/2024 1:33 AM, Fred. Zwarts wrote: >>>> Op 08.jun.2024 om 20:47 schreef olcott: >>>>> Before we can get to the behavior of the directly executed >>>>> DD(DD) we must first see that the Sipser approved criteria >>>>> have been met: >>>>> >>>>> <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> >>>>> >>>>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote: >>>>> > I don't think that is the shell game. PO really /has/ an H >>>>> > (it's trivial to do for this one case) that correctly determines >>>>> > that P(P) *would* never stop running *unless* aborted. >>>>> >>>>> Try to show how this DD correctly simulated by any HH ever >>>>> stops running without having its simulation aborted by HH. >>>> >>>> Stopping at your first error. So, we can focus on it. Your are >>>> asking a question that contradicts itself. >>>> A correct simulation of HH that aborts itself, should simulate up to >>>> the point where the simulated HH aborts. That is logically >>>> impossible. So, either it is a correct simulation and then we see >>>> that the simulated HH aborts and returns, or the simulation is >>>> incorrect, because it assumes incorrectly that things that happen >>>> (abort) do not happen. >>>> A premature conclusion. >>>> >>>> >>> >>> *No one has verified the actual facts of this for THREE YEARS* >>> *No one has verified the actual facts of this for THREE YEARS* >>> *No one has verified the actual facts of this for THREE YEARS* >> >> >> So, I guess you are admitting that you claim it as a verified fact is >> just a LIE. >> > > I should have said no reviewers here have verified these > facts for THREE years. I have had four other reviewers > that verified these facts that were not in this forum. > > You are ridiculously childish for saying that every tiny > mistake is an intentional falsehood. But REPEATING it shows it was. > >>> >>> On 5/29/2021 2:26 PM, olcott wrote: >>> https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ >>> >>> THE ONLY POSSIBLE WAY for D simulated by H to have the same >>> behavior as the directly executed D(D) is for the instructions >>> of D to be incorrectly simulated by H (details provided below). >> >> So, I guess you are admitting that this means that "D correctly >> simulated by H" is NOT a possible equivalent statement for the >> behavior of the direct execution of the input as required by the >> Halting Problem, so you admit you have been LYING every time you imply >> that it is. >> >> > > I am saying that no one here has bothered to carefully > study the proof that I am correct in THREE SOLID YEARS. WHAT PROOF? I haven't seen an actual statement of a truth-preserving operation connecting a statement accepted as true to any of your claims. Only "examples" and statements of "obvious" (with sources) > >> >>> >>> _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] >>> >>> In order for D simulated by H to have the same behavior as the >>> directly executed D(D) H must ignore the instruction at machine >>> address [00000d07]. *That is an incorrect simulation of D* >> >> No, H can, and must, simulate the call instruction correctly. >> > > The only way for D simulated by H to have the same behavior as > the directly executed D(D) is for D simulated by H to skip over > this call. You haven't proven that. And all that actualy shows is that H's simulation can't be correct in the right manner to be used for the Halting Problem. After all, the halting problem SPECIFICALLY takes about the direct execution as the criterion, and we can only talk about using simulation when that simulation agrees with that. SO, you are just admitting that your claim to working on the Halting Problem is either a LIE or evidence of your total ignorance about the subject. > >> >> Your problem is that it turns out that the only way that a correct >> simulation by H to be an actual correct simulation that shows halting >> behavior, it can't answer and be a decider. >> > > <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> And by "Correct Simulation" he means a simulation that recreates fully the behavior of the dirrectly executed machine, which requries a simulation that never aborts. Not something that H satisified or proves that it is correct about. > > The above is self-evidently correct thus making it a verified > fact and you and others disagree anyway. Yes, but not applicable to you, since you use a different definition of "correct simulation", so your quoting him this way just proves your attempt to be deceptive, in other words, to try to LIE. > >>> >>> H does not ignore that instruction and simulates itself simulating D. >>> The simulated H outputs its own execution trace of D. >>> >>> >> >> But your H DOES ignore the CORRECT behavior of that instruction, as a >> correct simulation of that instruction (by what ever type of >> simulation you want to do) must either continue it trace inot the >> function H (which none of your publish traces of the resutls of the >> simulation H does do) if the simulation instruction level, or it must >> show the effective behavior of the actaul function H, which is to >> return 0 (since you claim you H is correct, and correct to return 0). >> >> Neither of these is what your "correct simulation" of the input does, >> so it can not be a correct simulation of the input. Your H just >> doesn't "correctly simulate" that call instruction, but does invalid >> logic to conclude the wrong answer. >> >> >> It seems impossible for you claim that you have looked at the trace of >> H acuallly doing the x86 instruction trace of H to show that it was >> correctly determining what you claim, as your "250 page" trace turns >> out not to be that trace, and you admit you didn't look at it closely, >> and you JUST think you figured out how to get such a trace out. >> > > There is no need to look at the trace of H correctly simulated > by H when the trace of D correctly simulated by simulated H is > proven to be correct. But it CAN'T be if H didn't simulate the H that is PART OF D. If you try to simulate D without H, your simulation STOPS after 7 instuctions and can not continue. PERIOD. > >> Thus, you could NOT have verified it 3 years ago. >> >> So, you have just been caught in a LIE. > > I have just proven otherwise. > WHere? You have made unsubstantiated claims. Where is the accepted truth perserving operation from accepted truth makers to your claim. LIST THEM OR IT IS AN ADMITION THAT YOU HAVE LIED.
[toc] | [prev] | [standalone]
Page 5 of 5 — ← Prev page 1 2 3 4 [5]
Back to top | Article view | comp.theory
csiph-web