Re: Liar detector: Fred, Richard, Joes and Alan --- Ben's agreement

Op 18.jul.2024 om 15:17 schreef olcott:

On 7/18/2024 2:40 AM, Mikko wrote:

On 2024-07-17 13:00:55 +0000, olcott said:
>

On 7/17/2024 1:43 AM, Mikko wrote:

On 2024-07-16 14:21:28 +0000, olcott said:

>
When simulated input DDD stops running {if and only if}
the simulation of this input DDD has been aborted this
necessitates that input DDD specifies non-halting behavior

>
DDD does not stop runnig unless it is completely exeuted.

>
_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 emulated by HHH according to the semantic meaning of
its x86 instructions never stop running unless aborted.

>
You mean HHH's simulation of DDD may not termite before HHH aborts it?

 When we examine the infinite set of every HHH/DDD pair such that:
HHH₁ one step of DDD₁ is correctly emulated by HHH₁.
HHH₂ two steps of DDD₂ are correctly emulated by HHH₂.
HHH₃ three steps of DDD₃ are correctly emulated by HHH₃.
...
HHH∞ The emulation of DDD∞ by HHH∞ never stops running.

And we have proved that each of these infinite set of simulations is incorrect.

 When each DDD of the HHH/DDD pairs above is correctly emulated
by its corresponding HHH according to the semantic meaning of its
x86 instructions it CANNOT POSSIBLY reach past its own machine
address 0000216b, not even by an act of God.

Which proves that the simulation is incorrect. Only the start of the simulation is correct, but the simulation aborts too soon, which make the simulation as a whole incorrect.

 

The behaviour specified by DDD, both by C semantics and by x86 semantics,
is halting if HHH returns. Otherwise HHH is not a decider.
>

 When HHH is required to be a pure function then only one element
of the above infinite set of every possible HHH/DDD is not a decider.
 

DDD is a misleading and unneeded complication. It is easy to eliminate DDD:
        int main() {
          return HHH(main);
        }
This has the same problem. This proves that the problem is not in DDD, but in HHH, which halts when it aborts the simulation, but it decides that the simulation of itself does not halt.
HHH is simply unable to decide about finite recursions.
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
It decides after N recursions that there is an infinite recursion, which is incorrect.
Your HHH is programmed to abort the simulation after N cycles of recursive simulations. Therefore, it is incorrect to abort the simulation of HHH when the simulated HHH has performed only N-1 cycles, because that changes the behaviour of HHH.
Since the simulated HHH always runs one cycle behind the simulating HHH, it is clear that HHH can never simulate enough cycles for a correct simulation, as is required by the x86 language.
Therefore, the simulation is incorrect according to the criteria you stipulated.
The conclusion is simple:
HHH cannot possibly simulate itself correctly.
No matter how much you want it to be correct, or how many times you repeat that it is correct, it does not change the fact that such a simulation is incorrect, because it is unable to reach the end.
Your own claim that the simulated HHH does not reach its end confirms it. The trace you have shown also proves that HHH cannot reach the end of its own simulation. So, your own claims prove that it is true that HHH cannot possibly simulate itself up to the end, which makes the simulation incorrect.
Sipser would agree that this incorrect simulation cannot be used to detect a non-halting behaviour.