*This is the correct definition of a decider*
Deciders always must compute the mapping from an input finite string to
their own accept or reject state on the basis of a syntactic or semantic
property of this finite string.

*Definition of the HP based on the above definition of a decider*
In computability theory, the halting problem is the problem of
determining, whether an input finite string pair of program/input
specifies a computation that would reach a final state and terminate
normally.

*Definition of halt decider based on the above definitions*
(a) If simulating termination analyzer H correctly determines that D
correctly simulated by H cannot possibly reach its own simulated final
state and terminate normally then

(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

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

On 1/19/24 8:54 AM, olcott wrote:
> *This is the correct definition of a decider*
> Deciders always must compute the mapping from an input finite string to
> their own accept or reject state on the basis of a syntactic or semantic
> property of this finite string.
>
> *Definition of the HP based on the above definition of a decider*
> In computability theory, the halting problem is the problem of
> determining, whether an input finite string pair of program/input
> specifies a computation that would reach a final state and terminate
> normally.
>
> *Definition of halt decider based on the above definitions*
> (a) If simulating termination analyzer H correctly determines that D
> correctly simulated by H cannot possibly reach its own simulated final
> state and terminate normally then
>

Nope.

Where did you get the transition from

a input finite string pair of program/input specifies a computation that
would reach a final state and terminate normally

to

H correctly determines that D correctly simulated *by H* cannot possiby
reach its own simulated final state.

Note, the definition of a UTM say you can replace the actual running of
the machine representation with that of a UTM simulation (because it
will behave the same) but that operation also says such a simulation can
not abort, as the machine given as an input didn't stop running there.

THus adding the "by H" to your definition, you are REQUIRING that H can
not abort its simulation, and thus your statement (b) is meaningless, as
something that can not abort can not have conditions when it can abort.

You could say, if H correctly determines that (perhaps by its own
partial correct simulation) that an ACTUAL correct simulation of the
input by an actual UTM would not halt, you would be correct.

You H doesn't meet this requrement.

> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>

But only if H ACTUALLY DOES a correct simulation (which means never
aborts), and that simulation must be of the ACTUAL D, which in this case
used the H that aborts and returns the non-halting answer (not the OTHER
machine lyingly also called H which does a correct simulation).

So, you requirment boils down to a correct halting decider must not
abort its simulation, but also must abort its simulation.

Your H is just another name for the Barber that shaves everyone that
doesn't shave themselves, or the set of all sets that don't contain
themselves.

It just can not exist.

Your "proof" is based on the error or replacing the PROGRAM D, for a
tenplate that changes when the decider changes. Such a template is not a
program, so is a category error to give to a Halt Decider.

Yes, YOUR definition of D (which isn't of a program) make the Halting
Question about it invalid, because it isn't actually a program, which is
what the domain of the Halting Question is.

On 1/19/24 14:54, olcott wrote:
> *This is the correct definition of a decider*
> Deciders always must compute the mapping from an input finite string to
> their own accept or reject state on the basis of a syntactic or semantic
> property of this finite string.

yes

>
> *Definition of the HP based on the above definition of a decider*
> In computability theory, the halting problem is the problem of
> determining, whether an input finite string pair of program/input
> specifies a computation that would reach a final state and terminate
> normally.

yes

>
> *Definition of halt decider based on the above definitions*
> (a) If simulating termination analyzer H correctly determines that D
> correctly simulated by H cannot possibly reach its own simulated final
> state and terminate normally then

no, this is your interpretation

On 1/19/2024 9:56 AM, immibis wrote:
> On 1/19/24 14:54, olcott wrote:
>> *This is the correct definition of a decider*
>> Deciders always must compute the mapping from an input finite string to
>> their own accept or reject state on the basis of a syntactic or semantic
>> property of this finite string.
>
> yes
>
>>
>> *Definition of the HP based on the above definition of a decider*
>> In computability theory, the halting problem is the problem of
>> determining, whether an input finite string pair of program/input
>> specifies a computation that would reach a final state and terminate
>> normally.
>
> yes
>
>>
>> *Definition of halt decider based on the above definitions*
>> (a) If simulating termination analyzer H correctly determines that D
>> correctly simulated by H cannot possibly reach its own simulated final
>> state and terminate normally then
>
> no, this is your interpretation
>

Well it is very great that you agreed to the first two.
That you can't understand that DD does specify recursive
simulation to HH means that you cannot understand me.

On 10/13/2022 11:46 AM, olcott wrote:
> MIT Professor Michael Sipser has agreed that the following
> verbatim paragraph is correct (he has not agreed to anything
> else in this paper):
>
> If simulating halt decider H correctly simulates its input D
> until H correctly determines that its simulated D would never
> stop running unless aborted then H can abort its simulation
> of D and correctly report that D specifies a non-halting
> sequence of configurations.
>
> When one accepts this definition of a simulating halt decider
> then my code shows that H correctly determines the halt status
> of D.

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

On 1/19/2024 9:34 AM, Richard Damon wrote:
> On 1/19/24 8:54 AM, olcott wrote:
>> *This is the correct definition of a decider*
>> Deciders always must compute the mapping from an input finite string to
>> their own accept or reject state on the basis of a syntactic or semantic
>> property of this finite string.
>>
>> *Definition of the HP based on the above definition of a decider*
>> In computability theory, the halting problem is the problem of
>> determining, whether an input finite string pair of program/input
>> specifies a computation that would reach a final state and terminate
>> normally.
>>
>> *Definition of halt decider based on the above definitions*
>> (a) If simulating termination analyzer H correctly determines that D
>> correctly simulated by H cannot possibly reach its own simulated final
>> state and terminate normally then
>>
>
> Nope.
>
> Where did you get the transition from
>
> a input finite string pair of program/input specifies a computation that
> would reach a final state and terminate normally
>
> to
>
> H correctly determines that D correctly simulated *by H* cannot possiby
> reach its own simulated final state.
>

The computation that D specifies to H <is> recursive
simulation. H is not allowed to simply ignore that D
is calling itself.

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

On 1/19/24 11:14 AM, olcott wrote:
> On 1/19/2024 9:34 AM, Richard Damon wrote:
>> On 1/19/24 8:54 AM, olcott wrote:
>>> *This is the correct definition of a decider*
>>> Deciders always must compute the mapping from an input finite string to
>>> their own accept or reject state on the basis of a syntactic or semantic
>>> property of this finite string.
>>>
>>> *Definition of the HP based on the above definition of a decider*
>>> In computability theory, the halting problem is the problem of
>>> determining, whether an input finite string pair of program/input
>>> specifies a computation that would reach a final state and terminate
>>> normally.
>>>
>>> *Definition of halt decider based on the above definitions*
>>> (a) If simulating termination analyzer H correctly determines that D
>>> correctly simulated by H cannot possibly reach its own simulated final
>>> state and terminate normally then
>>>
>>
>> Nope.
>>
>> Where did you get the transition from
>>
>> a input finite string pair of program/input specifies a computation
>> that would reach a final state and terminate normally
>>
>> to
>>
>> H correctly determines that D correctly simulated *by H* cannot
>> possiby reach its own simulated final state.
>>
>
> The computation that D specifies to H <is> recursive
> simulation. H is not allowed to simply ignore that D
> is calling itself.
>
>
>
>

No, D, if it is an actual program, has its OWN "copy" of H that it uses,
so it is not recursive with the H that is deciding it.

If H can notice that D is using a copy of it then it can use that
knowledge, but it also must take into account that that H will behave
exactly like THIS H, so if this H aborts and return 0, it must take into
account that THAT H will also abort and return 0.

The H isn't some "abstract definition", but an actual copy of the actual
code that will do exactly like this one does.

Yes, this means that H is put into the impossible position of having to
compute the answer to the Liar's Paradox. This doesn't mean the question
is invalid, as for every putative definiton of H, there is an answer, it
just means that no H can exist that gets the answer right.

On 1/19/2024 10:44 AM, Richard Damon wrote:
> On 1/19/24 11:14 AM, olcott wrote:
>> On 1/19/2024 9:34 AM, Richard Damon wrote:
>>> On 1/19/24 8:54 AM, olcott wrote:
>>>> *This is the correct definition of a decider*
>>>> Deciders always must compute the mapping from an input finite string to
>>>> their own accept or reject state on the basis of a syntactic or
>>>> semantic
>>>> property of this finite string.
>>>>
>>>> *Definition of the HP based on the above definition of a decider*
>>>> In computability theory, the halting problem is the problem of
>>>> determining, whether an input finite string pair of program/input
>>>> specifies a computation that would reach a final state and terminate
>>>> normally.
>>>>
>>>> *Definition of halt decider based on the above definitions*
>>>> (a) If simulating termination analyzer H correctly determines that D
>>>> correctly simulated by H cannot possibly reach its own simulated final
>>>> state and terminate normally then
>>>>
>>>
>>> Nope.
>>>
>>> Where did you get the transition from
>>>
>>> a input finite string pair of program/input specifies a computation
>>> that would reach a final state and terminate normally
>>>
>>> to
>>>
>>> H correctly determines that D correctly simulated *by H* cannot
>>> possiby reach its own simulated final state.
>>>
>>
>> The computation that D specifies to H <is> recursive
>> simulation. H is not allowed to simply ignore that D
>> is calling itself.
>>
>>
>>
>>
>
> No, D, if it is an actual program, has its OWN "copy" of H that it uses,

I have proven that does not make any difference.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

Simulating Partial Halt Decider Applied to Linz Proof
Non-halting behavior patterns can be matched in N steps. The simulated
⟨Ĥ⟩ halts only it when reaches its simulated final state of ⟨Ĥ.qn⟩ in a
finite number of steps.

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

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

On 1/19/24 11:55 AM, olcott wrote:
> On 1/19/2024 10:44 AM, Richard Damon wrote:
>> On 1/19/24 11:14 AM, olcott wrote:
>>> On 1/19/2024 9:34 AM, Richard Damon wrote:
>>>> On 1/19/24 8:54 AM, olcott wrote:
>>>>> *This is the correct definition of a decider*
>>>>> Deciders always must compute the mapping from an input finite
>>>>> string to
>>>>> their own accept or reject state on the basis of a syntactic or
>>>>> semantic
>>>>> property of this finite string.
>>>>>
>>>>> *Definition of the HP based on the above definition of a decider*
>>>>> In computability theory, the halting problem is the problem of
>>>>> determining, whether an input finite string pair of program/input
>>>>> specifies a computation that would reach a final state and terminate
>>>>> normally.
>>>>>
>>>>> *Definition of halt decider based on the above definitions*
>>>>> (a) If simulating termination analyzer H correctly determines that D
>>>>> correctly simulated by H cannot possibly reach its own simulated final
>>>>> state and terminate normally then
>>>>>
>>>>
>>>> Nope.
>>>>
>>>> Where did you get the transition from
>>>>
>>>> a input finite string pair of program/input specifies a computation
>>>> that would reach a final state and terminate normally
>>>>
>>>> to
>>>>
>>>> H correctly determines that D correctly simulated *by H* cannot
>>>> possiby reach its own simulated final state.
>>>>
>>>
>>> The computation that D specifies to H <is> recursive
>>> simulation. H is not allowed to simply ignore that D
>>> is calling itself.
>>>
>>>
>>>
>>>
>>
>> No, D, if it is an actual program, has its OWN "copy" of H that it uses,
>
> I have proven that does not make any difference.
>
> When Ĥ is applied to ⟨Ĥ⟩
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> Simulating Partial Halt Decider Applied to Linz Proof
> Non-halting behavior patterns can be matched in N steps. The simulated
> ⟨Ĥ⟩ halts only it when reaches its simulated final state of ⟨Ĥ.qn⟩ in a
> finite number of steps.
>
> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
> (b) embedded_H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to
> ⟨Ĥ⟩
> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>

Except that pattern isn't non-halting, since if H (and thus embedded_H)
abort its simulation, that loop is NOT non-halting, but will reac a
point where the outer embedded_H also decides to abort and return Qn to
the Ĥ it was part of, which then halts.

Only by embedded_H not being the required exact copy of H do you get
your logic.

So, your statement is just false, and the fact that this has been
pointed out to you many times, shows you are a pathological liar and an
idiot.

On 1/19/2024 11:05 AM, Richard Damon wrote:
> On 1/19/24 11:55 AM, olcott wrote:
>> On 1/19/2024 10:44 AM, Richard Damon wrote:
>>> On 1/19/24 11:14 AM, olcott wrote:
>>>> On 1/19/2024 9:34 AM, Richard Damon wrote:
>>>>> On 1/19/24 8:54 AM, olcott wrote:
>>>>>> *This is the correct definition of a decider*
>>>>>> Deciders always must compute the mapping from an input finite
>>>>>> string to
>>>>>> their own accept or reject state on the basis of a syntactic or
>>>>>> semantic
>>>>>> property of this finite string.
>>>>>>
>>>>>> *Definition of the HP based on the above definition of a decider*
>>>>>> In computability theory, the halting problem is the problem of
>>>>>> determining, whether an input finite string pair of program/input
>>>>>> specifies a computation that would reach a final state and terminate
>>>>>> normally.
>>>>>>
>>>>>> *Definition of halt decider based on the above definitions*
>>>>>> (a) If simulating termination analyzer H correctly determines that D
>>>>>> correctly simulated by H cannot possibly reach its own simulated
>>>>>> final
>>>>>> state and terminate normally then
>>>>>>
>>>>>
>>>>> Nope.
>>>>>
>>>>> Where did you get the transition from
>>>>>
>>>>> a input finite string pair of program/input specifies a computation
>>>>> that would reach a final state and terminate normally
>>>>>
>>>>> to
>>>>>
>>>>> H correctly determines that D correctly simulated *by H* cannot
>>>>> possiby reach its own simulated final state.
>>>>>
>>>>
>>>> The computation that D specifies to H <is> recursive
>>>> simulation. H is not allowed to simply ignore that D
>>>> is calling itself.
>>>>
>>>>
>>>>
>>>>
>>>
>>> No, D, if it is an actual program, has its OWN "copy" of H that it uses,
>>
>> I have proven that does not make any difference.
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> Simulating Partial Halt Decider Applied to Linz Proof
>> Non-halting behavior patterns can be matched in N steps. The simulated
>> ⟨Ĥ⟩ halts only it when reaches its simulated final state of ⟨Ĥ.qn⟩ in
>> a finite number of steps.
>>
>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>> (b) embedded_H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>> to ⟨Ĥ⟩
>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>
>
> Except that pattern isn't non-halting, since if H (and thus embedded_H)
> abort its simulation, that loop is NOT non-halting,

An aborted simulation does not count as the simulated input reaching
its simulated final state of ⟨Ĥ.qn⟩ and terminated normally.

Since it is impossible for the simulated input ⟨Ĥ⟩ to reach its
simulated final state of ⟨Ĥ.qn⟩ and terminate normally then
professor Sipser and I agree that IT DOES NOT HALT.

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

On 1/19/24 12:17 PM, olcott wrote:
> On 1/19/2024 11:05 AM, Richard Damon wrote:
>> On 1/19/24 11:55 AM, olcott wrote:
>>> On 1/19/2024 10:44 AM, Richard Damon wrote:
>>>> On 1/19/24 11:14 AM, olcott wrote:
>>>>> On 1/19/2024 9:34 AM, Richard Damon wrote:
>>>>>> On 1/19/24 8:54 AM, olcott wrote:
>>>>>>> *This is the correct definition of a decider*
>>>>>>> Deciders always must compute the mapping from an input finite
>>>>>>> string to
>>>>>>> their own accept or reject state on the basis of a syntactic or
>>>>>>> semantic
>>>>>>> property of this finite string.
>>>>>>>
>>>>>>> *Definition of the HP based on the above definition of a decider*
>>>>>>> In computability theory, the halting problem is the problem of
>>>>>>> determining, whether an input finite string pair of program/input
>>>>>>> specifies a computation that would reach a final state and terminate
>>>>>>> normally.
>>>>>>>
>>>>>>> *Definition of halt decider based on the above definitions*
>>>>>>> (a) If simulating termination analyzer H correctly determines that D
>>>>>>> correctly simulated by H cannot possibly reach its own simulated
>>>>>>> final
>>>>>>> state and terminate normally then
>>>>>>>
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>> Where did you get the transition from
>>>>>>
>>>>>> a input finite string pair of program/input specifies a
>>>>>> computation that would reach a final state and terminate normally
>>>>>>
>>>>>> to
>>>>>>
>>>>>> H correctly determines that D correctly simulated *by H* cannot
>>>>>> possiby reach its own simulated final state.
>>>>>>
>>>>>
>>>>> The computation that D specifies to H <is> recursive
>>>>> simulation. H is not allowed to simply ignore that D
>>>>> is calling itself.
>>>>>
>>>>>
>>>>>
>>>>>
>>>>
>>>> No, D, if it is an actual program, has its OWN "copy" of H that it
>>>> uses,
>>>
>>> I have proven that does not make any difference.
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> Simulating Partial Halt Decider Applied to Linz Proof
>>> Non-halting behavior patterns can be matched in N steps. The
>>> simulated ⟨Ĥ⟩ halts only it when reaches its simulated final state of
>>> ⟨Ĥ.qn⟩ in a finite number of steps.
>>>
>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>> (b) embedded_H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>> to ⟨Ĥ⟩
>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>
>>
>> Except that pattern isn't non-halting, since if H (and thus
>> embedded_H) abort its simulation, that loop is NOT non-halting,
>
> An aborted simulation does not count as the simulated input reaching
> its simulated final state of ⟨Ĥ.qn⟩ and terminated normally.

Right, but doesn't show that the correct simulaiton of that input would
not halt.

Ĥ uses its copy of H to answer (by its simulation) the question about
its input (Ĥ) (Ĥ), and that H aborts its simulation and returns to Ĥ
which halts, as would a CORRECT simulaton of the input to any H give (Ĥ)
(Ĥ).

You are confusing the fact that H does a simulation, with the behavior
of the actual input, and the fact that a correct simulation of this
input simulates a simulator that aborts (and thus doesn't do a correct
simulation) and returns to its caller.

>
> Since it is impossible for the simulated input ⟨Ĥ⟩ to reach its
> simulated final state of ⟨Ĥ.qn⟩ and terminate normally then
> professor Sipser and I agree that IT DOES NOT HALT.
>

Nope.

Read what professor Sipser agreed to, *IF* H can CORRECTLY DETERMINE
that a CORRECT SIMULAITON (by H or anyone else, all correct simulation
are the same) of this input would not halt.

For the clause correct simulation by H to be true, H (and that mean THIS
H) must do a correct simulation in the first place, and since it
doesn't, it can't use that clause.

You confuse two different H's that you have intentionaly and deceptively
given the same name, a practice not allowed in proper logic.

All you have done is defined an impossible condition to use for you decider.

IT is the same as asking does the Barber who shaves everyone who does
shave themesevles shave himself?

On 1/19/24 17:14, olcott wrote:
> On 1/19/2024 9:34 AM, Richard Damon wrote:
>> On 1/19/24 8:54 AM, olcott wrote:
>>> *This is the correct definition of a decider*
>>> Deciders always must compute the mapping from an input finite string to
>>> their own accept or reject state on the basis of a syntactic or semantic
>>> property of this finite string.
>>>
>>> *Definition of the HP based on the above definition of a decider*
>>> In computability theory, the halting problem is the problem of
>>> determining, whether an input finite string pair of program/input
>>> specifies a computation that would reach a final state and terminate
>>> normally.
>>>
>>> *Definition of halt decider based on the above definitions*
>>> (a) If simulating termination analyzer H correctly determines that D
>>> correctly simulated by H cannot possibly reach its own simulated final
>>> state and terminate normally then
>>>
>>
>> Nope.
>>
>> Where did you get the transition from
>>
>> a input finite string pair of program/input specifies a computation
>> that would reach a final state and terminate normally
>>
>> to
>>
>> H correctly determines that D correctly simulated *by H* cannot
>> possiby reach its own simulated final state.
>>
>
> The computation that D specifies to H <is> recursive
> simulation. H is not allowed to simply ignore that D
> is calling itself.
>

H is not allowed to simply ignore that D would detect infinite
recursion, stop simulating and reach a final state.

On 1/19/24 1:16 PM, immibis wrote:
> On 1/19/24 17:14, olcott wrote:
>> On 1/19/2024 9:34 AM, Richard Damon wrote:
>>> On 1/19/24 8:54 AM, olcott wrote:
>>>> *This is the correct definition of a decider*
>>>> Deciders always must compute the mapping from an input finite string to
>>>> their own accept or reject state on the basis of a syntactic or
>>>> semantic
>>>> property of this finite string.
>>>>
>>>> *Definition of the HP based on the above definition of a decider*
>>>> In computability theory, the halting problem is the problem of
>>>> determining, whether an input finite string pair of program/input
>>>> specifies a computation that would reach a final state and terminate
>>>> normally.
>>>>
>>>> *Definition of halt decider based on the above definitions*
>>>> (a) If simulating termination analyzer H correctly determines that D
>>>> correctly simulated by H cannot possibly reach its own simulated final
>>>> state and terminate normally then
>>>>
>>>
>>> Nope.
>>>
>>> Where did you get the transition from
>>>
>>> a input finite string pair of program/input specifies a computation
>>> that would reach a final state and terminate normally
>>>
>>> to
>>>
>>> H correctly determines that D correctly simulated *by H* cannot
>>> possiby reach its own simulated final state.
>>>
>>
>> The computation that D specifies to H <is> recursive
>> simulation. H is not allowed to simply ignore that D
>> is calling itself.
>>
>
> H is not allowed to simply ignore that D would detect infinite
> recursion, stop simulating and reach a final state.
>

Except that D doesn't create infinite recursion BECAUSE H (the H used by
D) aborts its simulation and stops it.

