On 3/9/24 2:22 PM, olcott wrote:
> On 3/9/2024 3:50 PM, immibis wrote:
>> On 9/03/24 22:34, olcott wrote:
>>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>>> On 3/9/24 10:33 AM, olcott wrote:
>>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Specifications, not actual behavior until the existance of such an H
>>>> is shown.
>>>>
>>>> IF taken as actual behavior, then it is conditional on such an H
>>>> existing.
>>>>
>>>>>
>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>>
>>>> It NEEDS to in order to meet its specification
>>>>
>>>> It DOESN'T unless its algorithm says it does,
>>>>
>>>> If it just fails to answer, then it has failed to be a correct Halt
>>>> Decider.
>>>>
>>>> The fact that you reach this conflict in actions, is the reason Halt
>>>> Deciding is uncomputable.
>>>>
>>>>>
>>>>> *This is a verified fact*
>>>>> When simulating halt deciders always report on the behavior of
>>>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>>>
>>>> In other words, you are admitting to changing the question, and thus
>>>> LYING that you are working on the actual original problem.
>>>
>>> This must just be over your head. It is very very difficult.
>>>
>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>> wrong answer to provide?
>>>
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria
>> that H ⟨Ĥ⟩ uses.
>
> Simulating halt deciders must make sure that they themselves
> do not get stuck in infinite execution. This means that they
> must abort every simulation that cannot possibly otherwise halt.

Yes, but you can't just assume they do, you need to define on what
condition they do that.

>
> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
> its simulation.

Except that they are running the exact same code, so if the code says to
abort, they will both abort.

If the code doesn't say it will abort, it won't and get stuck not returning.

>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
> does not simulate itself in recursive simulation.
>

But because it is doing the exact same code on the exact same data will
make the same decisions.

If they COULD tell themselves apart, you might be able justify that, but
H^ specifically was define to use an EXACT copy, and Turing Machine
enable this to be done.

On 3/9/2024 5:57 PM, immibis wrote:
> On 10/03/24 00:26, olcott wrote:
>> On 3/9/2024 5:10 PM, immibis wrote:
>>> On 9/03/24 23:22, olcott wrote:
>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>
>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>> wrong answer to provide?
>>>>>>
>>>>>
>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria
>>>>> that H ⟨Ĥ⟩ uses.
>>>>
>>>> Simulating halt deciders must make sure that they themselves
>>>> do not get stuck in infinite execution. This means that they
>>>> must abort every simulation that cannot possibly otherwise halt.
>>>>
>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>> its simulation.
>>>>
>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> does not simulate itself in recursive simulation.
>>>>
>>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria
>>> that H ⟨Ĥ⟩ uses.
>>>
>>
>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>
>
> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact
> same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.

The above is true no matter what criteria that is used
as long as H is a simulating halt decider.

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

On 10/03/24 01:22, olcott wrote:
> On 3/9/2024 5:57 PM, immibis wrote:
>> On 10/03/24 00:26, olcott wrote:
>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>> On 9/03/24 23:22, olcott wrote:
>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>
>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>> wrong answer to provide?
>>>>>>>
>>>>>>
>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria
>>>>>> that H ⟨Ĥ⟩ uses.
>>>>>
>>>>> Simulating halt deciders must make sure that they themselves
>>>>> do not get stuck in infinite execution. This means that they
>>>>> must abort every simulation that cannot possibly otherwise halt.
>>>>>
>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>> its simulation.
>>>>>
>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> does not simulate itself in recursive simulation.
>>>>>
>>>>
>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria
>>>> that H ⟨Ĥ⟩ uses.
>>>>
>>>
>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>
>>
>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the
>> exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>
> The above is true no matter what criteria that is used
> as long as H is a simulating halt decider.
>

Objective criteria cannot vary based on who the subject is. They are
objective. The answer to different people is the same answer if the
criteria are objective.

On 3/9/2024 5:59 PM, immibis wrote:
> On 10/03/24 00:30, olcott wrote:
>> On 3/9/2024 5:14 PM, immibis wrote:
>>> On 9/03/24 23:39, olcott wrote:
>>>> On 3/9/2024 3:59 PM, immibis wrote:
>>>>> On 9/03/24 22:55, olcott wrote:
>>>>>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>>>>>> On 3/9/24 10:33 AM, olcott wrote:
>>>>>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different
>>>>>>>> behavior*
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>> not halt
>>>>>>>
>>>>>>> Specifications, not actual behavior until the existance of such
>>>>>>> an H is shown.
>>>>>>>
>>>>>>> IF taken as actual behavior, then it is conditional on such an H
>>>>>>> existing.
>>>>>>>
>>>>>>>>
>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>>>> to ⟨Ĥ⟩
>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>>>>>
>>>>>>> It NEEDS to in order to meet its specification
>>>>>>>
>>>>>>> It DOESN'T unless its algorithm says it does,
>>>>>>>
>>>>>>> If it just fails to answer, then it has failed to be a correct
>>>>>>> Halt Decider.
>>>>>>>
>>>>>>> The fact that you reach this conflict in actions, is the reason
>>>>>>> Halt Deciding is uncomputable.
>>>>>>>
>>>>>>>>
>>>>>>>> *This is a verified fact*
>>>>>>>> When simulating halt deciders always report on the behavior of
>>>>>>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>>>>>>
>>>>>>> In other words, you are admitting to changing the question, and
>>>>>>> thus LYING that you are working on the actual original problem.
>>>>>>>
>>>>>>>>
>>>>>>>> *This is a verified fact*
>>>>>>>> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
>>>>>>>> its own POV.
>>>>>>>
>>>>>>> Which just means you are LYING that this apply to an actual Halt
>>>>>>> Decider per the Halting Theory,
>>>>>>>
>>>>>>>>
>>>>>>>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
>>>>>>>> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
>>>>>>>> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.
>>>>>>>
>>>>>>> And thus you are admitting that the H in H^.H is WRONG and thus H
>>>>>>> is not a correct Halt Decider, because it gets some cases wrong.
>>>>>>
>>>>>> It is a verified fact that when H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meet
>>>>>> this criteria that H gets the right answer and Ĥ.H gets the wrong
>>>>>> answer.
>>>>>
>>>>> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H
>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ to both meet this criteria if you honestly followed the
>>>>> Linz proof (for Turing machines).
>>>>
>>>> This has nothing to do with the Linz proof it only pertains to whether
>>>> or not Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can meet this criteria as a Turing machine.
>>>
>>> It can't.
>>>
>>>> If it can
>>>> then there is no need for Olcott machines.
>>>
>>> In Olcott machines, it still can't, but the proof is different,
>>> because Linz's proof is for Turing machines.
>>>
>>>>> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and
>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to both meet this criteria if you honestly followed
>>>>> the modified Linz proof (for Olcott machines).
>>>>>
>>>>
>>>> It is still the case that the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will
>>>> (a) Transition to Ĥ.Hqn and halt
>>>> (b) Transition to Ĥ.Hqy and loop
>>>> (c) Loop without transitioning to Ĥ.Hqn or Ĥ.Hqy
>>>
>>>
>>>> Because Linz H only contradicts itself that means that it
>>>> does not contradict Linz H.
>>>
>>> Linz Ĥ.H is stipulated to have IDENTICAL BEHAVIOUR to Linz H.
>>>
>>> It is the case that
>>> (a) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will transition to Ĥ.Hqn and halt AND the
>>> Linz H ⟨Ĥ⟩ will transition to H.qn and halt.
>>> (b) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will transition to Ĥ.Hqy and halt AND the
>>> Linz H ⟨Ĥ⟩ will transition to H.qy and halt.
>>> (c) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will loop without transitioning to Ĥ.Hqn or
>>> Ĥ.Hqy AND the Linz H ⟨Ĥ⟩ will loop without transitioning to H.qn or H.qy
>>>
>>> THIS IS BECAUASE THEY ARE STIPULATED TO HAVE IDENTICAL BEHAVIOUR.
>>>
>>>> Thus the only reason why anyone is saying that Linz H cannot get
>>>> the right answer is because they assume that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and Linz
>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ are the same computation when I proved otherwise:
>>>
>>> Richard Damon is the one who keeps using the word "computation" even
>>> though his explanation did not work the first time, and I think he is
>>> stupid for repeating it over and over even though it didn't work.
>>>
>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>
>>> THEY ARE STIPULATED TO HAVE IDENTICAL BEHAVIOUR.
>>>
>>
>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>> *This conclusively proves that they have different behavior*
>>
> This is what you WANT the behaviour to be. It is not the ACTUAL
> behaviour. The ACTUAL behaviour IS STIPULATED TO BE PRECISELY IDENTICAL
> WITH ABSOLUTELY NO EXCEPTIONS. If the actual behaviour is not precisely
> identical with absolutely no exceptions THEN YOU ARE BEING DISHONEST.

