On 4/14/2023 8:25 PM, Richard Damon wrote:
> On 4/14/23 9:13 PM, olcott wrote:
>> On 4/14/2023 7:54 PM, Richard Damon wrote:
>>> On 4/14/23 8:42 PM, olcott wrote:
>>>> On 4/14/2023 7:07 PM, Richard Damon wrote:
>>>>> On 4/14/23 7:46 PM, olcott wrote:
>>>>>> On 4/14/2023 6:19 PM, Richard Damon wrote:
>>>>>>> On 4/14/23 6:58 PM, olcott wrote:
>>>>>> When embedded_H correctly recognizes this behavior pattern in N
>>>>>> steps,
>>>>>> aborts its simulation and rejects this input as non-halting it is
>>>>>> merely
>>>>>> reporting on the above verified fact that ⟨Ĥ⟩ correctly simulated by
>>>>>> embedded_UTM or embedded_H cannot possibly reach its own final
>>>>>> state in
>>>>>> any finite number of steps of correct simulation.
>>>>>>
>>>>>
>>>>> Nope. It CAN'T correctly detect in N steps, as those N steps are
>>>>> the begininig of the correct simulation of UTM (Ĥ) (Ĥ) which does
>>>>> reach the final state.
>>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> *which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process*
>>>
>>> Which then STOPS when embedded_H reaches the poinnt it is simulation
>>> when it sees the machine reach the point of embdded_H (Ĥ) (Ĥ) and
>>> then rather that continuing the loop as you imply, it just aborts its
>>> simulation and goes to qn.
>>>
>>> You keep on forgetting that all copies of H need to do the same thing
>>>
>>> You fundamentally seem to not understand how programs actually work.
>>>
>>>>
>>>> In other words you can't tell from the above four steps that ⟨Ĥ⟩
>>>> correctly simulated by embedded_H cannot possibly reach its own final
>>>> state of ⟨Ĥ.qn⟩ in any finite number of steps of correct simulation?
>>>
>>> The fact that embedded_H can't simulate to the final state is
>>> IRRELEVERNT and proves your ignorance.
>>>
>>> The fact that an actual correct simulation of the input shows it does
>>> reach a final state proves that H is just wrong, and you have been
>>> LYING that H gets the correct answer.
>>>
>>>>
>>>>
>>>> Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>
>>>> which would begin at its own simulated ⟨Ĥ.q0⟩
>>>> then would transition to simulated ⟨embedded_H⟩
>>>> which would simulate ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> which would begin at its own simulated ⟨Ĥ.q0⟩
>>>>
>>>> which would begin at its own simulated ⟨Ĥ.q0⟩
>>>> then would transition to simulated ⟨embedded_H⟩
>>>> which would simulate ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> which would begin at its own simulated ⟨Ĥ.q0⟩ ...
>>>
>>> Which doesn't actually happen, becasuse you have defined H and thus
>>> embeded_H to stop its simulation at the point it (INCORRECTLY)
>>> decides that this loop occurs, and instead transition to qn.
>>>
>>
>> // We don't have to check each integer one at a time.
>> ∀x ∈ Integers (x > 5) ⊢ (x > 3)
>
> Right, but doesn't stop in N steps, doesn't say it doesn't stop in 5*N
> steps.
>

It doesn't do any steps it is confirmed to be true by static analysis.

> You just don't know how to do logic.
>
> you are making the claim that if M is the number of steps that Ĥ will
> halt in (and infinite if it never stops) that since M > N, M must be
> infinite. Ignoring that M could actually be as small as N+1.
>
> FAIL.
>
>>
>> *Likewise* the behavior of ⟨Ĥ⟩ correctly simulated by embedded_UTM
>> conclusively proves that any input defined to have a pathological
>> relationship to its simulator will never reach its own final state in
>> any finite number of steps of correct simulation.
>>
>
> Nope, since you prove with embedded_H was of a DIFFERNET Ĥ, is show
> absolutely nothing about the Ĥ.
>
> That is like saying cats bark because you dog barks.
>
>
>> ∀x ∈ TM_Descriptions
>> ∀y ∈ Simulators // including UTMs and simulating halt deciders
>> (Pathological_Relationship(x,y) ⊢ Simulated_by(x,y) →
>> Never_Reach_Final_State(x))
>>
>
> Nope. Try to actually show a proof.