Thus the H deciding, can't validly assume the H in D does what you claim
it assumes.

You have to look at the ACTUAL program D (and not the false template you
have created) and the actual H that it uses, which is exactly always the
H that you claim to give the right answer.

Therefore, when the deciding H postulates that it is something differnt
that actually does a correct simulation, that doesn't change the H that
D calls, it still cause the original H that will abort.

Thus H is INCORRECT in presuming that if it was something different that
didn't abort its simulation would go on forever.

Only in your INCORRECT model, where D changes to call whatever H is
trying to decide it, as opposed to the SPECIFIC H which is claimed to
get the right answer, is your logic valid.

Since it doesn't look at the ACTUAL PROGRAM D that the input is claimed
to represent, the logic isn't valid.

On 1/19/2024 11:56 AM, Richard Damon wrote:
> On 1/19/24 12:17 PM, olcott wrote:
>> On 1/19/2024 11:05 AM, Richard Damon wrote:
>>> On 1/19/24 11:55 AM, olcott wrote:
>>>> On 1/19/2024 10:44 AM, Richard Damon wrote:
>>>>> On 1/19/24 11:14 AM, olcott wrote:
>>>>>> On 1/19/2024 9:34 AM, Richard Damon wrote:
>>>>>>> On 1/19/24 8:54 AM, olcott wrote:
>>>>>>>> *This is the correct definition of a decider*
>>>>>>>> Deciders always must compute the mapping from an input finite
>>>>>>>> string to
>>>>>>>> their own accept or reject state on the basis of a syntactic or
>>>>>>>> semantic
>>>>>>>> property of this finite string.
>>>>>>>>
>>>>>>>> *Definition of the HP based on the above definition of a decider*
>>>>>>>> In computability theory, the halting problem is the problem of
>>>>>>>> determining, whether an input finite string pair of program/input
>>>>>>>> specifies a computation that would reach a final state and
>>>>>>>> terminate
>>>>>>>> normally.
>>>>>>>>
>>>>>>>> *Definition of halt decider based on the above definitions*
>>>>>>>> (a) If simulating termination analyzer H correctly determines
>>>>>>>> that D
>>>>>>>> correctly simulated by H cannot possibly reach its own simulated
>>>>>>>> final
>>>>>>>> state and terminate normally then
>>>>>>>>
>>>>>>>
>>>>>>> Nope.
>>>>>>>
>>>>>>> Where did you get the transition from
>>>>>>>
>>>>>>> a input finite string pair of program/input specifies a
>>>>>>> computation that would reach a final state and terminate normally
>>>>>>>
>>>>>>> to
>>>>>>>
>>>>>>> H correctly determines that D correctly simulated *by H* cannot
>>>>>>> possiby reach its own simulated final state.
>>>>>>>
>>>>>>
>>>>>> The computation that D specifies to H <is> recursive
>>>>>> simulation. H is not allowed to simply ignore that D
>>>>>> is calling itself.
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> No, D, if it is an actual program, has its OWN "copy" of H that it
>>>>> uses,
>>>>
>>>> I have proven that does not make any difference.
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> Simulating Partial Halt Decider Applied to Linz Proof
>>>> Non-halting behavior patterns can be matched in N steps. The
>>>> simulated ⟨Ĥ⟩ halts only it when reaches its simulated final state
>>>> of ⟨Ĥ.qn⟩ in a finite number of steps.
>>>>
>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>> (b) embedded_H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>> applied to ⟨Ĥ⟩
>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>
>>>
>>> Except that pattern isn't non-halting, since if H (and thus
>>> embedded_H) abort its simulation, that loop is NOT non-halting,
>>
>> An aborted simulation does not count as the simulated input reaching
>> its simulated final state of ⟨Ĥ.qn⟩ and terminated normally.
>
> Right, but doesn't show that the correct simulaiton of that input would
> not halt.
>
> Ĥ uses its copy of H to answer (by its simulation) the question about
> its input (Ĥ) (Ĥ), and that H aborts its simulation and returns to Ĥ
> which halts, as would a CORRECT simulaton of the input to any H give (Ĥ)
> (Ĥ).

