Re: Proof that H(D,D) meets its abort criteria --induction criteria--

On 3/20/24 2:35 PM, olcott wrote:

On 3/20/2024 1:13 PM, Richard Damon wrote:

On 3/20/24 12:29 PM, olcott wrote:

On 3/20/2024 11:12 AM, Richard Damon wrote:

On 3/19/24 2:14 PM, olcott wrote:

On 3/19/2024 12:42 PM, immibis wrote:

On 19/03/24 05:37, olcott wrote:

You are just getting nutty now. You are tossing out the sequence, selection, iteration model of computation.

>
aren't you tossing out the turing machine model of computation?
>

>
I am only tossing out the halting problem specification.
I am not saying (like Richard is saying) that sequential
code can be executed out-of-sequence.
>

>
Just more of your lies.
>
Where did I say "Sequential Code" can run out-of-sequence.
>
>
THe codes that I talk about not being in the sequence you think are two INDEPENDENT copies of the machines.
>

>
The one that is called first is executed first.

>
And I never denied that.
>
But H(D,D) doesn't "Call" D(D), it simulates it.
>

 Thus the steps of D(D) simulated by H come after H(D,D)
is executed, they do not occur in parallel at the same time.
 

The D(D) that it simulates is a machine that has already been "run", since Turing Machines are FULL computation devices that run their procesisng as soon as they are created.
>

 In some strawman deception argument the steps of D(D) come
before H(D,D) is executed.
 

This seems something you don't understand, because you seem to think that D(D) doesn't actually "run" until it is simulated.
>

 The steps of the simulated D(D) are never run, they are only simulated.
In a strawman deception argument the steps of D(D) are executed before
the steps of H(D,D).

Yes, the SIMULATION of those steps come after, but the steps that are being simmulated came before.
You seem to confuse the simulation of code with the actual running of it, and seem to forget that to actually simulate the code, the input needs to be fully defined, and thus the design phase considered completed (though you may waterfall on failure to a new design cycle).
Thus, to simulate D / H^, you need to have defined H since it depends on it, and thus the answer to H(D,D) is fixed before you run the test.

 

>

The H that is deciding the D(D) does not enforce that the ACTUAL D(D) it is simulating has not been run yet, and in fact, since we can consider Turing Machines to "auto-start" once created, it is IMPOSSIBLE to give to H a description of a D(D) that has not already run itself.
>

The one that is called first is executed first.

>
So?
>

 You tried to get away with saying otherwise.

Where?
The code was (automatically) run before simulation starts, in an independent timeline.

 

Where does H call D(D)? It SIMULATES it.
>
You seem to think that simulation is the exact same thing as EXECUTION.
>

>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
Ĥ ⟨Ĥ⟩ is executed before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ thus the executed Ĥ ⟨Ĥ⟩ is
run before the simulated one. When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ simulates its input
it can see that it must abort this simulation.

>
Yes H^ (H^) is executed before H^.H (H^) (H^) but the instance of the machine represented by that input was executed when it was created, so has already run.
>

Unless you are trying to get away with rejecting the sequence of
sequence, selection, iteration you already know that Ĥ ⟨Ĥ⟩ is always
executed before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.

Never said otherwise, and thus the correct behavior that H^ (H^) will do has been determined before H^ (H^) simulates it, so we have a definition of a correct simulation, that which matches that actual behavior.
Of course, H (or H^.H) doesn't see all that behavior, so can't use that actual behavior, only what it has seen, or can CORRECTLY deduce (which must match what actually happened to be correct) happened when it makes its decision.

 

Again, you are confusing the simulation that H, or H^.H does, with the axtual execution of them.
>
You could even look at the simulation of H^.H as telling H part of what this H^ (H^) has alteady done.
>
>

>

We, as finite humans may not know what it did, but the mathematical world of truth does.
>

>
Mathematical induction proves that after N steps of correct simulation
H correctly determines that ∞ steps of correct simulation would never
halt. *These are verified facts that you perpetually deny*

>
NOPE.
>
STATE YOUR INDUCTION CRITERIA and their proof
>

 As soon as H(D,D) sees that D calls itself with its same inputs
and there are no conditional branch instructions from the
beginning of D to its call to H(D,D) then H knows that its
simulated D(D) cannot possibly reach its own final instruction
(at line 06) in any finite number of steps of correct simulation.

Maybe it knows that IT can simulate it to that final state, but it doesn't know that if it aborts it, that the actual correct simulation (which matches that actual behavior) won't halt.
So, it can do its arguement about OTHER "similar" Hs and Ds but not for its own, which is different.

 

>
At least you finally understand how H(D,D) != H1(D,D) after two
years of failing to examine my proof that I was correct all along.

>
Only because you finally admitted that H1 was a different computation, and thus represent a different Turing Machine than H.
>

 You simply refused to look at the one page proof that I was correct
all along. At the time I thought that you had looked at it and simply
denied the easily verified facts. At the time this reasonable assumption
did justify me calling you a liar.
 

You CLAIMED it was the same computation.
I KNEW you were lying, and trying to point out your error. Of course, since you never learned (at apparently still do not know) what a computation actually is, you are been just lying out of your self-imposed ignorance, making you just a pathological liar, that can't tell truth from lies because they have lost the sense of the defintion of Truth.

>

You can't seem to comprehend that world, because you seem to like to live in your world of LIES.

>

>

 In retrospect is looks like neither one of us are liars.
 

Mope. You are still a liar, as you continue to start your lies.