Re: Proof that DDD specifies non-halting behavior --- reviewers disagree with basic facts

On 8/16/24 4:36 PM, olcott wrote:

On 8/16/2024 3:11 PM, Mike Terry wrote:

On 16/08/2024 07:57, Fred. Zwarts wrote:

Op 15.aug.2024 om 21:39 schreef olcott:

On 8/15/2024 1:35 PM, Mike Terry wrote:

On 15/08/2024 17:30, olcott wrote:

On 8/15/2024 10:40 AM, Fred. Zwarts wrote:

Op 15.aug.2024 om 14:12 schreef olcott:

On 8/15/2024 2:00 AM, joes wrote:

Am Wed, 14 Aug 2024 16:07:43 +0100 schrieb Mike Terry:

On 14/08/2024 08:43, joes wrote:

Am Tue, 13 Aug 2024 21:38:07 -0500 schrieb olcott:

On 8/13/2024 9:29 PM, Richard Damon wrote:

On 8/13/24 8:52 PM, olcott wrote:

>

A simulation of N instructions of DDD by HHH according to the
semantics of the x86 language is necessarily correct.

Nope, it is just the correct PARTIAL emulation of the first N
instructions of DDD, and not of all of DDD,

That is what I said dufuss.

You were trying to label an incomplete/partial/aborted simulation as
correct.
>

A correct simulation of N instructions of DDD by HHH is sufficient
to correctly predict the behavior of an unlimited simulation.

Nope, if a HHH returns to its caller,

*Try to show exactly how DDD emulated by HHH returns to its caller*

how *HHH* returns

>

HHH simulates DDD    enter the matrix
    DDD calls HHH(DDD)    Fred: could be eliminated HHH simulates

DDD

    second level
      DDD calls HHH(DDD)    recursion detected
    HHH aborts, returns    outside interference DDD halts

voila

HHH halts

>
You're misunderstanding the scenario?  If your simulated HHH aborts its
simulation [line 5 above],
then the outer level H would have aborted its identical simulation
earlier.  You know that, right?

>

Of course. I made it only to illustrate one step in the paradoxical
reasoning, as long as we're calling programs that do or don't abort
the same.
>

>
It is like I always pointed out. The outer HHH cannot
wait for the inner ones to abort because it would be
waiting forever.

Exactly. And when it aborts, it aborts too soon, one cycle before the simulated HHH would abort and halt.

>
Mike corrected you on this. You are wrong.

>
For the record, I did no such thing and Fred is correct.
>

>
*Fred has the same incorrect views as joes*
*Here is where you agreed that Fred is wrong*
*when replying to joes*
>
On 8/14/2024 10:07 AM, Mike Terry wrote:
 > On 14/08/2024 08:43, joes wrote:
 >> Am Tue, 13 Aug 2024 21:38:07 -0500 schrieb olcott:
 >>> *Try to show exactly how DDD emulated by HHH
 >>>  returns to its caller*>>
 >>> (the first one doesn't even have a caller)
 >>> Use the above machine language instructions to show this.
 >> HHH simulates DDD    enter the matrix
 >>    DDD calls HHH(DDD)    Fred: could be eliminated
 >>    HHH simulates DDD    second level
 >>      DDD calls HHH(DDD)    recursion detected
 >>    HHH aborts, returns    outside interference
 >>    DDD halts        voila
 >> HHH halts
 >
 > You're misunderstanding the scenario?  If your
 > simulated HHH aborts its simulation [line 5 above],
 > then the outer level H would have aborted its
 > identical simulation earlier.  You know that, right?
 > [It's what people have been discussing here endlessly
 > for the last few months! :) ]
 >
 > So your trace is impossible...
 >
>
>

>
It is clear that olcott does not really read what I write. (Or is very short of memory.)
I never said such a thing.
I repeatedly told that the simulating HHH aborted when the simulated HHH had only one cycle to go. I never said that the simulated HHH reached it abort and halted.
In fact, I said that the fact that the simulation fails to reach the abort and halt of the simulated HHH proves that the simulation is incomplete and incorrect, because a complete simulation (such as by HHH1) shows that the simulated HHH would abort and halt.
>
It now becomes clear that you either never understood what I said, or your memory is indeed very short.
Give it some time to think about what I say, try to escape from rebuttal mode, instead of ignoring it immediately.

>
That's all correct.  Going further I'll suggest that PO really doesn't "understand" /anything/ with an abstract / logical / mathematical content.  He can't understand definitions or their role in proofs, or the role of proofs in establishing knowledge.  I'm not kidding or being rude or anything like that - it's simply the way his brain works.  *Of course* PO does not "really read what you write".  Surely you must have at least suspected this for a long time?!  [I don't notice any problem with PO's memory.]
>

 I break my points down to the basic facts of the semantics
of the x86 language and the basic facts of the semantics
of the C programming.
 I can't ever get to the point of the computer science
because reviewers disagree with these basic facts.

No, the problem is that your "facts" just disagree with the computere science you claim to be doing.

 void DDD()
{
   HHH(DDD);
}
 _DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Which is NOT a program and can not be the complete input to HHH, in fact, HHH takes the whole of memory being uses as its "finite string" input, or your problem is just falsely stated.

 <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

Right, and to statisfy this, since the only simulation that is "Correct" for the determining of the behavior of a program is a COMPLETE behaivior (and thus no partial emulation can qualify), to make the determination that its simulated D would never stop running, we mean the COMPLETELY simulated D (which can't be done by H, since it will abort its simulation if it uses part 2) will never stop running.
Since if the HHH called by DDD above EVER aborts its simulation and returns and answer, that DDD *WILL* stop running, it is IMPOSSIBLE for HHH to CORRECTLY determine that the simulation of this input will not stop running, since it will stop.

      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 words 10/13/2022>

And part 2 can only be done if part 1 is CORRECTLY determined, and since if HHH does abort and return, DDD will halt, it is IMPOSSIBLE for HHH to ever correctly determine that its input will never halt and use part 2.

 *It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted*

WRONG.
No HHH that aborts its emulation HAS correctly emulated its input according to the semantics of the x86 language, as that says the emulation can ony be correctly terminated at a terminal instrucction.
Also, if the HHH that is there does abort its emulation then the complete and correct x86 emulation of the input WILL REACH that final state, it just isn't the emulation done by HHH.

 Mike might try to change the subject but I doubt if he
would disagree with this basic fact.
 *It took me two years to find a way to define correct*
*simulation such that all disagreement looks foolish*

No, you have tried, but you words still betray you.
"DDD emualted by HHH ... reaching a final state" has as a subject, DDD, which is the PROGRAM and its behavior, not the behavior of the partial emulation done by HHH, which is just references in a subordinate clause.
If you want to talk about the emulation and not the program, then the emulaiton needs to be the subject of the sentence, something like:
"It is a fact that no correct but partial emulation of DDD by the decider HHH can ever reach the final state"
The problem with this is that it makes it clear that you are only looking at the partial emulation and thus the fact that it doesn't make it to a final state doesn't mean that the program DDD doesn't halt.
In fact, since it can be shown that if HHH does abort and return, that the DDD that it is emulating WILL halt, you are stuck in a bad corner.

 There are more steps to my proof in addition to this
yet the above portion of my proof is a necessary
prerequisite. If people disagree with arithmetic how
are we ever going to get to the subject of algebra?
 

But since you don't bave this one, your rest just don't work. Your problem is that you "logic" is based on shifting meaning between parts, and thus is just based on LIES.