*Only because Ĥ.H is embedded within Ĥ and H is not*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
*This conclusively proves that they have different behavior*

The above is true no matter what criteria that is used
as long as H is a simulating halt decider.

It is true because Ĥ copies its input thus never runs
out of params and H does not copy its input thus runs
out of params.

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

On 3/9/2024 6:24 PM, immibis wrote:
> On 10/03/24 01:22, olcott wrote:
>> On 3/9/2024 5:57 PM, immibis wrote:
>>> On 10/03/24 00:26, olcott wrote:
>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>
>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>> wrong answer to provide?
>>>>>>>>
>>>>>>>
>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>
>>>>>> Simulating halt deciders must make sure that they themselves
>>>>>> do not get stuck in infinite execution. This means that they
>>>>>> must abort every simulation that cannot possibly otherwise halt.
>>>>>>
>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>> its simulation.
>>>>>>
>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> does not simulate itself in recursive simulation.
>>>>>>
>>>>>
>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria
>>>>> that H ⟨Ĥ⟩ uses.
>>>>>
>>>>
>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>
>>>
>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the
>>> exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>
>> The above is true no matter what criteria that is used
>> as long as H is a simulating halt decider.
>>
>
> Objective criteria cannot vary based on who the subject is. They are
> objective. The answer to different people is the same answer if the
> criteria are objective.

It is objectively true that Ĥ.H can get stuck in recursive
simulation because Ĥ copies its input thus never runs
out of params.

It is objectively true that Ĥ cannot possibly get stuck
in recursive because H does not copy its input thus runs
out of params.

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

On 3/9/2024 6:09 PM, Richard Damon wrote:
> On 3/9/24 2:15 PM, olcott wrote:
>> On 3/9/2024 3:49 PM, immibis wrote:
>>> On 9/03/24 22:30, olcott wrote:
>>>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>>>> On 3/9/24 10:33 AM, olcott wrote:
>>>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different
>>>>>> behavior*
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>
>>>>> Specifications, not actual behavior until the existance of such an
>>>>> H is shown.
>>>>>
>>>>> IF taken as actual behavior, then it is conditional on such an H
>>>>> existing.
>>>>>
>>>>>>
>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>>>
>>>>> It NEEDS to in order to meet its specification
>>>>>
>>>> Yes. (Notice that I am agreeing with you, yet never do that with me)
>>>>
>>>>> It DOESN'T unless its algorithm says it does,
>>>>>
>>>> Yes. (Notice that I am agreeing with you, yet never do that with me)
>>>>
>>>>> If it just fails to answer, then it has failed to be a correct Halt
>>>>> Decider.
>>>>>
>>>> Yes. (Notice that I am agreeing with you, yet never do that with me)
>>>>
>>>>> The fact that you reach this conflict in actions, is the reason
>>>>> Halt Deciding is uncomputable.
>>>>
>>>> *No. We know that Ĥ ⟨Ĥ⟩ either halts or fails to halt*
>>>>
>>>> If it halts then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitioned to Ĥ.Hqn.
>>>
>>> If Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitioned to Ĥ.Hqn then H ⟨Ĥ⟩ transitioned to H.qn
>>> or else Ĥ is the wrong Ĥ or you can't read instructions.
>>>
>>
>> I generally agree that a pair of identical machines
>> must have the same behavior on the same input.
>>
>> This may not apply when these machines having identical
>> states and identical inputs:
>>
>> (a) Are out-of-sync by a whole execution trace or
>
> Nope, the machine execute INDEPENDENTLY of each other,
>
> The only thing that shows this "sync" issue is that the simulation of
> machines, where one machine simulating another might be at different
> stages.
>
> You keep on confusing the simulation of the machine with the actual
> behavior of the
>
>>
>> (b) When one of the machines is embedded within another machine
>> that would cause this embedded machine to have recursive
>> simulation that the non-embedded machine cannot possibly have.
>
> Nope.
>
> Not posssible.
>
> Please try to show how this can happen.
>
> ACTUAL INSTRUCTION that differ in path.
>
> You seem to NEED for this to be true, but it isn't
>
>>
>> *I think that the actual difference is the latter case because*
>> *we have the exact same issue when the infinite loop is removed*
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>
> Why not? H -> H^ ... H^.H -> H^ ... H^.H is getting stuck in a recusive
> simulation.
>
> Just like if F1 calls f2, and f2 calls f2, then f1 will get stuck in a
> "infinite recursive call loop" even though f1 isn't part of the loop
>>
>> *The above two behaviors are different for identical*
>> *machines with identical inputs*
>>
>
> Which just shows you don't understand what you are saying.

It is objectively true that Ĥ.H can get stuck in recursive
simulation because Ĥ copies its input thus never runs
out of params.

It is objectively true that Ĥ cannot possibly get stuck in
recursive simulation because H does not copy its input
thus runs out of params.

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

On 3/9/2024 6:19 PM, Richard Damon wrote:
> On 3/9/24 2:22 PM, olcott wrote:
>> On 3/9/2024 3:50 PM, immibis wrote:
>>> On 9/03/24 22:34, olcott wrote:
>>>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>>>> On 3/9/24 10:33 AM, olcott wrote:
>>>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different
>>>>>> behavior*
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>
>>>>> Specifications, not actual behavior until the existance of such an
>>>>> H is shown.
>>>>>
>>>>> IF taken as actual behavior, then it is conditional on such an H
>>>>> existing.
>>>>>
>>>>>>
>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>>>
>>>>> It NEEDS to in order to meet its specification
>>>>>
>>>>> It DOESN'T unless its algorithm says it does,
>>>>>
>>>>> If it just fails to answer, then it has failed to be a correct Halt
>>>>> Decider.
>>>>>
>>>>> The fact that you reach this conflict in actions, is the reason
>>>>> Halt Deciding is uncomputable.
>>>>>
>>>>>>
>>>>>> *This is a verified fact*
>>>>>> When simulating halt deciders always report on the behavior of
>>>>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>>>>
>>>>> In other words, you are admitting to changing the question, and
>>>>> thus LYING that you are working on the actual original problem.
>>>>
>>>> This must just be over your head. It is very very difficult.
>>>>
>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>> wrong answer to provide?
>>>>
>>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria
>>> that H ⟨Ĥ⟩ uses.
>>
>> Simulating halt deciders must make sure that they themselves
>> do not get stuck in infinite execution. This means that they
>> must abort every simulation that cannot possibly otherwise halt.
>
> Yes, but you can't just assume they do, you need to define on what
> condition they do that.
>
>>
>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>> its simulation.
>
> Except that they are running the exact same code, so if the code says to
> abort, they will both abort.
>
> If the code doesn't say it will abort, it won't and get stuck not
> returning.
>
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>> does not simulate itself in recursive simulation.
>>
>
> But because it is doing the exact same code on the exact same data will
> make the same decisions.
>
> If they COULD tell themselves apart, you might be able justify that, but
> H^ specifically was define to use an EXACT copy, and Turing Machine
> enable this to be done.

It is objectively true that Ĥ.H can get stuck in recursive
simulation because Ĥ copies its input thus never runs
out of params.

It is objectively true that Ĥ cannot possibly get stuck in
recursive simulation because H does not copy its input
thus runs out of params.

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