Static analysis conclusively proves that every input defined to have a
pathological relationship with its simulator cannot possibly reach its
own final state in any finite number of steps of correct simulation.

Try and provide a counter-example that does not rely on the strawman error:
(a) Simulator S must have a pathological relationship to input ⟨I⟩
(b) ⟨I⟩ correctly simulated by S reaches its own final state of ⟨I.qy⟩
or ⟨I.qn⟩

I.q0 ⟨I⟩ ⊢* S ⟨I⟩ ⟨I⟩ ⊢* I.qy
I.q0 ⟨I⟩ ⊢* S ⟨I⟩ ⟨I⟩ ⊢* I.qn

Exactly how does ⟨I⟩ simulated by S reach ⟨I.qy⟩ or ⟨I.qn⟩ ???

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 4/14/23 9:50 PM, olcott wrote:
> On 4/14/2023 8:25 PM, Richard Damon wrote:
>> On 4/14/23 9:13 PM, olcott wrote:
>>> On 4/14/2023 7:54 PM, Richard Damon wrote:
>>>> On 4/14/23 8:42 PM, olcott wrote:
>>>>> On 4/14/2023 7:07 PM, Richard Damon wrote:
>>>>>> On 4/14/23 7:46 PM, olcott wrote:
>>>>>>> On 4/14/2023 6:19 PM, Richard Damon wrote:
>>>>>>>> On 4/14/23 6:58 PM, olcott wrote:
>>>>>>> When embedded_H correctly recognizes this behavior pattern in N
>>>>>>> steps,
>>>>>>> aborts its simulation and rejects this input as non-halting it is
>>>>>>> merely
>>>>>>> reporting on the above verified fact that ⟨Ĥ⟩ correctly simulated by
>>>>>>> embedded_UTM or embedded_H cannot possibly reach its own final
>>>>>>> state in
>>>>>>> any finite number of steps of correct simulation.
>>>>>>>
>>>>>>
>>>>>> Nope. It CAN'T correctly detect in N steps, as those N steps are
>>>>>> the begininig of the correct simulation of UTM (Ĥ) (Ĥ) which does
>>>>>> reach the final state.
>>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> *which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process*
>>>>
>>>> Which then STOPS when embedded_H reaches the poinnt it is simulation
>>>> when it sees the machine reach the point of embdded_H (Ĥ) (Ĥ) and
>>>> then rather that continuing the loop as you imply, it just aborts
>>>> its simulation and goes to qn.
>>>>
>>>> You keep on forgetting that all copies of H need to do the same thing
>>>>
>>>> You fundamentally seem to not understand how programs actually work.
>>>>
>>>>>
>>>>> In other words you can't tell from the above four steps that ⟨Ĥ⟩
>>>>> correctly simulated by embedded_H cannot possibly reach its own final
>>>>> state of ⟨Ĥ.qn⟩ in any finite number of steps of correct simulation?
>>>>
>>>> The fact that embedded_H can't simulate to the final state is
>>>> IRRELEVERNT and proves your ignorance.
>>>>
>>>> The fact that an actual correct simulation of the input shows it
>>>> does reach a final state proves that H is just wrong, and you have
>>>> been LYING that H gets the correct answer.
>>>>
>>>>>
>>>>>
>>>>> Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>> embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy)
>>>>> which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>
>>>>> which would begin at its own simulated ⟨Ĥ.q0⟩
>>>>> then would transition to simulated ⟨embedded_H⟩
>>>>> which would simulate ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> which would begin at its own simulated ⟨Ĥ.q0⟩
>>>>>
>>>>> which would begin at its own simulated ⟨Ĥ.q0⟩
>>>>> then would transition to simulated ⟨embedded_H⟩
>>>>> which would simulate ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> which would begin at its own simulated ⟨Ĥ.q0⟩ ...
>>>>
>>>> Which doesn't actually happen, becasuse you have defined H and thus
>>>> embeded_H to stop its simulation at the point it (INCORRECTLY)
>>>> decides that this loop occurs, and instead transition to qn.
>>>>
>>>
>>> // We don't have to check each integer one at a time.
>>> ∀x ∈ Integers (x > 5) ⊢ (x > 3)
>>
>> Right, but doesn't stop in N steps, doesn't say it doesn't stop in 5*N
>> steps.
>>
>
> It doesn't do any steps it is confirmed to be true by static analysis.
>
>> You just don't know how to do logic.
>>
>> you are making the claim that if M is the number of steps that Ĥ will
>> halt in (and infinite if it never stops) that since M > N, M must be
>> infinite. Ignoring that M could actually be as small as N+1.
>>
>> FAIL.
>>
>>>
>>> *Likewise* the behavior of ⟨Ĥ⟩ correctly simulated by embedded_UTM
>>> conclusively proves that any input defined to have a pathological
>>> relationship to its simulator will never reach its own final state in
>>> any finite number of steps of correct simulation.
>>>
>>
>> Nope, since you prove with embedded_H was of a DIFFERNET Ĥ, is show
>> absolutely nothing about the Ĥ.
>>
>> That is like saying cats bark because you dog barks.
>>
>>
>>> ∀x ∈ TM_Descriptions
>>> ∀y ∈ Simulators // including UTMs and simulating halt deciders
>>> (Pathological_Relationship(x,y) ⊢ Simulated_by(x,y) →
>>> Never_Reach_Final_State(x))
>>>
>>
>> Nope. Try to actually show a proof.
>
> Static analysis conclusively proves that every input defined to have a
> pathological relationship with its simulator cannot possibly reach its
> own final state in any finite number of steps of correct simulation.

