On 1/19/2024 5:03 PM, Richard Damon wrote:
> On 1/19/24 5:14 PM, olcott wrote:
>> On 1/19/2024 3:34 PM, Richard Damon wrote:
>>> 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,
>>
>> This is simply not true. What computer language are you an expert in?
>>
>> The outermost HH sees the abort criteria first. If it does not abort
>> then none of them do because it is the exact same code at the exact
>> same machine address.
>>
>
> No, YOU do not understand about programs.
>

I will assume that you are not an expert in any programming
language until you say otherwise.

--
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 5:03 PM, Richard Damon wrote:
> On 1/19/24 5:29 PM, olcott wrote:
>> On 1/19/2024 3:57 PM, Richard Damon wrote:
>>> On 1/19/24 4:47 PM, olcott wrote:
>>>> On 1/19/2024 3:34 PM, Richard Damon wrote:
>>>>> 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.
>>>>
>>>> void Infinite_Loop()
>>>> {
>>>>    HERE: goto HERE;
>>>> }
>>>>
>>>> In other words no one can possibly tell that the above function will
>>>> not
>>>> halt until they waited an infinite amount of time and saw that it did
>>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>>>
>>>> The freaking repeated state proves non-halting the first freaking time
>>>> that it is encountered.
>>>>
>>>
>>> That isn't what I said. The fact that the aborted simulation didn't
>>> reach an end, doesn't prove BY ITSELF, that the input is non-halting.
>>>
>>
>> It is the repeated state that proves non-halting you big dummy.
>> You never did any programming did you?
>>
>
> And what repeated state is that?
>

You don't even know what the term means.

--
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 5:03 PM, Richard Damon wrote:
> On 1/19/24 5:50 PM, Alan Mackenzie wrote:
>> In comp.theory Richard Damon <richard@damon-family.org> wrote:
>>
>> [ .... ]
>>
>>> 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.
>>
>> Is that right?  Deciders must answer in finite time, but is there
>> actually a bound on how long this time can be?  If so, what is it?
>>
>
> It is not stated, but it it DOES answer in a finite time, then that time
> can be given as the bound.

Wrong. It must be a finite sequence of steps it
does not matter if each step takes a million years.

--
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 6:30 PM, olcott wrote:
> On 1/19/2024 4:58 PM, Alan Mackenzie wrote:
>> In comp.theory olcott <polcott2@gmail.com> wrote:
>>
>> [ .... ]
>>
>>> void Infinite_Loop()
>>> {
>>>    HERE: goto HERE;
>>> }
>>
>>> In other words no one can possibly tell that the above function will not
>>> halt until they waited an infinite amount of time and saw that it did
>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>
>> That is why attempting to solve the halting problem with a simulator is
>> not a sensible thing to do.
>>
>
> The best selling author of textbooks on the theory of computation
> disagrees.
>
> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>
> 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.
>

Nope.