Do you understand that none of the simulated ⟨Ĥ⟩ can possibly reach
their simulated final state of ⟨Ĥ.qn⟩ ???

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

On 1/19/2024 12:16 PM, immibis wrote:
> On 1/19/24 17:14, olcott wrote:
>> On 1/19/2024 9:34 AM, Richard Damon wrote:
>>> On 1/19/24 8:54 AM, olcott wrote:
>>>> *This is the correct definition of a decider*
>>>> Deciders always must compute the mapping from an input finite string to
>>>> their own accept or reject state on the basis of a syntactic or
>>>> semantic
>>>> property of this finite string.
>>>>
>>>> *Definition of the HP based on the above definition of a decider*
>>>> In computability theory, the halting problem is the problem of
>>>> determining, whether an input finite string pair of program/input
>>>> specifies a computation that would reach a final state and terminate
>>>> normally.
>>>>
>>>> *Definition of halt decider based on the above definitions*
>>>> (a) If simulating termination analyzer H correctly determines that D
>>>> correctly simulated by H cannot possibly reach its own simulated final
>>>> state and terminate normally then
>>>>
>>>
>>> Nope.
>>>
>>> Where did you get the transition from
>>>
>>> a input finite string pair of program/input specifies a computation
>>> that would reach a final state and terminate normally
>>>
>>> to
>>>
>>> H correctly determines that D correctly simulated *by H* cannot
>>> possiby reach its own simulated final state.
>>>
>>
>> The computation that D specifies to H <is> recursive
>> simulation. H is not allowed to simply ignore that D
>> is calling itself.
>>
>
> H is not allowed to simply ignore that D would detect infinite
> recursion, stop simulating and reach a final state.
>

