Re: Liar detector: Peter Olcott --- Honest Dialogue ? --- Infinite set of HHH/DDD pairs, all wrong

On 7/22/24 10:13 AM, olcott wrote:

On 7/22/2024 3:01 AM, Mikko wrote:

On 2024-07-21 13:50:17 +0000, olcott said:
>

On 7/21/2024 4:38 AM, Mikko wrote:

On 2024-07-20 13:28:36 +0000, olcott said:
>

On 7/20/2024 3:54 AM, Mikko wrote:

On 2024-07-19 14:39:25 +0000, olcott said:
>

On 7/19/2024 3:51 AM, Mikko wrote:

>
You apparently mean that no HHHᵢ can simulate the corresponding DDDᵢ to
its termination?

>
No I don't mean that at all that incorrectly allocates the error
to the emulator.

>
Anyway you did not say that some HHHᵢ can simulate the corresponding DDDᵢ
to its termination. And each DDDᵢ does terminate, whether simulated or not.

>
*Until you quit lying about this we cannot have an honest dialog*

>
I don't believe that you can have a honest dialog, at least not without
a chairman who wants to and can keep the dialog honest.
>

>
void DDD()
{
   HHH(DDD);
   return;
}
>
When N steps of DDD are emulated by pure function HHH according
to the semantics of the x86 language then N steps are emulated correctly.
>
The subscripts to HHH and DDD pairs are each element of
the set of positive integers ℤ+
>
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ₙ n steps of DDDₙ are correctly emulated by HHHₙ.
>
Then DDD correctly simulated by any pure function HHH cannot
possibly reach its own return instruction and halt, therefore
every HHH is correct to reject its DDD as non-halting.

>
That does not follow. It is never correct to reject a halting comoputation
as non-halting.
>

 In each of the above instances DDD never reaches its return
instruction and halts. This proves that HHH is correct to
report that its DDD never halts.

No, the EMULATION of DDD never reaches that point, but DDD itself does.
Just like if someone took a movie of you for a day, that is just a movie of you, that isn't you.

 When every element of an infinite set of the DDD of HHH/DDD
pairs never halt (all black cats are black) then HHH can
report that its DDD never halts (all black cats are cats).

But just because each H looks at ONE cat, doesn't mean that all cats are black.
By that logic we could say that all numbers are even, because we could make an infinite number of testing machines, each paired to a number that just happened to be twice the id number of that machine.
ALL the machine report that their input was even, so by your logic, ALL numbers are even.
In this case, Each H, that will simulate its input for N steps, is given an input (a different one for each H, since it includes the logic of H in it) runs for 2N steps and then reaches an end.
Your logic thinks that none of them halt, but in truth, all of them do.

 Most people here seems intentionally ridiculously stupid when
it comes to hypothetical scenarios:

No, you just don't understand proper logic,

 _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]
 A correct simulation is defined as emulating the x86 instructions
of DDD according to the semantics specified by these instructions.
This includes emulating HHH emulating DDD according to the semantics
of the x86 instructions of HHH.

No, that would be emulating the instructions of HHH. The x86 has no concept at its instruction level of a program emulating another, that is just a meta-concept.
You are just proving you have a reckless disregard for the truth which has made you into an ignorant pathological liar.

 Within the hypothetical scenario where DDD is correctly emulated
by its HHH and this HHH never aborts its simulation neither DDD
nor HHH ever stops running.

Right, THAT DDD never halts, But the behavior of DDD is dependent on the HHH that it calls, so you can't use that for any other HHH.
Your logic just shows that you believe that lying is valid logic, which shows that you are a pathological liar.

 This conclusively proves that HHH is required to abort the
simulation of its corresponding DDD as required by the design
spec that every partial halt decider must halt and is otherwise
not any kind of decider at all.

No, it proves you are just a pathological liar.

 That HHH is required to abort its simulation of DDD conclusively
proves that this DDD never halts.
 

Nope, that you say that, after it has been shown to be wrong, just shows that you are just a pathological liar.