Re: Sequence of sequence, selection and iteration matters --- Ben proves that he agrees to my meanings

On 7/9/24 10:40 AM, olcott wrote:

On 7/9/2024 6:29 AM, Richard Damon wrote:

On 7/9/24 12:22 AM, olcott wrote:

On 7/8/2024 9:59 PM, Richard Damon wrote:

On 7/8/24 10:42 PM, olcott wrote:

On 7/8/2024 9:11 PM, Richard Damon wrote:

On 7/8/24 10:01 PM, olcott wrote:

On 7/8/2024 8:53 PM, Richard Damon wrote:

On 7/8/24 9:37 PM, olcott wrote:

On 7/8/2024 8:27 PM, Richard Damon wrote:

On 7/8/24 8:47 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

On 7/8/2024 6:59 PM, Richard Damon wrote:

On 7/8/24 7:45 PM, olcott wrote:

On 7/8/2024 6:26 PM, Richard Damon wrote:

On 7/8/24 9:04 AM, olcott wrote:

On 7/8/2024 2:22 AM, Mikko wrote:

On 2024-07-07 14:16:10 +0000, olcott said:
>

_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]
>
Sufficient knowledge of the x86 language conclusively proves
that the call from DDD correctly emulated by HHH to HHH(DDD)
cannot possibly return for any pure function HHH.

>
Suffifcient knowledge of the x86 language makes obvious that
DDD returns if and only if HHH returns.
>

>
That is insufficient knowledge. Sufficient knowledge proves that
DDD correctly simulated by HHH meets this criteria.

>
Nope, YOU have the insufficent knowledge, since you don't understand that the x86 language says programs are deterministic, and their behavior is fully establish when they are written, and running or simulating them is only a way to observe that behavior, and the only CORRECT observation of all the behavior, so letting that operation reach its final state.
>

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

>
Which you H doesn't meet, since the definition of "Correct Simulation" here (as for most people) is a simulation that exactly reproduces the behavior of the full program the input represents, which means a simulaiton that doesn't abort.
>
Since your H doesn't do that, or correctly determine what one of those would do (since it would halt since you H returns 0) so you CAN'T correctly predict that which doesn't happen.
>

>
*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*

>
No, he agress that your H, which is NOT a Halt Decider, is correctly answering your non-halt-deciding question.  In other words, it is a correct POOP decide.r
>

>
It is literally true that Ben agrees that the "if" statement
has been met.

>
Same words, but different meanings.
>
SO, NO
>

>
He literally agrees with MY meanings that the "if" has
been fulfilled.
>
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.
...
 > But H determines (correctly) that D would not halt if it were not
 > halted.  That much is a truism.
>
>
>

>
Yes, Ben agrees that

>
*That the verbatim words of the If statement are fulfilled*
>

>
In other words, you think changing meaning of words in a statement is valid logic, but it is actually one form of LIE.

>
Ben agrees:
*That the verbatim words of the If statement are fulfilled*
>

>
But with difffent meaning of the words, so you LIE.

>
Ben proved that agreed that my meanings of my words were
fulfilled by paraphrasing my words into his own words.
>
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
 > But H determines (correctly) that D would not halt if
 > it were not halted.  That much is a truism.
>
Ben only disagreed that my meanings of my words entail
the second part.

>
No, Ben agreed that with YOUR definiton of the words, which are diffferent than profressor Sipser, you can show that your POOP problem is correctly solved for P by H.
>
You are INCORRECT about Professor Sipser;s meaning, and thus about Halting.
>

>
Ben felt that HHH could say that it didn't need to
abort DDD because AFTER it does abort DDD it doesn't
need to abort DDD.
>
SEQUENCE MATTERS !!!
SEQUENCE CANNOT BE CORRECTLY IGNORED !!!
>

>
TRUTH MATTERS.
>
The problem is the thing we are talking about, the behavior of DDD isn't determined by the simulation HHH does of it, but what HHH does with its simulation. If HHH returns, then so does DDD, even if HHH doesn't see it.

>
The behavior of DDD is determined by its machine code.
>

>
Right, which include the machine code of HHH which determines that DDD will call HHH, then that HHH will do some things (emulate its copy of DDD) and then it will stop the emulation and return to DDD which returns.
>

 DDD correctly emulated by any pure function HHH that
can possibly exist cannot possibly halt. That you say
otherwise proves your incompetence with the x86 language.

Nope, if the HHH that you are talking about only "correctly emulated" its input per you definition, but actually just did a partial emulation and returned, the the actual behavior of DDD is to halt, and you claim is just a lie. Yes, the emulation by HHH doesn't show that, but partial emulations do not define the behaivor of inputs.
This is because the definition of EVERY x86 instruction that we will run into include (as part of the general description of instructions) that the next instruction after this WILL be executed (and the needs to be emulated to be completely correct, and just partially correct is just incorrect.

 _DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
 DDD is correctly emulated by HHH which calls an emulated
HHH(DDD) to repeat this process until the emulated DDD is
aborted. At no point in this emulation does the call from
DDD correctly emulated by HHH to HHH(DDD) ever return.
 

Which means that the actual behavior of the DDD that called the first HHH will be to returned to (since ALL calls to HHH(DDD) act the same) and thus halt.
The ONLY DDD that will not halt is the DDD that calls an HHH(DDD) that NEVER aborts so never returns.
You are just showing you lack of understanding about the x86 instructions set, or computers in general, or even about the nature of Truth.