*This is simply over your head*
Unless the outermost HH aborts its simulation then none of them do.

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

On 1/19/2024 12:27 PM, Richard Damon wrote:
> On 1/19/24 1:16 PM, immibis wrote:
>> On 1/19/24 17:14, olcott wrote:
>>> On 1/19/2024 9:34 AM, Richard Damon wrote:
>>>> On 1/19/24 8:54 AM, olcott wrote:
>>>>> *This is the correct definition of a decider*
>>>>> Deciders always must compute the mapping from an input finite
>>>>> string to
>>>>> their own accept or reject state on the basis of a syntactic or
>>>>> semantic
>>>>> property of this finite string.
>>>>>
>>>>> *Definition of the HP based on the above definition of a decider*
>>>>> In computability theory, the halting problem is the problem of
>>>>> determining, whether an input finite string pair of program/input
>>>>> specifies a computation that would reach a final state and terminate
>>>>> normally.
>>>>>
>>>>> *Definition of halt decider based on the above definitions*
>>>>> (a) If simulating termination analyzer H correctly determines that D
>>>>> correctly simulated by H cannot possibly reach its own simulated final
>>>>> state and terminate normally then
>>>>>
>>>>
>>>> Nope.
>>>>
>>>> Where did you get the transition from
>>>>
>>>> a input finite string pair of program/input specifies a computation
>>>> that would reach a final state and terminate normally
>>>>
>>>> to
>>>>
>>>> H correctly determines that D correctly simulated *by H* cannot
>>>> possiby reach its own simulated final state.
>>>>
>>>
>>> The computation that D specifies to H <is> recursive
>>> simulation. H is not allowed to simply ignore that D
>>> is calling itself.
>>>
>>
>> H is not allowed to simply ignore that D would detect infinite
>> recursion, stop simulating and reach a final state.
>>
>
> Except that D doesn't create infinite recursion BECAUSE H (the H used by
> D) aborts its simulation and stops it.
>