NOPE.

Simple analysis has shown that Ĥ (Ĥ) -> Ĥ.qn and halts.

>
> Try and provide a counter-example that does not rely on the strawman error:
> (a) Simulator S must have a pathological relationship to input ⟨I⟩
> (b) ⟨I⟩ correctly simulated by S reaches its own final state of ⟨I.qy⟩
> or ⟨I.qn⟩

Why? YOUR Question is the Strawman.

The DEFINIEION of a Halt Decider is that

H (M) w -> qy if M w will Halt and -> qn if M w will never Halt.

No mention of "Simulation"

We have that you say that

H (Ĥ) (Ĥ) -> qn

But if we look at the behavior of the input

Ĥ (Ĥ) will go do Ĥ.qx (Ĥ) (Ĥ) which is a copy of H, and from your
stipulation H (Ĥ) (Ĥ) -> qn so the full trace of Ĥ is

Ĥ.q0 (Ĥ) -> Ĥ.qx (Ĥ) (Ĥ) == H (Ĥ) (Ĥ) -> Ĥ.qn which Halts.

Thus, by the definition, H to be correct needed to go to qy, but it didn/t

>
> I.q0 ⟨I⟩ ⊢* S ⟨I⟩ ⟨I⟩ ⊢* I.qy
> I.q0 ⟨I⟩ ⊢* S ⟨I⟩ ⟨I⟩ ⊢* I.qn
>
> Exactly how does ⟨I⟩ simulated by S reach ⟨I.qy⟩ or ⟨I.qn⟩ ???
>

It doesn't, but it doesn't need to.

The definition of Halting is what the machine itself does, that is what
I (I) does.

which depends on what S (I) (I) does.

SInce H (Ĥ) (Ĥ) -> qn we know that Ĥ (Ĥ) -> qn and halts, so the correct
answer is HALTING and thus H should have gone to qy.

You are just proving you don't understand what you are talking about and
have just wasted your life on a lie.