On 10/03/24 01:26, olcott wrote:
> On 3/9/2024 5:59 PM, immibis wrote:
>> On 10/03/24 00:30, olcott wrote:
>>> On 3/9/2024 5:14 PM, immibis wrote:
>>>> On 9/03/24 23:39, olcott wrote:
>>>>> On 3/9/2024 3:59 PM, immibis wrote:
>>>>>> On 9/03/24 22:55, olcott wrote:
>>>>>>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>>>>>>> On 3/9/24 10:33 AM, olcott wrote:
>>>>>>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different
>>>>>>>>> behavior*
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>> not halt
>>>>>>>>
>>>>>>>> Specifications, not actual behavior until the existance of such
>>>>>>>> an H is shown.
>>>>>>>>
>>>>>>>> IF taken as actual behavior, then it is conditional on such an H
>>>>>>>> existing.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>>>>> to ⟨Ĥ⟩
>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>>>>>>
>>>>>>>> It NEEDS to in order to meet its specification
>>>>>>>>
>>>>>>>> It DOESN'T unless its algorithm says it does,
>>>>>>>>
>>>>>>>> If it just fails to answer, then it has failed to be a correct
>>>>>>>> Halt Decider.
>>>>>>>>
>>>>>>>> The fact that you reach this conflict in actions, is the reason
>>>>>>>> Halt Deciding is uncomputable.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> *This is a verified fact*
>>>>>>>>> When simulating halt deciders always report on the behavior of
>>>>>>>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>>>>>>>
>>>>>>>> In other words, you are admitting to changing the question, and
>>>>>>>> thus LYING that you are working on the actual original problem.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> *This is a verified fact*
>>>>>>>>> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
>>>>>>>>> its own POV.
>>>>>>>>
>>>>>>>> Which just means you are LYING that this apply to an actual Halt
>>>>>>>> Decider per the Halting Theory,
>>>>>>>>
>>>>>>>>>
>>>>>>>>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
>>>>>>>>> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
>>>>>>>>> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.
>>>>>>>>
>>>>>>>> And thus you are admitting that the H in H^.H is WRONG and thus
>>>>>>>> H is not a correct Halt Decider, because it gets some cases wrong.
>>>>>>>
>>>>>>> It is a verified fact that when H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meet
>>>>>>> this criteria that H gets the right answer and Ĥ.H gets the wrong
>>>>>>> answer.
>>>>>>
>>>>>> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H
>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ to both meet this criteria if you honestly followed the
>>>>>> Linz proof (for Turing machines).
>>>>>
>>>>> This has nothing to do with the Linz proof it only pertains to whether
>>>>> or not Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can meet this criteria as a Turing machine.
>>>>
>>>> It can't.
>>>>
>>>>> If it can
>>>>> then there is no need for Olcott machines.
>>>>
>>>> In Olcott machines, it still can't, but the proof is different,
>>>> because Linz's proof is for Turing machines.
>>>>
>>>>>> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and
>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to both meet this criteria if you honestly
>>>>>> followed the modified Linz proof (for Olcott machines).
>>>>>>
>>>>>
>>>>> It is still the case that the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will
>>>>> (a) Transition to Ĥ.Hqn and halt
>>>>> (b) Transition to Ĥ.Hqy and loop
>>>>> (c) Loop without transitioning to Ĥ.Hqn or Ĥ.Hqy
>>>>
>>>>
>>>>> Because Linz H only contradicts itself that means that it
>>>>> does not contradict Linz H.
>>>>
>>>> Linz Ĥ.H is stipulated to have IDENTICAL BEHAVIOUR to Linz H.
>>>>
>>>> It is the case that
>>>> (a) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will transition to Ĥ.Hqn and halt AND the
>>>> Linz H ⟨Ĥ⟩ will transition to H.qn and halt.
>>>> (b) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will transition to Ĥ.Hqy and halt AND the
>>>> Linz H ⟨Ĥ⟩ will transition to H.qy and halt.
>>>> (c) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will loop without transitioning to Ĥ.Hqn or
>>>> Ĥ.Hqy AND the Linz H ⟨Ĥ⟩ will loop without transitioning to H.qn or
>>>> H.qy
>>>>
>>>> THIS IS BECAUASE THEY ARE STIPULATED TO HAVE IDENTICAL BEHAVIOUR.
>>>>
>>>>> Thus the only reason why anyone is saying that Linz H cannot get
>>>>> the right answer is because they assume that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and Linz
>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ are the same computation when I proved otherwise:
>>>>
>>>> Richard Damon is the one who keeps using the word "computation" even
>>>> though his explanation did not work the first time, and I think he
>>>> is stupid for repeating it over and over even though it didn't work.
>>>>
>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>
>>>> THEY ARE STIPULATED TO HAVE IDENTICAL BEHAVIOUR.
>>>>
>>>
>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>> *This conclusively proves that they have different behavior*
>>>
>> This is what you WANT the behaviour to be. It is not the ACTUAL
>> behaviour. The ACTUAL behaviour IS STIPULATED TO BE PRECISELY
>> IDENTICAL WITH ABSOLUTELY NO EXCEPTIONS. If the actual behaviour is
>> not precisely identical with absolutely no exceptions THEN YOU ARE
>> BEING DISHONEST.
>
> [irrelevant dumb bullshit]

THE ACTUAL BEHAVIOUR IS STIPULATED TO BE PRECISELY IDENTICAL WITH
ABSOLUTELY NO EXCEPTIONS AND IF YOU CANNOT UNDERSTAND THIS THEN YOU
SHOULD GO BACK TO PRIMARY SCHOOL.

On 10/03/24 01:30, olcott wrote:
> On 3/9/2024 6:24 PM, immibis wrote:
>> On 10/03/24 01:22, olcott wrote:
>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>> On 10/03/24 00:26, olcott wrote:
>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>
>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>> wrong answer to provide?
>>>>>>>>>
>>>>>>>>
>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>
>>>>>>> Simulating halt deciders must make sure that they themselves
>>>>>>> do not get stuck in infinite execution. This means that they
>>>>>>> must abort every simulation that cannot possibly otherwise halt.
>>>>>>>
>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>> its simulation.
>>>>>>>
>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>
>>>>>>
>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria
>>>>>> that H ⟨Ĥ⟩ uses.
>>>>>>
>>>>>
>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>
>>>>
>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the
>>>> exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>
>>> The above is true no matter what criteria that is used
>>> as long as H is a simulating halt decider.
>>>
>>
>> Objective criteria cannot vary based on who the subject is. They are
>> objective. The answer to different people is the same answer if the
>> criteria are objective.
>
> It is objectively true that Ĥ.H can get stuck in recursive
> simulation because Ĥ copies its input thus never runs
> out of params.
>
> It is objectively true that Ĥ cannot possibly get stuck
> in recursive because H does not copy its input thus runs
> out of params.
>

Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey could do
better. Write the Olcott machine (not x86utm) code for Ĥ and I would
show you.

On 3/9/2024 7:24 PM, immibis wrote:
> On 10/03/24 01:30, olcott wrote:
>> On 3/9/2024 6:24 PM, immibis wrote:
>>> On 10/03/24 01:22, olcott wrote:
>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>
>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>
>>>>>>>> Simulating halt deciders must make sure that they themselves
>>>>>>>> do not get stuck in infinite execution. This means that they
>>>>>>>> must abort every simulation that cannot possibly otherwise halt.
>>>>>>>>
>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>> its simulation.
>>>>>>>>
>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>
>>>>>>>
>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>
>>>>>>
>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>>
>>>>>
>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the
>>>>> exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>
>>>> The above is true no matter what criteria that is used
>>>> as long as H is a simulating halt decider.
>>>>
>>>
>>> Objective criteria cannot vary based on who the subject is. They are
>>> objective. The answer to different people is the same answer if the
>>> criteria are objective.
>>
>> It is objectively true that Ĥ.H can get stuck in recursive
>> simulation because Ĥ copies its input thus never runs
>> out of params.
>>
>> It is objectively true that Ĥ cannot possibly get stuck
>> in recursive because H does not copy its input thus runs
>> out of params.
>>
>
> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey could do
> better. Write the Olcott machine (not x86utm) code for Ĥ and I would
> show you.

*In other words you are denying these verified facts*
*In other words you are denying these verified facts*
*In other words you are denying these verified facts*

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