HH correctly simulates DD until it correctly determines
that HH correctly simulated by HH cannot possibly reach
its own simulated final state and halt, then HH returns
to its caller.

When DD(DD) is its caller then this entirely different
execution sequence benefits from the fact that HH
has aborted the simulation of the different execution
sequence specified by DD.

HH cannot possibly benefit from itself already having
aborted the simulation of DD before any HH has done this.

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

On 1/19/24 19:56, olcott wrote:
> On 1/19/2024 12:16 PM, immibis wrote:
>> On 1/19/24 17:14, olcott wrote:
>>> On 1/19/2024 9:34 AM, Richard Damon wrote:
>>>> On 1/19/24 8:54 AM, olcott wrote:
>>>>> *This is the correct definition of a decider*
>>>>> Deciders always must compute the mapping from an input finite
>>>>> string to
>>>>> their own accept or reject state on the basis of a syntactic or
>>>>> semantic
>>>>> property of this finite string.
>>>>>
>>>>> *Definition of the HP based on the above definition of a decider*
>>>>> In computability theory, the halting problem is the problem of
>>>>> determining, whether an input finite string pair of program/input
>>>>> specifies a computation that would reach a final state and terminate
>>>>> normally.
>>>>>
>>>>> *Definition of halt decider based on the above definitions*
>>>>> (a) If simulating termination analyzer H correctly determines that D
>>>>> correctly simulated by H cannot possibly reach its own simulated final
>>>>> state and terminate normally then
>>>>>
>>>>
>>>> Nope.
>>>>
>>>> Where did you get the transition from
>>>>
>>>> a input finite string pair of program/input specifies a computation
>>>> that would reach a final state and terminate normally
>>>>
>>>> to
>>>>
>>>> H correctly determines that D correctly simulated *by H* cannot
>>>> possiby reach its own simulated final state.
>>>>
>>>
>>> The computation that D specifies to H <is> recursive
>>> simulation. H is not allowed to simply ignore that D
>>> is calling itself.
>>>
>>
>> H is not allowed to simply ignore that D would detect infinite
>> recursion, stop simulating and reach a final state.
>>
>
> *This is simply over your head*
> Unless the outermost HH aborts its simulation then none of them do.
>

