Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis

On 6/8/24 10:11 AM, olcott wrote:

On 6/8/2024 8:56 AM, Fred. Zwarts wrote:

Op 08.jun.2024 om 15:32 schreef olcott:

On 6/8/2024 8:20 AM, Fred. Zwarts wrote:

Op 08.jun.2024 om 15:04 schreef olcott:

On 6/8/2024 1:42 AM, Mikko wrote:

On 2024-06-07 22:26:05 +0000, olcott said:
>

On 6/7/2024 4:00 PM, joes wrote:

Am Fri, 07 Jun 2024 09:47:35 -0500 schrieb olcott:

On 6/7/2024 1:30 AM, Mikko wrote:

On 2024-06-06 15:31:36 +0000, olcott said:

On 6/6/2024 10:14 AM, Mikko wrote:

On 2024-06-06 13:53:58 +0000, olcott said:

On 6/6/2024 5:15 AM, Mikko wrote:

On 2024-06-05 13:29:28 +0000, olcott said:

On 6/5/2024 2:37 AM, Mikko wrote:

On 2024-06-04 18:02:03 +0000, olcott said:

>

A simulating halt decider cannot report on what the behavior of a
non-terminating input actually is because this would take forever.

Exactly. Didn't you say it is allowed to abort?
>

H is not allowed to report on any computation containing its actual self
because Turing machines can only take finite string inputs thus cannot
take Turing machines as inputs.

Bullshit. It can take other machines just fine. It doesn't know about
itself.
>

>
No actual Turing machine can be the input to any other actual
Turing machine. Turing machines only take finite string inputs.

>
Any finite string can be an input to some Turing machine.
Can you prove that a Turing machine is not a finite string?
>

>
By definition Turing Machines are not finite strings in the
conventional model. In my x86utm model of computation x86
machine language <is> the input to another function written
in the x86 language.
>

Your own attempts of a conter-proof are not about Turing machines
but C programs. C programs are finite strings, so a C program
is a valid input to a C program (and a Turing machine, too).
>

>
They are about Turing Machines yet cannot be sufficiently understood
with less than the 100% compete precision of the x86 language. They
x86utm model is required to prove that false assumptions about the
nature of correct simulation are false assumptions.
>
void DDD(int (*x)())
{
   HH(x, x);
}
>
DDD correctly simulated by any HH cannot possibly stop running
without being aborted. When this is understood and accepted then
>
When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by any embedded_H is understood
to not possibly stop running until aborted.
>
I have all of the details of the machine code and C code for HH and DDD.
I can't to the same thing for embedded_H and ⟨Ĥ⟩ ⟨Ĥ⟩ so we have to learn
by analogy.
>

This means that H is not allowed to report on the behavior of the
directly executed P(P).

So on which program does it report then?

>

>
DD(DD) is just like infinite recursion that gets terminated at
its second recursive call. DD(DD) halts only because HH(DD,DD)
correctly determines that its input DOES NOT HALT >
If HH(DD,DD) did not correctly determine that its input
DOES NOT HALT then DD(DD) would never halt.
>
>

>
Indeed, *only if*. if HH does not halt, then DD does not halt. But your claim is that HH halts, because of that DD(DD) *DOES* halt. You cannot base a conclusion on something that does not happen.

>
You are twisting the meaning of my words.

>
No, your are twisting your own words.
>

*Verified facts* (some may be beyond your technical competence)

>
Up to now, your have not been able to tell how they were verified. It seems beyond your competence to see the difference between verified facts and wishes. That is twisting the meaning of words.
>

(1) The input to HH DOES NOT HALT.

>
Only if HH (as part of the input) does not halt.
You even proved that this conclusion is a false negative on 05.jun.2024 at 15:59 (CET)
>

>
(2) HH correctly recognizes that its input DOES NOT HALT.

>
Only if HH would not abort, but it does abort.

 <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>
 I stop at the first big mistake so that we can focus on correcting
this big mistake.
 When
   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.
  

And since H doesn't do a "Correct Simulation" per the meaning that Professor Sipser uses, you can't use that clause.
You are just caught in your own deception. You forget that all Hs in the problem are the same and all will do the same thing and thus if H thinks it can abort, then the input naturally becomes halting, so H is wrong.
This is the power of Computations to include copies of other computations, and the fact that the input is created after the decider so it can use its code to confound it.