Execution trace of Ĥ applied to ⟨Ĥ⟩
(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
(b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
*The same execution trace occurs even when the infinite loop is removed*

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

On 10/03/24 02:29, olcott wrote:
> On 3/9/2024 7:24 PM, immibis wrote:
>> On 10/03/24 01:30, olcott wrote:
>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>> On 10/03/24 01:22, olcott wrote:
>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>
>>>>>>>>> Simulating halt deciders must make sure that they themselves
>>>>>>>>> do not get stuck in infinite execution. This means that they
>>>>>>>>> must abort every simulation that cannot possibly otherwise halt.
>>>>>>>>>
>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>> its simulation.
>>>>>>>>>
>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>
>>>>>>>
>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>>>
>>>>>>
>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the
>>>>>> exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>
>>>>> The above is true no matter what criteria that is used
>>>>> as long as H is a simulating halt decider.
>>>>>
>>>>
>>>> Objective criteria cannot vary based on who the subject is. They are
>>>> objective. The answer to different people is the same answer if the
>>>> criteria are objective.
>>>
>>> It is objectively true that Ĥ.H can get stuck in recursive
>>> simulation because Ĥ copies its input thus never runs
>>> out of params.
>>>
>>> It is objectively true that Ĥ cannot possibly get stuck
>>> in recursive because H does not copy its input thus runs
>>> out of params.
>>>
>>
>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey could
>> do better. Write the Olcott machine (not x86utm) code for Ĥ and I
>> would show you.
>
> *In other words you are denying these verified facts*
> *In other words you are denying these verified facts*
> *In other words you are denying these verified facts*
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt

That's not a verified fact, that's just something you want to be true.

∞ means infinite loop. Infinite loop doesn't halt. You see how stupid it
is, to say that an infinite loop halts?

> Execution trace of Ĥ applied to ⟨Ĥ⟩
> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process

Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS PRECISELY
IDENTICAL TO STEPS B AND C:
> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
> (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the process

On 3/9/2024 7:32 PM, immibis wrote:
> On 10/03/24 02:29, olcott wrote:
>> On 3/9/2024 7:24 PM, immibis wrote:
>>> On 10/03/24 01:30, olcott wrote:
>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>
>>>>>>>>>> Simulating halt deciders must make sure that they themselves
>>>>>>>>>> do not get stuck in infinite execution. This means that they
>>>>>>>>>> must abort every simulation that cannot possibly otherwise halt.
>>>>>>>>>>
>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>> its simulation.
>>>>>>>>>>
>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩
>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>>>>
>>>>>>>
>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the
>>>>>>> exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>
>>>>>> The above is true no matter what criteria that is used
>>>>>> as long as H is a simulating halt decider.
>>>>>>
>>>>>
>>>>> Objective criteria cannot vary based on who the subject is. They
>>>>> are objective. The answer to different people is the same answer if
>>>>> the criteria are objective.
>>>>
>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>> simulation because Ĥ copies its input thus never runs
>>>> out of params.
>>>>
>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>> in recursive because H does not copy its input thus runs
>>>> out of params.
>>>>
>>>
>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey could
>>> do better. Write the Olcott machine (not x86utm) code for Ĥ and I
>>> would show you.
>>
>> *In other words you are denying these verified facts*
>> *In other words you are denying these verified facts*
>> *In other words you are denying these verified facts*
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> That's not a verified fact, that's just something you want to be true.
>
> ∞ means infinite loop. Infinite loop doesn't halt. You see how stupid it
> is, to say that an infinite loop halts?
>
>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>
> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS PRECISELY
> IDENTICAL TO STEPS B AND C:
> > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
> > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the process
>

*Yes and the key step of copying its input is left out so*
*H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out of params*

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

On 10/03/24 02:37, olcott wrote:
> On 3/9/2024 7:32 PM, immibis wrote:
>> On 10/03/24 02:29, olcott wrote:
>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>> On 10/03/24 01:30, olcott wrote:
>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>
>>>>>>>>>>> Simulating halt deciders must make sure that they themselves
>>>>>>>>>>> do not get stuck in infinite execution. This means that they
>>>>>>>>>>> must abort every simulation that cannot possibly otherwise halt.
>>>>>>>>>>>
>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>> aborts
>>>>>>>>>>> its simulation.
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H
>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use
>>>>>>>> the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>
>>>>>>> The above is true no matter what criteria that is used
>>>>>>> as long as H is a simulating halt decider.
>>>>>>>
>>>>>>
>>>>>> Objective criteria cannot vary based on who the subject is. They
>>>>>> are objective. The answer to different people is the same answer
>>>>>> if the criteria are objective.
>>>>>
>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>> simulation because Ĥ copies its input thus never runs
>>>>> out of params.
>>>>>
>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>> in recursive because H does not copy its input thus runs
>>>>> out of params.
>>>>>
>>>>
>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey could
>>>> do better. Write the Olcott machine (not x86utm) code for Ĥ and I
>>>> would show you.
>>>
>>> *In other words you are denying these verified facts*
>>> *In other words you are denying these verified facts*
>>> *In other words you are denying these verified facts*
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> That's not a verified fact, that's just something you want to be true.
>>
>> ∞ means infinite loop. Infinite loop doesn't halt. You see how stupid
>> it is, to say that an infinite loop halts?
>>
>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>
>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS PRECISELY
>> IDENTICAL TO STEPS B AND C:
>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the process
>>
>
> *Yes and the key step of copying its input is left out so*
> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out of params*
>

that isn't how any of this works. Do you even know what words mean?

On 3/9/24 4:33 PM, olcott wrote:
> On 3/9/2024 6:09 PM, Richard Damon wrote:
>> On 3/9/24 2:15 PM, olcott wrote:
>>> On 3/9/2024 3:49 PM, immibis wrote:
>>>> On 9/03/24 22:30, olcott wrote:
>>>>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>>>>> On 3/9/24 10:33 AM, olcott wrote:
>>>>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different
>>>>>>> behavior*
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>
>>>>>> Specifications, not actual behavior until the existance of such an
>>>>>> H is shown.
>>>>>>
>>>>>> IF taken as actual behavior, then it is conditional on such an H
>>>>>> existing.
>>>>>>
>>>>>>>
>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to
>>>>>>> ⟨Ĥ⟩
>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>>>>
>>>>>> It NEEDS to in order to meet its specification
>>>>>>
>>>>> Yes. (Notice that I am agreeing with you, yet never do that with me)
>>>>>
>>>>>> It DOESN'T unless its algorithm says it does,
>>>>>>
>>>>> Yes. (Notice that I am agreeing with you, yet never do that with me)
>>>>>
>>>>>> If it just fails to answer, then it has failed to be a correct
>>>>>> Halt Decider.
>>>>>>
>>>>> Yes. (Notice that I am agreeing with you, yet never do that with me)
>>>>>
>>>>>> The fact that you reach this conflict in actions, is the reason
>>>>>> Halt Deciding is uncomputable.
>>>>>
>>>>> *No. We know that Ĥ ⟨Ĥ⟩ either halts or fails to halt*
>>>>>
>>>>> If it halts then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitioned to Ĥ.Hqn.
>>>>
>>>> If Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitioned to Ĥ.Hqn then H ⟨Ĥ⟩ transitioned to H.qn
>>>> or else Ĥ is the wrong Ĥ or you can't read instructions.
>>>>
>>>
>>> I generally agree that a pair of identical machines
>>> must have the same behavior on the same input.
>>>
>>> This may not apply when these machines having identical
>>> states and identical inputs:
>>>
>>> (a) Are out-of-sync by a whole execution trace or
>>
>> Nope, the machine execute INDEPENDENTLY of each other,
>>
>> The only thing that shows this "sync" issue is that the simulation of
>> machines, where one machine simulating another might be at different
>> stages.
>>
>> You keep on confusing the simulation of the machine with the actual
>> behavior of the
>>
>>>
>>> (b) When one of the machines is embedded within another machine
>>> that would cause this embedded machine to have recursive
>>> simulation that the non-embedded machine cannot possibly have.
>>
>> Nope.
>>
>> Not posssible.
>>
>> Please try to show how this can happen.
>>
>> ACTUAL INSTRUCTION that differ in path.
>>
>> You seem to NEED for this to be true, but it isn't
>>
>>>
>>> *I think that the actual difference is the latter case because*
>>> *we have the exact same issue when the infinite loop is removed*
>>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>
>> Why not? H -> H^ ... H^.H -> H^ ... H^.H is getting stuck in a
>> recusive simulation.
>>
>> Just like if F1 calls f2, and f2 calls f2, then f1 will get stuck in a
>> "infinite recursive call loop" even though f1 isn't part of the loop
>>>
>>> *The above two behaviors are different for identical*
>>> *machines with identical inputs*
>>>
>>
>> Which just shows you don't understand what you are saying.
>
> It is objectively true that Ĥ.H can get stuck in recursive
> simulation because Ĥ copies its input thus never runs
> out of params.
>
> It is objectively true that Ĥ cannot possibly get stuck in
> recursive simulation  because H does not copy its input
> thus runs out of params.
>
>

WRONG.

If H never aborts is simulation, then it will just keep simulating the
recursive simulation of H^.H, which will also never abort its simulation.

This is what WILL happen if H tries to wait to see the decision that
H^.H is going to make, because the copy in H that is at H^.H will also
try to wait to see the descision that the H^.H it is simulating is going
to make, and so on.

You just don't seem to understand that exact same code using the exact
same data is going to produce the exact same results.

Yes, the code before H.H could be nice and do something to break the
cycle, but it HOSTILE to H, and wants it to fail, so isn't going to help.

The need to abort isn't on H^, it is on H, and thus either ALL copies
will do it, or NONE will do it.

Until you can show how executing the EXACT SAME sequence of statements
starting with the EXACT SAME data can lead to different result, you are
just caught in a LIE that they can act different.

Try to show a Turing Machine step that can start the same but end up in
two different results.

It is IMPOSSIBLE.

And you logic is just unsound because you aren't working from actual
facts, but things your "need" to happen, so you assume the DO happen.

On 3/9/24 4:34 PM, olcott wrote:
> On 3/9/2024 6:19 PM, Richard Damon wrote:
>> On 3/9/24 2:22 PM, olcott wrote:
>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>> On 9/03/24 22:34, olcott wrote:
>>>>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>>>>> On 3/9/24 10:33 AM, olcott wrote:
>>>>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different
>>>>>>> behavior*
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>
>>>>>> Specifications, not actual behavior until the existance of such an
>>>>>> H is shown.
>>>>>>
>>>>>> IF taken as actual behavior, then it is conditional on such an H
>>>>>> existing.
>>>>>>
>>>>>>>
>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to
>>>>>>> ⟨Ĥ⟩
>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>>>>
>>>>>> It NEEDS to in order to meet its specification
>>>>>>
>>>>>> It DOESN'T unless its algorithm says it does,
>>>>>>
>>>>>> If it just fails to answer, then it has failed to be a correct
>>>>>> Halt Decider.
>>>>>>
>>>>>> The fact that you reach this conflict in actions, is the reason
>>>>>> Halt Deciding is uncomputable.
>>>>>>
>>>>>>>
>>>>>>> *This is a verified fact*
>>>>>>> When simulating halt deciders always report on the behavior of
>>>>>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>>>>>
>>>>>> In other words, you are admitting to changing the question, and
>>>>>> thus LYING that you are working on the actual original problem.
>>>>>
>>>>> This must just be over your head. It is very very difficult.
>>>>>
>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>> wrong answer to provide?
>>>>>
>>>>
>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria
>>>> that H ⟨Ĥ⟩ uses.
>>>
>>> Simulating halt deciders must make sure that they themselves
>>> do not get stuck in infinite execution. This means that they
>>> must abort every simulation that cannot possibly otherwise halt.
>>
>> Yes, but you can't just assume they do, you need to define on what
>> condition they do that.
>>
>>>
>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>> its simulation.
>>
>> Except that they are running the exact same code, so if the code says
>> to abort, they will both abort.
>>
>> If the code doesn't say it will abort, it won't and get stuck not
>> returning.
>>
>>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> does not simulate itself in recursive simulation.
>>>
>>
>> But because it is doing the exact same code on the exact same data
>> will make the same decisions.
>>
>> If they COULD tell themselves apart, you might be able justify that,
>> but H^ specifically was define to use an EXACT copy, and Turing
>> Machine enable this to be done.
>
> It is objectively true that Ĥ.H can get stuck in recursive
> simulation because Ĥ copies its input thus never runs
> out of params.
>
> It is objectively true that Ĥ cannot possibly get stuck in
> recursive simulation  because H does not copy its input
> thus runs out of params.
>
>

WRONG.

H can get stuck, if it simulates an input that neer stops runnning
unless it aborts that simulation.

If the code in H doesn't abort its simulation of (H^) (H^), then neither
will finish and both will run forever and H fails to be a decider.

If you try to have the H in H^.H abort its simulation, the only way to
do that is put that in the algorithm of H, so then H will also abort its
simulation before it sees what H^.H will do.

If you repeat this FALSE claim again, I will start pointing out your
mental state.

On 3/9/24 1:55 PM, olcott wrote:
> On 3/9/2024 3:17 PM, Richard Damon wrote:
>> On 3/9/24 10:33 AM, olcott wrote:
>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Specifications, not actual behavior until the existance of such an H
>> is shown.
>>
>> IF taken as actual behavior, then it is conditional on such an H
>> existing.
>>
>>>
>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>
>> It NEEDS to in order to meet its specification
>>
>> It DOESN'T unless its algorithm says it does,
>>
>> If it just fails to answer, then it has failed to be a correct Halt
>> Decider.
>>
>> The fact that you reach this conflict in actions, is the reason Halt
>> Deciding is uncomputable.
>>
>>>
>>> *This is a verified fact*
>>> When simulating halt deciders always report on the behavior of
>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>
>> In other words, you are admitting to changing the question, and thus
>> LYING that you are working on the actual original problem.
>>
>>>
>>> *This is a verified fact*
>>> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
>>> its own POV.
>>
>> Which just means you are LYING that this apply to an actual Halt
>> Decider per the Halting Theory,
>>
>>>
>>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
>>> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
>>> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.
>>
>> And thus you are admitting that the H in H^.H is WRONG and thus H is
>> not a correct Halt Decider, because it gets some cases wrong.
>
> It is a verified fact that when H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meet this
> criteria that H gets the right answer and Ĥ.H gets the wrong answer.

And thus H is not a Halt Decider, since one invokation of it gave the
wrong answer.

>
> What it not a verified fact is whether or not Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can meet
> this criteria as a Turing machine.
>
> If it cannot meet this criteria as a Turing machine then it is
> still that case that Ĥ ⟨Ĥ⟩ either halts or fails to halt.
>
> It may fail to halt by looping without ever transitioning to
> Ĥ.Hqy or Ĥ.Hqn. I see no reason why H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot see this.

Because the only reason that this happens is that the algorithm for H
doesn't have any code that sees the infinite recursion forming.

IF H has it, then H^.H has it, and will stop it then, but not know what
the machine it is simulating will do.

>
> I generally agree that a pair of identical machines
> must have the same behavior on the same input.
>
> This may not apply when these machines having identical
> states and identical inputs:

Nope, IDENTICAL MACHINE WITH IDENTICL INPUTS **ALWAYS** act the same

PERIOD.
>
> (a) Are out-of-sync by a whole execution trace or
>
> (b) When one of the machines is embedded within another machine
> that would cause this embedded machine to have recursive
> simulation that the non-embedded machine cannot possibly have.
>
> *I think that the actual difference is the latter case because*
> *we have the exact same issue when the infinite loop is removed*
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>

Nope, explained elsewhere.

On 3/9/24 2:39 PM, olcott wrote:
> On 3/9/2024 3:59 PM, immibis wrote:
>> On 9/03/24 22:55, olcott wrote:
>>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>>> On 3/9/24 10:33 AM, olcott wrote:
>>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Specifications, not actual behavior until the existance of such an H
>>>> is shown.
>>>>
>>>> IF taken as actual behavior, then it is conditional on such an H
>>>> existing.
>>>>
>>>>>
>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>>
>>>> It NEEDS to in order to meet its specification
>>>>
>>>> It DOESN'T unless its algorithm says it does,
>>>>
>>>> If it just fails to answer, then it has failed to be a correct Halt
>>>> Decider.
>>>>
>>>> The fact that you reach this conflict in actions, is the reason Halt
>>>> Deciding is uncomputable.
>>>>
>>>>>
>>>>> *This is a verified fact*
>>>>> When simulating halt deciders always report on the behavior of
>>>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>>>
>>>> In other words, you are admitting to changing the question, and thus
>>>> LYING that you are working on the actual original problem.
>>>>
>>>>>
>>>>> *This is a verified fact*
>>>>> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
>>>>> its own POV.
>>>>
>>>> Which just means you are LYING that this apply to an actual Halt
>>>> Decider per the Halting Theory,
>>>>
>>>>>
>>>>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
>>>>> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
>>>>> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.
>>>>
>>>> And thus you are admitting that the H in H^.H is WRONG and thus H is
>>>> not a correct Halt Decider, because it gets some cases wrong.
>>>
>>> It is a verified fact that when H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meet this
>>> criteria that H gets the right answer and Ĥ.H gets the wrong answer.
>>
>> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩
>> ⟨Ĥ⟩ to both meet this criteria if you honestly followed the Linz proof
>> (for Turing machines).
>
> This has nothing to do with the Linz proof it only pertains to whether
> or not Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can meet this criteria as a Turing machine. If it can
> then there is no need for Olcott machines.
>
>> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H
>> ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to both meet this criteria if you honestly followed the
>> modified Linz proof (for Olcott machines).
>>
>
> It is still the case that the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will
> (a) Transition to Ĥ.Hqn and halt
> (b) Transition to Ĥ.Hqy and loop
> (c) Loop without transitioning to Ĥ.Hqn or Ĥ.Hqy
>
> Because Linz H only contradicts itself that means that it
> does not contradict Linz H.
>
> Thus the only reason why anyone is saying that Linz H cannot get
> the right answer is because they assume that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and Linz
> H ⟨Ĥ⟩ ⟨Ĥ⟩ are the same computation when I proved otherwise:
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>

Nope, proven elsewhere

H gets stuck if it doesn't aborts and wait for the input to decide,
because then then H^.H will also not abort and wait for the machine it
is simulating to decide, which will wait for the machine IT is
simulating to make its decision to decide and so on.

The is no actual requirement that H^.H will abort, it does it only if H
does.

On 3/9/24 2:10 PM, olcott wrote:
> On 3/9/2024 3:39 PM, immibis wrote:
>> On 9/03/24 19:33, olcott wrote:
>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>
>> It is only verified that you would like them to have different
>> behaviour, not that they actually do.
>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> ∞ means it doesn't halt
>>
>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>
>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>
>> I DON'T CARE what it MUST do, only what it ACTUALLY does. You fail to
>> realize this or you are dishonestly ignoring this.
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does abort its simulation. This is a verified fact.
>
> As Richard correctly pointed out this is not a verified fact.
> The only verified fact here is that when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meets is
> spec then it aborts its simulation.
>
>> Ĥ ⟨Ĥ⟩ halts. This is a verified fact.
>>
> Only within the assumption that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meets its spec.
>
>>> *This is a verified fact*
>>> When simulating halt deciders always report on the behavior of
>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>
>> Nobody cares about POV. There is no POV in the halting problem. The
>> program halts, or it doesn't halt. End of story.
>>
> This criteria is the only criteria where Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
> wrong answer to provide that enables H ⟨Ĥ⟩ ⟨Ĥ⟩ to provide the
> correct answer. Historically Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would simply loop and
> never reach either Ĥ.Hqy or Ĥ.Hqn.
>
>> Ĥ ⟨Ĥ⟩ halts. This is a verified fact.
>>
> Not it is not. It only halts if Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meets its design spec
> and a Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ might not be able to do that.
>
> <snip issues already addressed>
>
>>> Because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ seem to be identical machines
>>> on identical input that have different behavior we must
>>> somehow explain how they are not identical machines with
>>> identical inputs.
>>
>> I agree. But please understand: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ are
>> stipulated to be identical because they are Turing machines, and
>> identical Turing machines with identical input always produce
>> identical output. The Linz proof does not work for other types of
>> machines.
>>
>
> I generally agree that a pair of identical machines
> must have the same behavior on the same input.
>
> This may not apply when these machines having identical
> states and identical inputs:
>
> (a) Are out-of-sync by a whole execution trace or
>
> (b) When one of the machines is embedded within another machine
> that would cause this embedded machine to have recursive
> simulation that the non-embedded machine cannot possibly have.
>
> *I think that the actual difference is the latter case because*
> *we have the exact same issue when the infinite loop is removed*
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>
>> The halting problem is uncomputable with Olcott machines, but the
>> proof is different. In the Olcott machine version of the Linz proof,
>> Ĥ.H isn't an identical copy of H, but it does compute identical output
>> when the input is identical.
>
> If Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot meet this criteria as a Turing machine then
> it is still that case that Ĥ ⟨Ĥ⟩ either halts or fails to halt.
>
> It may fail to halt by looping without ever transitioning to
> Ĥ.Hqy or Ĥ.Hqn. I see no reason why H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot see this.
>
>

Because if H tries to wait to see what H^ does, then so does H^.H, and
so does the machine that is simulating, ...

So, Either H aborts its simulation before it knows (and then all do) or
it doesn't abort its simulation, and gets stuck in an infinite simulation.

On 3/9/24 2:46 PM, olcott wrote:
> On 3/9/2024 12:33 PM, olcott wrote:
>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>
>> *This is a verified fact*
>> When simulating halt deciders always report on the behavior of
>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>> transitions to Ĥ.Hqn it is correct from its own POV.
>>
>> *This is a verified fact*
>> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
>> its own POV.
>>
>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
>> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
>> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.
>>
>> *Verified facts*
>> (a) It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the
>> simulation of its input to prevent its own infinite execution.
>>
>> (b) It is a verified fact when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see that it
>> must abort its simulation then it would transition to Ĥ.Hqn
>> to reject this input as non-halting from its own POV.
>>
>> (c) It is a verified fact when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot see that it
>> must abort its simulation then it would transition to Ĥ.Hqy
>> and loop.
>>
>> (d) (b) gives H ⟨Ĥ⟩ ⟨Ĥ⟩ the basis to transition to H.qy.
>> (e) (c) gives H ⟨Ĥ⟩ ⟨Ĥ⟩ the basis to transition to H.qn.
>>
>> Because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ seem to be identical machines
>> on identical input that have different behavior we must
>> somehow explain how they are not identical machines with
>> identical inputs.
>
> Because Linz H only contradicts itself that means that it
> does not contradict Linz H.

No, Linz H^ contradicts Linz H, not H^, as Linz H^ isn't a decider.

>
> Thus the only reason why anyone is saying that Linz H cannot get
> the right answer is because they assume that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and Linz
> H ⟨Ĥ⟩ ⟨Ĥ⟩ are the same computation when I proved otherwise:

Then you did something wrong.
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ *can possibly get stuck in recursive simulation*
> and
> H ⟨Ĥ⟩ ⟨Ĥ⟩ *cannot possibly get stuck in recursive simulation*
>

But it CAN, as has been shown.

If H waits, so does H^.H, and so does ever version down the line leading
us to the infinite depth recursion.

H can get stuck in that because it never sees the way out, or it would
never happen.

On 3/9/24 5:37 PM, olcott wrote:
> On 3/9/2024 7:32 PM, immibis wrote:
>> On 10/03/24 02:29, olcott wrote:
>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>> On 10/03/24 01:30, olcott wrote:
>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>
>>>>>>>>>>> Simulating halt deciders must make sure that they themselves
>>>>>>>>>>> do not get stuck in infinite execution. This means that they
>>>>>>>>>>> must abort every simulation that cannot possibly otherwise halt.
>>>>>>>>>>>
>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>> aborts
>>>>>>>>>>> its simulation.
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H
>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use
>>>>>>>> the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>
>>>>>>> The above is true no matter what criteria that is used
>>>>>>> as long as H is a simulating halt decider.
>>>>>>>
>>>>>>
>>>>>> Objective criteria cannot vary based on who the subject is. They
>>>>>> are objective. The answer to different people is the same answer
>>>>>> if the criteria are objective.
>>>>>
>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>> simulation because Ĥ copies its input thus never runs
>>>>> out of params.
>>>>>
>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>> in recursive because H does not copy its input thus runs
>>>>> out of params.
>>>>>
>>>>
>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey could
>>>> do better. Write the Olcott machine (not x86utm) code for Ĥ and I
>>>> would show you.
>>>
>>> *In other words you are denying these verified facts*
>>> *In other words you are denying these verified facts*
>>> *In other words you are denying these verified facts*
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> That's not a verified fact, that's just something you want to be true.
>>
>> ∞ means infinite loop. Infinite loop doesn't halt. You see how stupid
>> it is, to say that an infinite loop halts?
>>
>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>
>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS PRECISELY
>> IDENTICAL TO STEPS B AND C:
>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the process
>>
>
> *Yes and the key step of copying its input is left out so*
> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out of params*
>

You are just being down right stupid.

H (H^) (H^) is not H (H) (H)

The later runs out of parms, but is nowhere actually in view.

H (H^) (H^) will simulate H^ (H^) which will go to H^.H (H^) (H^)
which will simulate H^ (H^) which will go to H^.H (H^) (H^)

and so on, unless the code in H will stop this somewhere.

Thus, H (H^) (H^) can get stuck in the exact same "infinte recursio" as
H^.H (H^) (H^)

Once you put that abort in somewhere, H is now stuck not being able to
see what H^ (H^) ends up doing, as it is aborted before its
H^.H (H^) (H^) reaches its point of decision.

This is the crux of the conundrum that H is in.

On 3/9/24 3:30 PM, olcott wrote:
> On 3/9/2024 5:14 PM, immibis wrote:
>> On 9/03/24 23:39, olcott wrote:
>>> On 3/9/2024 3:59 PM, immibis wrote:
>>>> On 9/03/24 22:55, olcott wrote:
>>>>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>>>>> On 3/9/24 10:33 AM, olcott wrote:
>>>>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different
>>>>>>> behavior*
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>
>>>>>> Specifications, not actual behavior until the existance of such an
>>>>>> H is shown.
>>>>>>
>>>>>> IF taken as actual behavior, then it is conditional on such an H
>>>>>> existing.
>>>>>>
>>>>>>>
>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to
>>>>>>> ⟨Ĥ⟩
>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>>>>
>>>>>> It NEEDS to in order to meet its specification
>>>>>>
>>>>>> It DOESN'T unless its algorithm says it does,
>>>>>>
>>>>>> If it just fails to answer, then it has failed to be a correct
>>>>>> Halt Decider.
>>>>>>
>>>>>> The fact that you reach this conflict in actions, is the reason
>>>>>> Halt Deciding is uncomputable.
>>>>>>
>>>>>>>
>>>>>>> *This is a verified fact*
>>>>>>> When simulating halt deciders always report on the behavior of
>>>>>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>>>>>
>>>>>> In other words, you are admitting to changing the question, and
>>>>>> thus LYING that you are working on the actual original problem.
>>>>>>
>>>>>>>
>>>>>>> *This is a verified fact*
>>>>>>> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
>>>>>>> its own POV.
>>>>>>
>>>>>> Which just means you are LYING that this apply to an actual Halt
>>>>>> Decider per the Halting Theory,
>>>>>>
>>>>>>>
>>>>>>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
>>>>>>> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
>>>>>>> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.
>>>>>>
>>>>>> And thus you are admitting that the H in H^.H is WRONG and thus H
>>>>>> is not a correct Halt Decider, because it gets some cases wrong.
>>>>>
>>>>> It is a verified fact that when H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meet this
>>>>> criteria that H gets the right answer and Ĥ.H gets the wrong answer.
>>>>
>>>> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩
>>>> ⟨Ĥ⟩ to both meet this criteria if you honestly followed the Linz
>>>> proof (for Turing machines).
>>>
>>> This has nothing to do with the Linz proof it only pertains to whether
>>> or not Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can meet this criteria as a Turing machine.
>>
>> It can't.
>>
>>> If it can
>>> then there is no need for Olcott machines.
>>
>> In Olcott machines, it still can't, but the proof is different,
>> because Linz's proof is for Turing machines.
>>
>>>> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H
>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to both meet this criteria if you honestly followed the
>>>> modified Linz proof (for Olcott machines).
>>>>
>>>
>>> It is still the case that the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will
>>> (a) Transition to Ĥ.Hqn and halt
>>> (b) Transition to Ĥ.Hqy and loop
>>> (c) Loop without transitioning to Ĥ.Hqn or Ĥ.Hqy
>>
>>
>>> Because Linz H only contradicts itself that means that it
>>> does not contradict Linz H.
>>
>> Linz Ĥ.H is stipulated to have IDENTICAL BEHAVIOUR to Linz H.
>>
>> It is the case that
>> (a) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will transition to Ĥ.Hqn and halt AND the
>> Linz H ⟨Ĥ⟩ will transition to H.qn and halt.
>> (b) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will transition to Ĥ.Hqy and halt AND the
>> Linz H ⟨Ĥ⟩ will transition to H.qy and halt.
>> (c) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will loop without transitioning to Ĥ.Hqn or
>> Ĥ.Hqy AND the Linz H ⟨Ĥ⟩ will loop without transitioning to H.qn or H.qy
>>
>> THIS IS BECAUASE THEY ARE STIPULATED TO HAVE IDENTICAL BEHAVIOUR.
>>
>>> Thus the only reason why anyone is saying that Linz H cannot get
>>> the right answer is because they assume that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and Linz
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ are the same computation when I proved otherwise:
>>
>> Richard Damon is the one who keeps using the word "computation" even
>> though his explanation did not work the first time, and I think he is
>> stupid for repeating it over and over even though it didn't work.
>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>
>> THEY ARE STIPULATED TO HAVE IDENTICAL BEHAVIOUR.
>>
>
> *Only because Ĥ.H is embedded within Ĥ and H is not*
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
> *This conclusively proves that they have different behavior*
>

H^.H being embedded in H^ makes NO difference to the processing of the
algorithm of H that is there. All it sees is what is on the tape, which
is IDENTICAL to what is on the tape when you run H (H^) (H^).

Identical instructions run on Identical data yields Identical results

PERIOD.

Show a Turing Machihe instruction that can violate that principle.

No Turing Instruction depends on ANYTHING but the State Transistion
Table of the step (which is equivalent for both instances) and the tape
contents (which are also Identical here)

On 3/9/2024 7:40 PM, immibis wrote:
> On 10/03/24 02:37, olcott wrote:
>> On 3/9/2024 7:32 PM, immibis wrote:
>>> On 10/03/24 02:29, olcott wrote:
>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>
>>>>>>>>>>>> Simulating halt deciders must make sure that they themselves
>>>>>>>>>>>> do not get stuck in infinite execution. This means that they
>>>>>>>>>>>> must abort every simulation that cannot possibly otherwise
>>>>>>>>>>>> halt.
>>>>>>>>>>>>
>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>> aborts
>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H
>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use
>>>>>>>>> the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>
>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>
>>>>>>>
>>>>>>> Objective criteria cannot vary based on who the subject is. They
>>>>>>> are objective. The answer to different people is the same answer
>>>>>>> if the criteria are objective.
>>>>>>
>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>> out of params.
>>>>>>
>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>> in recursive because H does not copy its input thus runs
>>>>>> out of params.
>>>>>>
>>>>>
>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey
>>>>> could do better. Write the Olcott machine (not x86utm) code for Ĥ
>>>>> and I would show you.
>>>>
>>>> *In other words you are denying these verified facts*
>>>> *In other words you are denying these verified facts*
>>>> *In other words you are denying these verified facts*
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> That's not a verified fact, that's just something you want to be true.
>>>
>>> ∞ means infinite loop. Infinite loop doesn't halt. You see how stupid
>>> it is, to say that an infinite loop halts?
>>>
>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>
>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS PRECISELY
>>> IDENTICAL TO STEPS B AND C:
>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>
>>
>> *Yes and the key step of copying its input is left out so*
>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out of params*
>>
>
> that isn't how any of this works. Do you even know what words mean?

(b) and (c) are not the same as (1) and (2)
Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
(1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(2) which begins at simulated ⟨Ĥ.q0⟩
(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
(b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process

This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more execution
trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see.

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

On 3/9/24 8:30 PM, olcott wrote:
> On 3/9/2024 7:40 PM, immibis wrote:
>> On 10/03/24 02:37, olcott wrote:
>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>> On 10/03/24 02:29, olcott wrote:
>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Simulating halt deciders must make sure that they themselves
>>>>>>>>>>>>> do not get stuck in infinite execution. This means that they
>>>>>>>>>>>>> must abort every simulation that cannot possibly otherwise
>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>> aborts
>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H
>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use
>>>>>>>>>> the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>
>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Objective criteria cannot vary based on who the subject is. They
>>>>>>>> are objective. The answer to different people is the same answer
>>>>>>>> if the criteria are objective.
>>>>>>>
>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>> out of params.
>>>>>>>
>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>> out of params.
>>>>>>>
>>>>>>
>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey
>>>>>> could do better. Write the Olcott machine (not x86utm) code for Ĥ
>>>>>> and I would show you.
>>>>>
>>>>> *In other words you are denying these verified facts*
>>>>> *In other words you are denying these verified facts*
>>>>> *In other words you are denying these verified facts*
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> That's not a verified fact, that's just something you want to be true.
>>>>
>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see how
>>>> stupid it is, to say that an infinite loop halts?
>>>>
>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>
>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS PRECISELY
>>>> IDENTICAL TO STEPS B AND C:
>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to
>>>> ⟨Ĥ⟩
>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>
>>>
>>> *Yes and the key step of copying its input is left out so*
>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out of params*
>>>
>>
>> that isn't how any of this works. Do you even know what words mean?
>
> (b) and (c) are not the same as (1) and (2)
> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
> (2) which begins at simulated ⟨Ĥ.q0⟩
> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>
> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more execution
> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see.
>

Nope, your just being stuupid, perhaps intentionally.
(c) just moves around to its simulation of a

(a) H^.q0 (H^)
H^ then makes a copy of its input

(b) H^.H (H^) (H^) == (1) H (H^) (H^)
The algorithm of H begins a simulation of its input, watching the
behaior of H^ (H^)

(c) = (2)
Which begins at the simulation of H^.q0 (H^)

(d = sim a) = (sim a)
Ths Simulated H^.q0 (H^) makes a copy of its input

(e = sim b) = (sim b)
The Simulated H^.H (H^) (H^) has is H begin the simulation of its input ...

and so on.

Both machine see EXACTLY the same level of details.

Yes, the top level H is farther along at any given time then its
simulated machine, and that is H's problem, it has to act before it sees
how its simulation will respond to its copy of its actions.

Thus, if it stops, it needs to make its decision "blind" and not with an
idea of how the machine it is simulating will perform.

If it doesn't stop, the level of recursion just keeps growing and no
answer ever comes out.

On 3/9/2024 10:55 PM, Richard Damon wrote:
> On 3/9/24 8:30 PM, olcott wrote:
>> On 3/9/2024 7:40 PM, immibis wrote:
>>> On 10/03/24 02:37, olcott wrote:
>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Simulating halt deciders must make sure that they themselves
>>>>>>>>>>>>>> do not get stuck in infinite execution. This means that they
>>>>>>>>>>>>>> must abort every simulation that cannot possibly otherwise
>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does
>>>>>>>>>>>>>> not
>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>> aborts
>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use
>>>>>>>>>>> the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>
>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Objective criteria cannot vary based on who the subject is.
>>>>>>>>> They are objective. The answer to different people is the same
>>>>>>>>> answer if the criteria are objective.
>>>>>>>>
>>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>> out of params.
>>>>>>>>
>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>> out of params.
>>>>>>>>
>>>>>>>
>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey
>>>>>>> could do better. Write the Olcott machine (not x86utm) code for Ĥ
>>>>>>> and I would show you.
>>>>>>
>>>>>> *In other words you are denying these verified facts*
>>>>>> *In other words you are denying these verified facts*
>>>>>> *In other words you are denying these verified facts*
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>
>>>>> That's not a verified fact, that's just something you want to be true.
>>>>>
>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see how
>>>>> stupid it is, to say that an infinite loop halts?
>>>>>
>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>
>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS PRECISELY
>>>>> IDENTICAL TO STEPS B AND C:
>>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>> to ⟨Ĥ⟩
>>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>
>>>>
>>>> *Yes and the key step of copying its input is left out so*
>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out of params*
>>>>
>>>
>>> that isn't how any of this works. Do you even know what words mean?
>>
>> (b) and (c) are not the same as (1) and (2)
>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>> (2) which begins at simulated ⟨Ĥ.q0⟩
>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>
>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more execution
>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see.
>>
>
> Nope, your just being stuupid, perhaps intentionally.
> (c) just moves around to its simulation of a
>
>
> (a) H^.q0 (H^)
> H^ then makes a copy of its input
>
> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
> The algorithm of H begins a simulation of its input, watching the
> behaior of H^ (H^)
>
> (c) = (2)
> Which begins at the simulation of H^.q0 (H^)
>
> (d = sim a) = (sim a)
> Ths Simulated H^.q0 (H^) makes a copy of its input
>
> (e = sim b) = (sim b)
> The Simulated H^.H (H^) (H^) has is H begin the simulation of its input ...
>
> and so on.
>
> Both machine see EXACTLY the same level of details.
>
> Yes, the top level H is farther along at any given time then its
> simulated machine, and that is H's problem, it has to act before it sees
> how its simulation will respond to its copy of its actions.
>
> Thus, if it stops, it needs to make its decision "blind" and not with an
> idea of how the machine it is simulating will perform.
>
> If it doesn't stop, the level of recursion just keeps growing and no
> answer ever comes out.

On 3/9/24 9:14 PM, olcott wrote:
> On 3/9/2024 10:55 PM, Richard Damon wrote:
>> On 3/9/24 8:30 PM, olcott wrote:
>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>> On 10/03/24 02:37, olcott wrote:
>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Simulating halt deciders must make sure that they themselves
>>>>>>>>>>>>>>> do not get stuck in infinite execution. This means that they
>>>>>>>>>>>>>>> must abort every simulation that cannot possibly
>>>>>>>>>>>>>>> otherwise halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and
>>>>>>>>>>>>>>> does not
>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>> ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation
>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to
>>>>>>>>>>>> use the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>
>>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Objective criteria cannot vary based on who the subject is.
>>>>>>>>>> They are objective. The answer to different people is the same
>>>>>>>>>> answer if the criteria are objective.
>>>>>>>>>
>>>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>> out of params.
>>>>>>>>>
>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>>> out of params.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey
>>>>>>>> could do better. Write the Olcott machine (not x86utm) code for
>>>>>>>> Ĥ and I would show you.
>>>>>>>
>>>>>>> *In other words you are denying these verified facts*
>>>>>>> *In other words you are denying these verified facts*
>>>>>>> *In other words you are denying these verified facts*
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>
>>>>>> That's not a verified fact, that's just something you want to be
>>>>>> true.
>>>>>>
>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see how
>>>>>> stupid it is, to say that an infinite loop halts?
>>>>>>
>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to
>>>>>>> ⟨Ĥ⟩
>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>
>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS PRECISELY
>>>>>> IDENTICAL TO STEPS B AND C:
>>>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>> to ⟨Ĥ⟩
>>>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>
>>>>>
>>>>> *Yes and the key step of copying its input is left out so*
>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out of
>>>>> params*
>>>>>
>>>>
>>>> that isn't how any of this works. Do you even know what words mean?
>>>
>>> (b) and (c) are not the same as (1) and (2)
>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>
>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more execution
>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see.
>>>
>>
>> Nope, your just being stuupid, perhaps intentionally.
>> (c) just moves around to its simulation of a
>>
>>
>> (a) H^.q0 (H^)
>> H^ then makes a copy of its input
>>
>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>> The algorithm of H begins a simulation of its input, watching the
>> behaior of H^ (H^)
>>
>> (c) = (2)
>> Which begins at the simulation of H^.q0 (H^)
>>
>> (d = sim a) = (sim a)
>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>
>> (e = sim b) = (sim b)
>> The Simulated H^.H (H^) (H^) has is H begin the simulation of its
>> input ...
>>
>> and so on.
>>
>> Both machine see EXACTLY the same level of details.
>>
>> Yes, the top level H is farther along at any given time then its
>> simulated machine, and that is H's problem, it has to act before it
>> sees how its simulation will respond to its copy of its actions.
>>
>> Thus, if it stops, it needs to make its decision "blind" and not with
>> an idea of how the machine it is simulating will perform.
>>
>> If it doesn't stop, the level of recursion just keeps growing and no
>> answer ever comes out.
>
> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
> its simulation. Right before its cycle repeats the first time.
>