Why?

And what is HH? You changed H to HH - why?

On 1/19/24 17:07, olcott wrote:
> On 1/19/2024 9:56 AM, immibis wrote:
>> On 1/19/24 14:54, olcott wrote:
>>> *This is the correct definition of a decider*
>>> Deciders always must compute the mapping from an input finite string to
>>> their own accept or reject state on the basis of a syntactic or semantic
>>> property of this finite string.
>>
>> yes
>>
>>>
>>> *Definition of the HP based on the above definition of a decider*
>>> In computability theory, the halting problem is the problem of
>>> determining, whether an input finite string pair of program/input
>>> specifies a computation that would reach a final state and terminate
>>> normally.
>>
>> yes
>>
>>>
>>> *Definition of halt decider based on the above definitions*
>>> (a) If simulating termination analyzer H correctly determines that D
>>> correctly simulated by H cannot possibly reach its own simulated final
>>> state and terminate normally then
>>
>> no, this is your interpretation
>>
>
> Well it is very great that you agreed to the first two.
> That you can't understand that DD does specify recursive
> simulation to HH means that you cannot understand me.
>

That you can't understand that H contains a non-halting pattern checker
means you cannot understand yourself.

And what is HH?

On 1/19/24 18:17, olcott wrote:
>
> An aborted simulation does not count as the simulated input reaching
> its simulated final state of ⟨Ĥ.qn⟩ and terminated normally.
>

An abortING simulation does count as the simulatOR reaching its final
state and terminating normally.

On 1/19/2024 2:44 PM, immibis wrote:
> On 1/19/24 19:56, olcott wrote:
>> On 1/19/2024 12:16 PM, immibis wrote:
>>> On 1/19/24 17:14, olcott wrote:
>>>> On 1/19/2024 9:34 AM, Richard Damon wrote:
>>>>> On 1/19/24 8:54 AM, olcott wrote:
>>>>>> *This is the correct definition of a decider*
>>>>>> Deciders always must compute the mapping from an input finite
>>>>>> string to
>>>>>> their own accept or reject state on the basis of a syntactic or
>>>>>> semantic
>>>>>> property of this finite string.
>>>>>>
>>>>>> *Definition of the HP based on the above definition of a decider*
>>>>>> In computability theory, the halting problem is the problem of
>>>>>> determining, whether an input finite string pair of program/input
>>>>>> specifies a computation that would reach a final state and terminate
>>>>>> normally.
>>>>>>
>>>>>> *Definition of halt decider based on the above definitions*
>>>>>> (a) If simulating termination analyzer H correctly determines that D
>>>>>> correctly simulated by H cannot possibly reach its own simulated
>>>>>> final
>>>>>> state and terminate normally then
>>>>>>
>>>>>
>>>>> Nope.
>>>>>
>>>>> Where did you get the transition from
>>>>>
>>>>> a input finite string pair of program/input specifies a computation
>>>>> that would reach a final state and terminate normally
>>>>>
>>>>> to
>>>>>
>>>>> H correctly determines that D correctly simulated *by H* cannot
>>>>> possiby reach its own simulated final state.
>>>>>
>>>>
>>>> The computation that D specifies to H <is> recursive
>>>> simulation. H is not allowed to simply ignore that D
>>>> is calling itself.
>>>>
>>>
>>> H is not allowed to simply ignore that D would detect infinite
>>> recursion, stop simulating and reach a final state.
>>>
>>
>> *This is simply over your head*
>> Unless the outermost HH aborts its simulation then none of them do.
>>
>
> Why?
>

Each simulated HH has the exact same instructions as the
others because it <is> the same code at the same machine
address.

The outer HH aborts the simulation as soon as the abort
criteria has been met. Since it sees this abort criteria
first unless it aborts then none of them do.

> And what is HH? You changed H to HH - why?

HH is the original H and can simulate itself simulating
DD. H can not do this, it uses a different abort criteria
so that it can abort sooner.

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

On 1/19/2024 2:46 PM, immibis wrote:
> On 1/19/24 18:17, olcott wrote:
>>
>> An aborted simulation does not count as the simulated input reaching
>> its simulated final state of ⟨Ĥ.qn⟩ and terminated normally.
>>
>
> An abortING simulation does count as the simulatOR reaching its final
> state and terminating normally.
>
>

Yes it does. It does not count as the simulated input DD halting.

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