He agrees that if H can CORRECT determine that a CORRECT SIMULATION (it
doesn't really matter by who) of THIS input would be non-halting, then
the decider can abort.

Since D(D) Halts, a correct simulation will halt, and thus you can not
correctly determine that a correct simulation would not halt, therefore
H is INCORRECT in its decision to abort.

Any simulation showing non-halting behavior is of a different input
where D was built on a different H than the one originally give, which
does abort its simulation and returns 0.

Your system, just is incapbable of handling the required components, and
you have admitted that in the past.

D needs to use the original H, but your system can have only one H, so
any operations done with a modified H (like removing its abort
operation) are just not applicable, as they are not look at the actual
problem.

You also have admitted that your D isn't even really a program, so none
of your logic is even applicable.

You are also have admited that you aren't even working in Computation
Theory, but Olcott-Computation Theory, and just lying that it applies to
the original theory.

On 1/19/2024 5:38 PM, Richard Damon wrote:
> On 1/19/24 6:30 PM, olcott wrote:
>> On 1/19/2024 4:58 PM, Alan Mackenzie wrote:
>>> In comp.theory olcott <polcott2@gmail.com> wrote:
>>>
>>> [ .... ]
>>>
>>>> void Infinite_Loop()
>>>> {
>>>>    HERE: goto HERE;
>>>> }
>>>
>>>> In other words no one can possibly tell that the above function will
>>>> not
>>>> halt until they waited an infinite amount of time and saw that it did
>>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>>
>>> That is why attempting to solve the halting problem with a simulator is
>>> not a sensible thing to do.
>>>
>>
>> The best selling author of textbooks on the theory of computation
>> disagrees.
>>
>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>
>> 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.
>>
>
> Nope.
>
> He agrees that if H can CORRECT determine that a CORRECT SIMULATION (it
> doesn't really matter by who) of THIS input would be non-halting, then
> the decider can abort.

You have simply been indoctrinated to believe this.
My counter-example may be the first case in history
where the correct simulation has different behavior
that the direct execution.

The directly executed DD(DD) itself does specify recursive
simulation that is aborted on its second recursive call.
This is the first time that HH can see what is going on.

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

In comp.theory olcott <polcott2@gmail.com> wrote:
> On 1/19/2024 4:58 PM, Alan Mackenzie wrote:
>> In comp.theory olcott <polcott2@gmail.com> wrote:

>> [ .... ]

>>> void Infinite_Loop()
>>> {
>>> HERE: goto HERE;
>>> }

>>> In other words no one can possibly tell that the above function will not
>>> halt until they waited an infinite amount of time and saw that it did
>>> not halt. DUMB, DUMB, DUMB, DUMB.

>> That is why attempting to solve the halting problem with a simulator is
>> not a sensible thing to do.

> The best selling author of textbooks on the theory of computation
> disagrees.

He does not. This author knows full well that a halting decider cannot
be built, as do millions of students and graduates world wide, who have
seen a proof (or even written one) and appreciate its clarity,
simplicity, and finality.

> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X

> 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.

I haven't seen you define a halting decider of any type over the last few
years. Such is impossible, just as it is impossible to square the
circle, or trisect an angle with ruler and compasses.

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

--
Alan Mackenzie (Nuremberg, Germany).

On 1/19/24 6:55 PM, olcott wrote:
> On 1/19/2024 5:38 PM, Richard Damon wrote:
>> On 1/19/24 6:30 PM, olcott wrote:
>>> On 1/19/2024 4:58 PM, Alan Mackenzie wrote:
>>>> In comp.theory olcott <polcott2@gmail.com> wrote:
>>>>
>>>> [ .... ]
>>>>
>>>>> void Infinite_Loop()
>>>>> {
>>>>>    HERE: goto HERE;
>>>>> }
>>>>
>>>>> In other words no one can possibly tell that the above function
>>>>> will not
>>>>> halt until they waited an infinite amount of time and saw that it did
>>>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>>>
>>>> That is why attempting to solve the halting problem with a simulator is
>>>> not a sensible thing to do.
>>>>
>>>
>>> The best selling author of textbooks on the theory of computation
>>> disagrees.
>>>
>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>
>>> 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.
>>>
>>
>> Nope.
>>
>> He agrees that if H can CORRECT determine that a CORRECT SIMULATION
>> (it doesn't really matter by who) of THIS input would be non-halting,
>> then the decider can abort.
>
> You have simply been indoctrinated to believe this.
> My counter-example may be the first case in history
> where the correct simulation has different behavior
> that the direct execution.

Which is INPOSSIBE by the DEFINITION of "Correct Simulation"

You can't make a cow a horse by calling it a horse.

>
> The directly executed DD(DD) itself does specify recursive
> simulation that is aborted on its second recursive call.
> This is the first time that HH can see what is going on.
>

But the simulation that was aborted was aborted by the program, and thus
the program gets "credit" for that behavior.

The fact the decider in the program happens to abort a simulation
doesn't make the program non-hatling.

This doesn't change just becauae the program it was simulating happend
to be a copy of itself.

You just are proving your utter ignorance of the subject and the fact
that you are just a pathological liar that just doesn't understand what
Truth actually is.

On 1/19/24 6:35 PM, olcott wrote:
> On 1/19/2024 5:03 PM, Richard Damon wrote:
>> On 1/19/24 5:50 PM, Alan Mackenzie wrote:
>>> In comp.theory Richard Damon <richard@damon-family.org> wrote:
>>>
>>> [ .... ]
>>>
>>>> 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.
>>>
>>> Is that right?  Deciders must answer in finite time, but is there
>>> actually a bound on how long this time can be?  If so, what is it?
>>>
>>
>> It is not stated, but it it DOES answer in a finite time, then that
>> time can be given as the bound.
>
> Wrong. It must be a finite sequence of steps it
> does not matter if each step takes a million years.
>

"time" in Conputation theory is measured in Steps, not Seconds.

On 1/19/24 6:32 PM, olcott wrote:
> On 1/19/2024 5:03 PM, Richard Damon wrote:
>> On 1/19/24 5:14 PM, olcott wrote:
>>> On 1/19/2024 3:34 PM, Richard Damon wrote:
>>>> 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,
>>>
>>> This is simply not true. What computer language are you an expert in?
>>>
>>> The outermost HH sees the abort criteria first. If it does not abort
>>> then none of them do because it is the exact same code at the exact
>>> same machine address.
>>>
>>
>> No, YOU do not understand about programs.
>>
>
> I will assume that you are not an expert in any programming
> language until you say otherwise.
>

Well, I AM proficient in probably more programming languages than you
actually know.

So, I have said otherwise.

I am still employed at a job where programming is a major part of my job
and considered the "go to" person for handling problems.

On 1/19/24 6:33 PM, olcott wrote:
> On 1/19/2024 5:03 PM, Richard Damon wrote:
>> On 1/19/24 5:29 PM, olcott wrote:
>>> On 1/19/2024 3:57 PM, Richard Damon wrote:
>>>> On 1/19/24 4:47 PM, olcott wrote:
>>>>> On 1/19/2024 3:34 PM, Richard Damon wrote:
>>>>>> 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.
>>>>>
>>>>> void Infinite_Loop()
>>>>> {
>>>>>    HERE: goto HERE;
>>>>> }
>>>>>
>>>>> In other words no one can possibly tell that the above function
>>>>> will not
>>>>> halt until they waited an infinite amount of time and saw that it did
>>>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>>>>
>>>>> The freaking repeated state proves non-halting the first freaking time
>>>>> that it is encountered.
>>>>>
>>>>
>>>> That isn't what I said. The fact that the aborted simulation didn't
>>>> reach an end, doesn't prove BY ITSELF, that the input is non-halting.
>>>>
>>>
>>> It is the repeated state that proves non-halting you big dummy.
>>> You never did any programming did you?
>>>
>>
>> And what repeated state is that?
>>
>
> You don't even know what the term means.
>

Sure I do, the conplete state of execution of the program is the
collection of ALL the information under the "control" of the program.

On 1/19/2024 6:01 PM, Alan Mackenzie wrote:
> In comp.theory olcott <polcott2@gmail.com> wrote:
>> On 1/19/2024 4:58 PM, Alan Mackenzie wrote:
>>> In comp.theory olcott <polcott2@gmail.com> wrote:
>
>>> [ .... ]
>
>>>> void Infinite_Loop()
>>>> {
>>>> HERE: goto HERE;
>>>> }
>
>>>> In other words no one can possibly tell that the above function will not
>>>> halt until they waited an infinite amount of time and saw that it did
>>>> not halt. DUMB, DUMB, DUMB, DUMB.
>
>>> That is why attempting to solve the halting problem with a simulator is
>>> not a sensible thing to do.
>
>
>> The best selling author of textbooks on the theory of computation
>> disagrees.
>
> He does not. This author knows full well that a halting decider cannot
> be built, as do millions of students and graduates world wide, who have
> seen a proof (or even written one) and appreciate its clarity,
> simplicity, and finality.
>
>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>
>> 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.
>
> I haven't seen you define a halting decider of any type over
> the last few years.

When you ignore what I say THIS DOES NOT COUNT AS ME NOT SAYING IT.
Professor Sipser agreed that the following definition
of a simulating halt decider is correct

On 10/13/2022 11:46 AM, olcott wrote:
> MIT Professor Michael Sipser has agreed that the following
> verbatim paragraph is correct:
>
> 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.

Did you notice that it says: "simulating halt decider H"

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

--
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 6:13 PM, Richard Damon wrote:
> On 1/19/24 6:33 PM, olcott wrote:
>> On 1/19/2024 5:03 PM, Richard Damon wrote:
>>> On 1/19/24 5:29 PM, olcott wrote:
>>>> On 1/19/2024 3:57 PM, Richard Damon wrote:
>>>>> On 1/19/24 4:47 PM, olcott wrote:
>>>>>> On 1/19/2024 3:34 PM, Richard Damon wrote:
>>>>>>> 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.
>>>>>>
>>>>>> void Infinite_Loop()
>>>>>> {
>>>>>>    HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> In other words no one can possibly tell that the above function
>>>>>> will not
>>>>>> halt until they waited an infinite amount of time and saw that it did
>>>>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>>>>>
>>>>>> The freaking repeated state proves non-halting the first freaking
>>>>>> time
>>>>>> that it is encountered.
>>>>>>
>>>>>
>>>>> That isn't what I said. The fact that the aborted simulation didn't
>>>>> reach an end, doesn't prove BY ITSELF, that the input is non-halting.
>>>>>
>>>>
>>>> It is the repeated state that proves non-halting you big dummy.
>>>> You never did any programming did you?
>>>>
>>>
>>> And what repeated state is that?
>>>
>>
>> You don't even know what the term means.
>>
>
> Sure I do, the conplete state of execution of the program is the
> collection of ALL the information under the "control" of the program.
>
> Since the "state" you called repeated occred at a differet level of
> simulation then the origianl, the state of the whole program is NOT the
> same, as the data reguarding simulation levels differs.
>
> YOU don't seem to know what it means, since you use it incorrectly.

On 1/19/2024 6:08 PM, Richard Damon wrote:
> On 1/19/24 6:55 PM, olcott wrote:
>> On 1/19/2024 5:38 PM, Richard Damon wrote:
>>> On 1/19/24 6:30 PM, olcott wrote:
>>>> On 1/19/2024 4:58 PM, Alan Mackenzie wrote:
>>>>> In comp.theory olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>> [ .... ]
>>>>>
>>>>>> void Infinite_Loop()
>>>>>> {
>>>>>>    HERE: goto HERE;
>>>>>> }
>>>>>
>>>>>> In other words no one can possibly tell that the above function
>>>>>> will not
>>>>>> halt until they waited an infinite amount of time and saw that it did
>>>>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>>>>
>>>>> That is why attempting to solve the halting problem with a
>>>>> simulator is
>>>>> not a sensible thing to do.
>>>>>
>>>>
>>>> The best selling author of textbooks on the theory of computation
>>>> disagrees.
>>>>
>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>
>>>> 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.
>>>>
>>>
>>> Nope.
>>>
>>> He agrees that if H can CORRECT determine that a CORRECT SIMULATION
>>> (it doesn't really matter by who) of THIS input would be non-halting,
>>> then the decider can abort.
>>
>> You have simply been indoctrinated to believe this.
>> My counter-example may be the first case in history
>> where the correct simulation has different behavior
>> that the direct execution.
>
> Which is INPOSSIBE by the DEFINITION of "Correct Simulation"
>

The definition of correct simulation simply presumed
that pathological self-reference does not change the
execution sequence because no one ever bothered to
carefully examined this.

Naive set theory presumed that its definition of {set}
was correct and ZFC proved that it was not correct.

Since it is a verified fact that D correctly simulated by
H1 depends on H aborting its simulation and H cannot
depend on this it is proved that they are not the same.

--
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 6:10 PM, Richard Damon wrote:
> On 1/19/24 6:32 PM, olcott wrote:
>> On 1/19/2024 5:03 PM, Richard Damon wrote:
>>> On 1/19/24 5:14 PM, olcott wrote:
>>>> On 1/19/2024 3:34 PM, Richard Damon wrote:
>>>>> 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,
>>>>
>>>> This is simply not true. What computer language are you an expert in?
>>>>
>>>> The outermost HH sees the abort criteria first. If it does not abort
>>>> then none of them do because it is the exact same code at the exact
>>>> same machine address.
>>>>
>>>
>>> No, YOU do not understand about programs.
>>>
>>
>> I will assume that you are not an expert in any programming
>> language until you say otherwise.
>>
>
> Well, I AM proficient in probably more programming languages than you
> actually know.
>
> So, I have said otherwise.
>
> I am still employed at a job where programming is a major part of my job
> and considered the "go to" person for handling problems.

In other words you are a Jack of some trades and a master of none.

--
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 7:31 PM, olcott wrote:
> On 1/19/2024 6:13 PM, Richard Damon wrote:
>> On 1/19/24 6:33 PM, olcott wrote:
>>> On 1/19/2024 5:03 PM, Richard Damon wrote:
>>>> On 1/19/24 5:29 PM, olcott wrote:
>>>>> On 1/19/2024 3:57 PM, Richard Damon wrote:
>>>>>> On 1/19/24 4:47 PM, olcott wrote:
>>>>>>> On 1/19/2024 3:34 PM, Richard Damon wrote:
>>>>>>>> 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.
>>>>>>>
>>>>>>> void Infinite_Loop()
>>>>>>> {
>>>>>>>    HERE: goto HERE;
>>>>>>> }
>>>>>>>
>>>>>>> In other words no one can possibly tell that the above function
>>>>>>> will not
>>>>>>> halt until they waited an infinite amount of time and saw that it
>>>>>>> did
>>>>>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>>>>>>
>>>>>>> The freaking repeated state proves non-halting the first freaking
>>>>>>> time
>>>>>>> that it is encountered.
>>>>>>>
>>>>>>
>>>>>> That isn't what I said. The fact that the aborted simulation
>>>>>> didn't reach an end, doesn't prove BY ITSELF, that the input is
>>>>>> non-halting.
>>>>>>
>>>>>
>>>>> It is the repeated state that proves non-halting you big dummy.
>>>>> You never did any programming did you?
>>>>>
>>>>
>>>> And what repeated state is that?
>>>>
>>>
>>> You don't even know what the term means.
>>>
>>
>> Sure I do, the conplete state of execution of the program is the
>> collection of ALL the information under the "control" of the program.
>>
>> Since the "state" you called repeated occred at a differet level of
>> simulation then the origianl, the state of the whole program is NOT
>> the same, as the data reguarding simulation levels differs.
>>
>> YOU don't seem to know what it means, since you use it incorrectly.
>
> The exact same sequence of instructions is executed
> with the exact same data... Dunderhead.
>

On 1/19/24 7:36 PM, olcott wrote:
> On 1/19/2024 6:08 PM, Richard Damon wrote:
>> On 1/19/24 6:55 PM, olcott wrote:
>>> On 1/19/2024 5:38 PM, Richard Damon wrote:
>>>> On 1/19/24 6:30 PM, olcott wrote:
>>>>> On 1/19/2024 4:58 PM, Alan Mackenzie wrote:
>>>>>> In comp.theory olcott <polcott2@gmail.com> wrote:
>>>>>>
>>>>>> [ .... ]
>>>>>>
>>>>>>> void Infinite_Loop()
>>>>>>> {
>>>>>>>    HERE: goto HERE;
>>>>>>> }
>>>>>>
>>>>>>> In other words no one can possibly tell that the above function
>>>>>>> will not
>>>>>>> halt until they waited an infinite amount of time and saw that it
>>>>>>> did
>>>>>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>>>>>
>>>>>> That is why attempting to solve the halting problem with a
>>>>>> simulator is
>>>>>> not a sensible thing to do.
>>>>>>
>>>>>
>>>>> The best selling author of textbooks on the theory of computation
>>>>> disagrees.
>>>>>
>>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>>
>>>>> 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.
>>>>>
>>>>
>>>> Nope.
>>>>
>>>> He agrees that if H can CORRECT determine that a CORRECT SIMULATION
>>>> (it doesn't really matter by who) of THIS input would be
>>>> non-halting, then the decider can abort.
>>>
>>> You have simply been indoctrinated to believe this.
>>> My counter-example may be the first case in history
>>> where the correct simulation has different behavior
>>> that the direct execution.
>>
>> Which is INPOSSIBE by the DEFINITION of "Correct Simulation"
>>
>
> The definition of correct simulation simply presumed
> that pathological self-reference does not change the
> execution sequence because no one ever bothered to
> carefully examined this.

Nope.

Just your admission of total ignorance.

>
> Naive set theory presumed that its definition of {set}
> was correct and ZFC proved that it was not correct.

Nope.

Russel's paradox proved that it was incorrect.

ZFC showed a different basis to make sets.

>
> Since it is a verified fact that D correctly simulated by
> H1 depends on H aborting its simulation and H cannot
> depend on this it is proved that they are not the same.
>
>

Nope.

Just shows that H can't do a correct simulation.

On 1/19/24 7:26 PM, olcott wrote:
> On 1/19/2024 6:01 PM, Alan Mackenzie wrote:
>> In comp.theory olcott <polcott2@gmail.com> wrote:
>>> On 1/19/2024 4:58 PM, Alan Mackenzie wrote:
>>>> In comp.theory olcott <polcott2@gmail.com> wrote:
>>
>>>> [ .... ]
>>
>>>>> void Infinite_Loop()
>>>>> {
>>>>>     HERE: goto HERE;
>>>>> }
>>
>>>>> In other words no one can possibly tell that the above function
>>>>> will not
>>>>> halt until they waited an infinite amount of time and saw that it did
>>>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>
>>>> That is why attempting to solve the halting problem with a simulator is
>>>> not a sensible thing to do.
>>
>>
>>> The best selling author of textbooks on the theory of computation
>>> disagrees.
>>
>> He does not.  This author knows full well that a halting decider cannot
>> be built, as do millions of students and graduates world wide, who have
>> seen a proof (or even written one) and appreciate its clarity,
>> simplicity, and finality.
>>
>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>
>>> 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.
>>
>> I haven't seen you define a halting decider of any type over the last
>> few years.
>
> When you ignore what I say THIS DOES NOT COUNT AS ME NOT SAYING IT.
> Professor Sipser agreed that the following definition
> of a simulating halt decider is correct
>
> On 10/13/2022 11:46 AM, olcott wrote:
> > MIT Professor Michael Sipser has agreed that the following
> > verbatim paragraph is correct:
> >
> > 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.
>
> Did you notice that it says: "simulating halt decider H"
>

Right, If H can CORRECTLY determine that a CORRECT SIMULATION of the
input can not stop running.

Since the program on the input does stop running (since it is D built on
the H that gives the claimed answer) the correct simulation of that
program will halt running at the final state, and thus H can not
correctly determine that it doesn/t.

Of course, since you admit that you don't understand the correct meaning
of a correct simulation, you can't understand what Professor Sipser said.

>>> --
>>> 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 7:38 PM, olcott wrote:
> On 1/19/2024 6:10 PM, Richard Damon wrote:
>> On 1/19/24 6:32 PM, olcott wrote:
>>> On 1/19/2024 5:03 PM, Richard Damon wrote:
>>>> On 1/19/24 5:14 PM, olcott wrote:
>>>>> On 1/19/2024 3:34 PM, Richard Damon wrote:
>>>>>> 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,
>>>>>
>>>>> This is simply not true. What computer language are you an expert in?
>>>>>
>>>>> The outermost HH sees the abort criteria first. If it does not abort
>>>>> then none of them do because it is the exact same code at the exact
>>>>> same machine address.
>>>>>
>>>>
>>>> No, YOU do not understand about programs.
>>>>
>>>
>>> I will assume that you are not an expert in any programming
>>> language until you say otherwise.
>>>
>>
>> Well, I AM proficient in probably more programming languages than you
>> actually know.
>>
>> So, I have said otherwise.
>>
>> I am still employed at a job where programming is a major part of my
>> job and considered the "go to" person for handling problems.
>
> In other words you are a Jack of some trades and a master of none.
>

Nope. It seems you are a Jack of no trades and a master of lying.

Who comes to YOU to solve problems.

On 1/19/2024 6:46 PM, Richard Damon wrote:
> On 1/19/24 7:31 PM, olcott wrote:
>> On 1/19/2024 6:13 PM, Richard Damon wrote:
>>> On 1/19/24 6:33 PM, olcott wrote:
>>>> On 1/19/2024 5:03 PM, Richard Damon wrote:
>>>>> On 1/19/24 5:29 PM, olcott wrote:
>>>>>> On 1/19/2024 3:57 PM, Richard Damon wrote:
>>>>>>> On 1/19/24 4:47 PM, olcott wrote:
>>>>>>>> On 1/19/2024 3:34 PM, Richard Damon wrote:
>>>>>>>>> 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.
>>>>>>>>
>>>>>>>> void Infinite_Loop()
>>>>>>>> {
>>>>>>>>    HERE: goto HERE;
>>>>>>>> }
>>>>>>>>
>>>>>>>> In other words no one can possibly tell that the above function
>>>>>>>> will not
>>>>>>>> halt until they waited an infinite amount of time and saw that
>>>>>>>> it did
>>>>>>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>>>>>>>
>>>>>>>> The freaking repeated state proves non-halting the first
>>>>>>>> freaking time
>>>>>>>> that it is encountered.
>>>>>>>>
>>>>>>>
>>>>>>> That isn't what I said. The fact that the aborted simulation
>>>>>>> didn't reach an end, doesn't prove BY ITSELF, that the input is
>>>>>>> non-halting.
>>>>>>>
>>>>>>
>>>>>> It is the repeated state that proves non-halting you big dummy.
>>>>>> You never did any programming did you?
>>>>>>
>>>>>
>>>>> And what repeated state is that?
>>>>>
>>>>
>>>> You don't even know what the term means.
>>>>
>>>
>>> Sure I do, the conplete state of execution of the program is the
>>> collection of ALL the information under the "control" of the program.
>>>
>>> Since the "state" you called repeated occred at a differet level of
>>> simulation then the origianl, the state of the whole program is NOT
>>> the same, as the data reguarding simulation levels differs.
>>>
>>> YOU don't seem to know what it means, since you use it incorrectly.
>>
>> The exact same sequence of instructions is executed
>> with the exact same data... Dunderhead.
>>
>
> That isn't the "state"
>
> DUNDERHEAD.
>

On 1/19/2024 6:48 PM, Richard Damon wrote:
> On 1/19/24 7:36 PM, olcott wrote:
>> On 1/19/2024 6:08 PM, Richard Damon wrote:
>>> On 1/19/24 6:55 PM, olcott wrote:
>>>> On 1/19/2024 5:38 PM, Richard Damon wrote:
>>>>> On 1/19/24 6:30 PM, olcott wrote:
>>>>>> On 1/19/2024 4:58 PM, Alan Mackenzie wrote:
>>>>>>> In comp.theory olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>> [ .... ]
>>>>>>>
>>>>>>>> void Infinite_Loop()
>>>>>>>> {
>>>>>>>>    HERE: goto HERE;
>>>>>>>> }
>>>>>>>
>>>>>>>> In other words no one can possibly tell that the above function
>>>>>>>> will not
>>>>>>>> halt until they waited an infinite amount of time and saw that
>>>>>>>> it did
>>>>>>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>>>>>>
>>>>>>> That is why attempting to solve the halting problem with a
>>>>>>> simulator is
>>>>>>> not a sensible thing to do.
>>>>>>>
>>>>>>
>>>>>> The best selling author of textbooks on the theory of computation
>>>>>> disagrees.
>>>>>>
>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>>>
>>>>>> 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.
>>>>>>
>>>>>
>>>>> Nope.
>>>>>
>>>>> He agrees that if H can CORRECT determine that a CORRECT SIMULATION
>>>>> (it doesn't really matter by who) of THIS input would be
>>>>> non-halting, then the decider can abort.
>>>>
>>>> You have simply been indoctrinated to believe this.
>>>> My counter-example may be the first case in history
>>>> where the correct simulation has different behavior
>>>> that the direct execution.
>>>
>>> Which is INPOSSIBE by the DEFINITION of "Correct Simulation"
>>>
>>
>> The definition of correct simulation simply presumed
>> that pathological self-reference does not change the
>> execution sequence because no one ever bothered to
>> carefully examined this.
>
> Nope.
>
> Just your admission of total ignorance.
>
>>
>> Naive set theory presumed that its definition of {set}
>> was correct and ZFC proved that it was not correct.
>
> Nope.
>
> Russel's paradox proved that it was incorrect.
>

And what everyone else is simply not bright enough to
understand is that every undecidable input proves
the each decision problem with undecidable input
is itself incorrect.

> ZFC showed a different basis to make sets.
>

Likewise a different basis to decide halting also
eliminates undecidability.

Undecidability always means that the decision problem is wrong.

--
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 6:54 PM, Richard Damon wrote:
> On 1/19/24 7:38 PM, olcott wrote:
>> On 1/19/2024 6:10 PM, Richard Damon wrote:
>>> On 1/19/24 6:32 PM, olcott wrote:
>>>> On 1/19/2024 5:03 PM, Richard Damon wrote:
>>>>> On 1/19/24 5:14 PM, olcott wrote:
>>>>>> On 1/19/2024 3:34 PM, Richard Damon wrote:
>>>>>>> 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,
>>>>>>
>>>>>> This is simply not true. What computer language are you an expert in?
>>>>>>
>>>>>> The outermost HH sees the abort criteria first. If it does not abort
>>>>>> then none of them do because it is the exact same code at the exact
>>>>>> same machine address.
>>>>>>
>>>>>
>>>>> No, YOU do not understand about programs.
>>>>>
>>>>
>>>> I will assume that you are not an expert in any programming
>>>> language until you say otherwise.
>>>>
>>>
>>> Well, I AM proficient in probably more programming languages than you
>>> actually know.
>>>
>>> So, I have said otherwise.
>>>
>>> I am still employed at a job where programming is a major part of my
>>> job and considered the "go to" person for handling problems.
>>
>> In other words you are a Jack of some trades and a master of none.
>>
>
> Nope. It seems you are a Jack of no trades and a master of lying.
>
> Who comes to YOU to solve problems.

It is not about solving arbitrary problems it is about
being able to perfectly understand how execution traces
work and how they can be verified as correct.

You are clearly not very good at that problem.

--
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 5:29 PM, olcott wrote:
> On 1/19/2024 3:57 PM, Richard Damon wrote:
>> On 1/19/24 4:47 PM, olcott wrote:
>>> On 1/19/2024 3:34 PM, Richard Damon wrote:
>>>> 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.
>>>
>>> void Infinite_Loop()
>>> {
>>>    HERE: goto HERE;
>>> }
>>>
>>> In other words no one can possibly tell that the above function will not
>>> halt until they waited an infinite amount of time and saw that it did
>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>>
>>> The freaking repeated state proves non-halting the first freaking time
>>> that it is encountered.
>>>
>>
>> That isn't what I said. The fact that the aborted simulation didn't
>> reach an end, doesn't prove BY ITSELF, that the input is non-halting.
>>
>
> It is the repeated state that proves non-halting you big dummy.
> You never did any programming did you?
>

But the full state wasn;t repeated, but only showed in different level
of conditional simulation, which doesn't count.

You seem to have never heard of logic and rules.

On 1/19/24 8:01 PM, olcott wrote:
> On 1/19/2024 6:48 PM, Richard Damon wrote:
>> On 1/19/24 7:36 PM, olcott wrote:
>>> On 1/19/2024 6:08 PM, Richard Damon wrote:
>>>> On 1/19/24 6:55 PM, olcott wrote:
>>>>> On 1/19/2024 5:38 PM, Richard Damon wrote:
>>>>>> On 1/19/24 6:30 PM, olcott wrote:
>>>>>>> On 1/19/2024 4:58 PM, Alan Mackenzie wrote:
>>>>>>>> In comp.theory olcott <polcott2@gmail.com> wrote:
>>>>>>>>
>>>>>>>> [ .... ]
>>>>>>>>
>>>>>>>>> void Infinite_Loop()
>>>>>>>>> {
>>>>>>>>>    HERE: goto HERE;
>>>>>>>>> }
>>>>>>>>
>>>>>>>>> In other words no one can possibly tell that the above function
>>>>>>>>> will not
>>>>>>>>> halt until they waited an infinite amount of time and saw that
>>>>>>>>> it did
>>>>>>>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>>>>>>>
>>>>>>>> That is why attempting to solve the halting problem with a
>>>>>>>> simulator is
>>>>>>>> not a sensible thing to do.
>>>>>>>>
>>>>>>>
>>>>>>> The best selling author of textbooks on the theory of computation
>>>>>>> disagrees.
>>>>>>>
>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>>>>
>>>>>>> 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.
>>>>>>>
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>> He agrees that if H can CORRECT determine that a CORRECT
>>>>>> SIMULATION (it doesn't really matter by who) of THIS input would
>>>>>> be non-halting, then the decider can abort.
>>>>>
>>>>> You have simply been indoctrinated to believe this.
>>>>> My counter-example may be the first case in history
>>>>> where the correct simulation has different behavior
>>>>> that the direct execution.
>>>>
>>>> Which is INPOSSIBE by the DEFINITION of "Correct Simulation"
>>>>
>>>
>>> The definition of correct simulation simply presumed
>>> that pathological self-reference does not change the
>>> execution sequence because no one ever bothered to
>>> carefully examined this.
>>
>> Nope.
>>
>> Just your admission of total ignorance.
>>
>>>
>>> Naive set theory presumed that its definition of {set}
>>> was correct and ZFC proved that it was not correct.
>>
>> Nope.
>>
>> Russel's paradox proved that it was incorrect.
>>
>
> And what everyone else is simply not bright enough to
> understand is that every undecidable input proves
> the each decision problem with undecidable input
> is itself incorrect.

Nope, undecidable problems are by definition correct, but then you don't
actually seem to know what an undecidable problem is.

Questions without possible answers are incorrect.

So making a set that contains only those sets that don't contain
themselves are not correct, as such a set can't exist.

The Halting Question is NOT such a question.

>
>> ZFC showed a different basis to make sets.
>>
>
> Likewise a different basis to decide halting also
> eliminates undecidability.

So, your making PO-Computation Theory?

The go post in comp.po-theory about your ideas, where people might care
about them.

>
> Undecidability always means that the decision problem is wrong.
>

Nope.

But again, you don't know what undecidability is, so of course you don't
know that it isn't wrong.

On 1/19/2024 7:20 PM, Richard Damon wrote:
> On 1/19/24 5:29 PM, olcott wrote:
>> On 1/19/2024 3:57 PM, Richard Damon wrote:
>>> On 1/19/24 4:47 PM, olcott wrote:
>>>> On 1/19/2024 3:34 PM, Richard Damon wrote:
>>>>> 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.
>>>>
>>>> void Infinite_Loop()
>>>> {
>>>>    HERE: goto HERE;
>>>> }
>>>>
>>>> In other words no one can possibly tell that the above function will
>>>> not
>>>> halt until they waited an infinite amount of time and saw that it did
>>>> not halt. DUMB, DUMB, DUMB, DUMB.
>>>>
>>>> The freaking repeated state proves non-halting the first freaking time
>>>> that it is encountered.
>>>>
>>>
>>> That isn't what I said. The fact that the aborted simulation didn't
>>> reach an end, doesn't prove BY ITSELF, that the input is non-halting.
>>>
>>
>> It is the repeated state that proves non-halting you big dummy.
>> You never did any programming did you?
>>
>
> But the full state wasn;t repeated, but only showed in different level
> of conditional simulation, which doesn't count.
>
> You seem to have never heard of logic and rules.
>
>

The full state of D was repeated.
The only thing that changed was the stack address.

--
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:14 PM, olcott wrote:
> On 1/19/2024 6:54 PM, Richard Damon wrote:
>> On 1/19/24 7:38 PM, olcott wrote:
>>> On 1/19/2024 6:10 PM, Richard Damon wrote:
>>>> On 1/19/24 6:32 PM, olcott wrote:
>>>>> On 1/19/2024 5:03 PM, Richard Damon wrote:
>>>>>> On 1/19/24 5:14 PM, olcott wrote:
>>>>>>> On 1/19/2024 3:34 PM, Richard Damon wrote:
>>>>>>>> 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,
>>>>>>>
>>>>>>> This is simply not true. What computer language are you an expert
>>>>>>> in?
>>>>>>>
>>>>>>> The outermost HH sees the abort criteria first. If it does not abort
>>>>>>> then none of them do because it is the exact same code at the exact
>>>>>>> same machine address.
>>>>>>>
>>>>>>
>>>>>> No, YOU do not understand about programs.
>>>>>>
>>>>>
>>>>> I will assume that you are not an expert in any programming
>>>>> language until you say otherwise.
>>>>>
>>>>
>>>> Well, I AM proficient in probably more programming languages than
>>>> you actually know.
>>>>
>>>> So, I have said otherwise.
>>>>
>>>> I am still employed at a job where programming is a major part of my
>>>> job and considered the "go to" person for handling problems.
>>>
>>> In other words you are a Jack of some trades and a master of none.
>>>
>>
>> Nope. It seems you are a Jack of no trades and a master of lying.
>>
>> Who comes to YOU to solve problems.
>
> It is not about solving arbitrary problems it is about
> being able to perfectly understand how execution traces
> work and how they can be verified as correct.
>
> You are clearly not very good at that problem.
>

I think better than you,
How many programs have you had to debug at the assembly level due to
bugs in the compiler?

You don't even understand what a simulation trace of a program should
contain.

You think changing levels of abstraction is correct when looking at the
beahavior of the first level and asking if the simulator is correct.

THe Call to H should be followed by the simulation of the subroutine H.