On 1/19/24 1:36 PM, olcott wrote:
> On 1/19/2024 11:56 AM, Richard Damon wrote:
>> On 1/19/24 12:17 PM, olcott wrote:
>>> On 1/19/2024 11:05 AM, Richard Damon wrote:
>>>> On 1/19/24 11:55 AM, olcott wrote:
>>>>> On 1/19/2024 10:44 AM, Richard Damon wrote:
>>>>>> On 1/19/24 11:14 AM, olcott wrote:
>>>>>>> On 1/19/2024 9:34 AM, Richard Damon wrote:
>>>>>>>> On 1/19/24 8:54 AM, olcott wrote:
>>>>>>>>> *This is the correct definition of a decider*
>>>>>>>>> Deciders always must compute the mapping from an input finite
>>>>>>>>> string to
>>>>>>>>> their own accept or reject state on the basis of a syntactic or
>>>>>>>>> semantic
>>>>>>>>> property of this finite string.
>>>>>>>>>
>>>>>>>>> *Definition of the HP based on the above definition of a decider*
>>>>>>>>> In computability theory, the halting problem is the problem of
>>>>>>>>> determining, whether an input finite string pair of program/input
>>>>>>>>> specifies a computation that would reach a final state and
>>>>>>>>> terminate
>>>>>>>>> normally.
>>>>>>>>>
>>>>>>>>> *Definition of halt decider based on the above definitions*
>>>>>>>>> (a) If simulating termination analyzer H correctly determines
>>>>>>>>> that D
>>>>>>>>> correctly simulated by H cannot possibly reach its own
>>>>>>>>> simulated final
>>>>>>>>> state and terminate normally then
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope.
>>>>>>>>
>>>>>>>> Where did you get the transition from
>>>>>>>>
>>>>>>>> a input finite string pair of program/input specifies a
>>>>>>>> computation that would reach a final state and terminate normally
>>>>>>>>
>>>>>>>> to
>>>>>>>>
>>>>>>>> H correctly determines that D correctly simulated *by H* cannot
>>>>>>>> possiby reach its own simulated final state.
>>>>>>>>
>>>>>>>
>>>>>>> The computation that D specifies to H <is> recursive
>>>>>>> simulation. H is not allowed to simply ignore that D
>>>>>>> is calling itself.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> No, D, if it is an actual program, has its OWN "copy" of H that it
>>>>>> uses,
>>>>>
>>>>> I have proven that does not make any difference.
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> Simulating Partial Halt Decider Applied to Linz Proof
>>>>> Non-halting behavior patterns can be matched in N steps. The
>>>>> simulated ⟨Ĥ⟩ halts only it when reaches its simulated final state
>>>>> of ⟨Ĥ.qn⟩ in a finite number of steps.
>>>>>
>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>> (b) embedded_H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>> applied to ⟨Ĥ⟩
>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>
>>>>
>>>> Except that pattern isn't non-halting, since if H (and thus
>>>> embedded_H) abort its simulation, that loop is NOT non-halting,
>>>
>>> An aborted simulation does not count as the simulated input reaching
>>> its simulated final state of ⟨Ĥ.qn⟩ and terminated normally.
>>
>> Right, but doesn't show that the correct simulaiton of that input
>> would not halt.
>>
>> Ĥ uses its copy of H to answer (by its simulation) the question about
>> its input (Ĥ) (Ĥ), and that H aborts its simulation and returns to Ĥ
>> which halts, as would a CORRECT simulaton of the input to any H give
>> (Ĥ) (Ĥ).
>
> Do you understand that none of the simulated ⟨Ĥ⟩ can possibly reach
> their simulated final state of ⟨Ĥ.qn⟩ ???
>

Yes, and it doesn't matter as an aborted simulation does not prove
non-halting. Partial simulations don't themselves prove anything. The
actual correct simulation of this input, when given to a REAL UTM (and
the input still using the embedded_H that is a copy of the H that gave
the answer) shows that it will halt, and thus none of the H's simulation
are "correct" for that purpose (just partial)

You are just proving yourself to be an idiot to claim that a "correct
answer" about the Halting behavior of the machine descxribed by the
input can be anything that disagrees with te actual Halting Beahvior of
the program described by the input when run.

You have agrees that Ĥ (Ĥ) will halt, but claim, as a lie, that
H (Ĥ) (Ĥ) saying non-halting is correct, because its PARTIAL (and thus
not difinitive) simulation didn't reach a final state.

Only a simulation that shows that you can not reach a final state even
after an unbounded number of steps shows non-halting, but doing such a
simulation make the machine fail to be a decider, as deciders must
answer in bounded time, and until you invent a time machine, you can't
do unbounded work in bounded time.

On 1/19/24 2:08 PM, olcott wrote:
> On 1/19/2024 12:27 PM, Richard Damon wrote:
>> On 1/19/24 1:16 PM, immibis wrote:
>>> On 1/19/24 17:14, olcott wrote:
>>>> On 1/19/2024 9:34 AM, Richard Damon wrote:
>>>>> On 1/19/24 8:54 AM, olcott wrote:
>>>>>> *This is the correct definition of a decider*
>>>>>> Deciders always must compute the mapping from an input finite
>>>>>> string to
>>>>>> their own accept or reject state on the basis of a syntactic or
>>>>>> semantic
>>>>>> property of this finite string.
>>>>>>
>>>>>> *Definition of the HP based on the above definition of a decider*
>>>>>> In computability theory, the halting problem is the problem of
>>>>>> determining, whether an input finite string pair of program/input
>>>>>> specifies a computation that would reach a final state and terminate
>>>>>> normally.
>>>>>>
>>>>>> *Definition of halt decider based on the above definitions*
>>>>>> (a) If simulating termination analyzer H correctly determines that D
>>>>>> correctly simulated by H cannot possibly reach its own simulated
>>>>>> final
>>>>>> state and terminate normally then
>>>>>>
>>>>>
>>>>> Nope.
>>>>>
>>>>> Where did you get the transition from
>>>>>
>>>>> a input finite string pair of program/input specifies a computation
>>>>> that would reach a final state and terminate normally
>>>>>
>>>>> to
>>>>>
>>>>> H correctly determines that D correctly simulated *by H* cannot
>>>>> possiby reach its own simulated final state.
>>>>>
>>>>
>>>> The computation that D specifies to H <is> recursive
>>>> simulation. H is not allowed to simply ignore that D
>>>> is calling itself.
>>>>
>>>
>>> H is not allowed to simply ignore that D would detect infinite
>>> recursion, stop simulating and reach a final state.
>>>
>>
>> Except that D doesn't create infinite recursion BECAUSE H (the H used
>> by D) aborts its simulation and stops it.
>>
>
> HH correctly simulates DD until it correctly determines
> that HH correctly simulated by HH cannot possibly reach
> its own simulated final state and halt, then HH returns
> to its caller.

The HH actually NEVER stops its simulation

>
> When DD(DD) is its caller then this entirely different
> execution sequence benefits from the fact that HH
> has aborted the simulation of the different execution
> sequence specified by DD.

But it isn't a different exection sequence.

Please show the first step in HH where its behavior differed by being
called from DD then being run as a top level machine.

or equivalnently

Show the first step where a difference actually occurs between the
"Correct" simulation done by HH on its input verse the actual behavior
of the directly run machine (or simulation of the input by a UTM) where
the behavior occurs.

There needs to be a first step of difference for the final results to be
different, since they start at the same place.

>
> HH cannot possibly benefit from itself already havng
> aborted the simulation of DD before any HH has done this.
>

You have the actions backwards. The HH that is doing the actual
simulation needs to "look ahead" at the behavior that the simulated
machine WILL DO if it simulated farther before it can decide to abort.
Since the simulated HH, if properly simulated past the point where HH
decides to abort its simulate, will also reach the point where it will
abort its simulation and return, and thus HH needs to take this into
account if it is to "Correctly" determine what a "Correct Simulation"
will do.

On 1/19/24 1:56 PM, olcott wrote:
> On 1/19/2024 12:16 PM, immibis wrote:
>> On 1/19/24 17:14, olcott wrote:
>>> On 1/19/2024 9:34 AM, Richard Damon wrote:
>>>> On 1/19/24 8:54 AM, olcott wrote:
>>>>> *This is the correct definition of a decider*
>>>>> Deciders always must compute the mapping from an input finite
>>>>> string to
>>>>> their own accept or reject state on the basis of a syntactic or
>>>>> semantic
>>>>> property of this finite string.
>>>>>
>>>>> *Definition of the HP based on the above definition of a decider*
>>>>> In computability theory, the halting problem is the problem of
>>>>> determining, whether an input finite string pair of program/input
>>>>> specifies a computation that would reach a final state and terminate
>>>>> normally.
>>>>>
>>>>> *Definition of halt decider based on the above definitions*
>>>>> (a) If simulating termination analyzer H correctly determines that D
>>>>> correctly simulated by H cannot possibly reach its own simulated final
>>>>> state and terminate normally then
>>>>>
>>>>
>>>> Nope.
>>>>
>>>> Where did you get the transition from
>>>>
>>>> a input finite string pair of program/input specifies a computation
>>>> that would reach a final state and terminate normally
>>>>
>>>> to
>>>>
>>>> H correctly determines that D correctly simulated *by H* cannot
>>>> possiby reach its own simulated final state.
>>>>
>>>
>>> The computation that D specifies to H <is> recursive
>>> simulation. H is not allowed to simply ignore that D
>>> is calling itself.
>>>
>>
>> H is not allowed to simply ignore that D would detect infinite
>> recursion, stop simulating and reach a final state.
>>
>
> *This is simply over your head*
> Unless the outermost HH aborts its simulation then none of them do.
>

And if the outermost HH aborts its simulation, then a correct simulation
of all of them do, so HH was incorrect in assuming that even if it
aborts, that the correct simulation of this input will never halt.

Since HH doesn't actually do the defined "correct simulation" it can't
use that as grounds to abort. It needs to correctly decide on the
behavior of an actual correct simulation.

On 1/19/24 4:12 PM, olcott wrote:
> On 1/19/2024 2:44 PM, immibis wrote:
>> On 1/19/24 19:56, olcott wrote:
>>> On 1/19/2024 12:16 PM, immibis wrote:
>>>> On 1/19/24 17:14, olcott wrote:
>>>>> On 1/19/2024 9:34 AM, Richard Damon wrote:
>>>>>> On 1/19/24 8:54 AM, olcott wrote:
>>>>>>> *This is the correct definition of a decider*
>>>>>>> Deciders always must compute the mapping from an input finite
>>>>>>> string to
>>>>>>> their own accept or reject state on the basis of a syntactic or
>>>>>>> semantic
>>>>>>> property of this finite string.
>>>>>>>
>>>>>>> *Definition of the HP based on the above definition of a decider*
>>>>>>> In computability theory, the halting problem is the problem of
>>>>>>> determining, whether an input finite string pair of program/input
>>>>>>> specifies a computation that would reach a final state and terminate
>>>>>>> normally.
>>>>>>>
>>>>>>> *Definition of halt decider based on the above definitions*
>>>>>>> (a) If simulating termination analyzer H correctly determines that D
>>>>>>> correctly simulated by H cannot possibly reach its own simulated
>>>>>>> final
>>>>>>> state and terminate normally then
>>>>>>>
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>> Where did you get the transition from
>>>>>>
>>>>>> a input finite string pair of program/input specifies a
>>>>>> computation that would reach a final state and terminate normally
>>>>>>
>>>>>> to
>>>>>>
>>>>>> H correctly determines that D correctly simulated *by H* cannot
>>>>>> possiby reach its own simulated final state.
>>>>>>
>>>>>
>>>>> The computation that D specifies to H <is> recursive
>>>>> simulation. H is not allowed to simply ignore that D
>>>>> is calling itself.
>>>>>
>>>>
>>>> H is not allowed to simply ignore that D would detect infinite
>>>> recursion, stop simulating and reach a final state.
>>>>
>>>
>>> *This is simply over your head*
>>> Unless the outermost HH aborts its simulation then none of them do.
>>>
>>
>> Why?
>>
>
> Each simulated HH has the exact same instructions as the
> others because it <is> the same code at the same machine
> address.
>
> The outer HH aborts the simulation as soon as the abort
> criteria has been met. Since it sees this abort criteria
> first unless it aborts then none of them do.

No, ALL of the others would do in an actual correct simulation.

>
>> And what is HH? You changed H to HH - why?
>
> HH is the original H and can simulate itself simulating
> DD. H can not do this, it uses a different abort criteria
> so that it can abort sooner.
>

And is still wrong.

On 1/19/24 4:13 PM, olcott wrote:
> On 1/19/2024 2:46 PM, immibis wrote:
>> On 1/19/24 18:17, olcott wrote:
>>>
>>> An aborted simulation does not count as the simulated input reaching
>>> its simulated final state of ⟨Ĥ.qn⟩ and terminated normally.
>>>
>>
>> An abortING simulation does count as the simulatOR reaching its final
>> state and terminating normally.
>>
>>
>
> Yes it does. It does not count as the simulated input DD halting.
>

Except for the fact that it is a given that the correct simulaiton of
that part of the input will be the same as the actual behavior of the
simulator.

Since H returns to qn, a correct simulation of embedded_H must see it
going to qn too.