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.
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
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.
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.
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/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.
An aborted simulation does not count as the simulated input reaching
its simulated final state of ⟨Ĥ.qn⟩ and terminated normally.
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⟩ ???
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.
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.
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.
On 1/19/2024 3:34 PM, Richard Damon wrote:
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.
When DD(DD) calls HH(DD,DD) this *DOES NOT SPECIFY* recursive
simulation.
When DD is simulated by HH(DD,DD) calls HH(DD,DD) this *DOES SPECIFY* recursive simulation.
You must be very terrible at coding.
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.
On 1/19/2024 3:41 PM, immibis wrote:
On 1/19/24 22:12, 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.
Does the direct executed HH have the exact same instructions as each
simulated HH?
There is only one HH at machine address [00001032].
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.
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.
--
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 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:Right, but doesn't show that the correct simulaiton of that input
On 1/19/24 11:55 AM, olcott wrote:An aborted simulation does not count as the simulated input reaching >>>>>>> its simulated final state of ⟨Ĥ.qn⟩ and terminated normally. >>>>>>
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, >>>>>>>
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?
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?
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.
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.
--
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: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.
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.
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:Right, but doesn't show that the correct simulaiton of that
On 1/19/24 11:55 AM, olcott wrote:An aborted simulation does not count as the simulated input
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, >>>>>>>>>
reaching
its simulated final state of ⟨Ĥ.qn⟩ and terminated normally. >>>>>>>>
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.
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:Right, but doesn't show that the correct simulaiton of that >>>>>>>>>> input would not halt.
On 1/19/24 11:55 AM, olcott wrote:An aborted simulation does not count as the simulated input >>>>>>>>>>> reaching
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, >>>>>>>>>>>
its simulated final state of ⟨Ĥ.qn⟩ and terminated normally. >>>>>>>>>>
Ĥ 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/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.
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
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.
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.
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:Right, but doesn't show that the correct simulaiton of that input
On 1/19/24 11:55 AM, olcott wrote:An aborted simulation does not count as the simulated input reaching >>>>>>> its simulated final state of ⟨Ĥ.qn⟩ and terminated normally. >>>>>>
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, >>>>>>>
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?
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.
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:Right, but doesn't show that the correct simulaiton of that
On 1/19/24 11:55 AM, olcott wrote:An aborted simulation does not count as the simulated input
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, >>>>>>>>>
reaching
its simulated final state of ⟨Ĥ.qn⟩ and terminated normally. >>>>>>>>
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.
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:Right, but doesn't show that the correct simulaiton of that >>>>>>>>>>>> input would not halt.
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. >>>>>>>>>>>>
Ĥ 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.
Begin Local Halt Decider Simulation Execution Trace Stored at:113027
[00001c42][00113013][00113017] 55 push ebp [00001c43][00113013][00113017] 8bec mov ebp,esp [00001c45][0011300f][00102fe3] 51 push ecx [00001c46][0011300f][00102fe3] 8b4508 mov eax,[ebp+08] ; DD [00001c49][0011300b][00001c42] 50 push eax ; DD
[00001c4a][0011300b][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD [00001c4d][00113007][00001c42] 51 push ecx ; DD
[00001c4e][00113003][00001c53] e80ff7ffff call 00001362 ; HH
New slave_stack at:14da47
[00001c42][0015da3b][0015da3f] 55 push ebp [00001c43][0015da3b][0015da3f] 8bec mov ebp,esp [00001c45][0015da37][0014da0b] 51 push ecx [00001c46][0015da37][0014da0b] 8b4508 mov eax,[ebp+08] ; DD [00001c49][0015da33][00001c42] 50 push eax ; DD
[00001c4a][0015da33][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD [00001c4d][0015da2f][00001c42] 51 push ecx ; DD
[00001c4e][0015da2b][00001c53] e80ff7ffff call 00001362 ; HH
Local Halt Decider: Recursion Simulation Detected Simulation Stopped
That you cannot tell that the above specifies
non-halting behavior makes you a dunderhead.
On 1/19/2024 7:25 PM, Richard Damon wrote:
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,
Then you were wrong when you said:
"Russel's paradox proved that it was incorrect."
It being the definition of the term: {set}.
*You just admitted that definitions can be incorrect*
The full state of D was repeated.
The only thing that changed was the stack address.
On 1/19/2024 7:31 PM, Richard Damon wrote:
On 1/19/24 7:55 PM, olcott wrote:
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:The exact same sequence of instructions is executed
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:Do you understand that none of the simulated ⟨Ĥ⟩ can >>>>>>>>>>>>> possibly reach
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 (Ĥ) (Ĥ). >>>>>>>>>>>>>
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. >>>>>
with the exact same data... Dunderhead.
That isn't the "state"
DUNDERHEAD.
Begin Local Halt Decider Simulation Execution Trace Stored >>> at:113027
[00001c42][00113013][00113017] 55 push ebp
[00001c43][00113013][00113017] 8bec mov ebp,esp
[00001c45][0011300f][00102fe3] 51 push ecx
[00001c46][0011300f][00102fe3] 8b4508 mov eax,[ebp+08] ; DD
[00001c49][0011300b][00001c42] 50 push eax ; DD
[00001c4a][0011300b][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD
[00001c4d][00113007][00001c42] 51 push ecx ; DD
[00001c4e][00113003][00001c53] e80ff7ffff call 00001362 ; HH
New slave_stack at:14da47
[00001c42][0015da3b][0015da3f] 55 push ebp
[00001c43][0015da3b][0015da3f] 8bec mov ebp,esp
[00001c45][0015da37][0014da0b] 51 push ecx
[00001c46][0015da37][0014da0b] 8b4508 mov eax,[ebp+08] ; DD
[00001c49][0015da33][00001c42] 50 push eax ; DD
[00001c4a][0015da33][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD
[00001c4d][0015da2f][00001c42] 51 push ecx ; DD
[00001c4e][0015da2b][00001c53] e80ff7ffff call 00001362 ; HH
Local Halt Decider: Recursion Simulation Detected Simulation Stopped
That you cannot tell that the above specifies
non-halting behavior makes you a dunderhead.
But since DD(DD) Halts, it can't be showing non-halting behavior.
Because of your ADHD I may need to say this hundreds of times
before you actually pay attention to the words.
DD(DD) relies on its HH(DD,DD) to terminate the recursive
simulation that it specifies.
DD simulated by HH cannot do that. This proves that
they are not the same computation.
On 1/19/2024 7:37 PM, Richard Damon wrote:
On 1/19/24 8:26 PM, olcott wrote:
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:Right, but doesn't show that the correct simulaiton of that >>>>>>>>>> input would not halt.
On 1/19/24 11:55 AM, olcott wrote:An aborted simulation does not count as the simulated input >>>>>>>>>>> reaching
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, >>>>>>>>>>>
its simulated final state of ⟨Ĥ.qn⟩ and terminated normally. >>>>>>>>>>
Ĥ 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.
No, the second set of "State" wasn't a state of the program, but a
state of the simulated simulated program inside the first simulation..
Only the x86utm operating system simulates the program
HH simulates the C function named HH. A C function <is>
a microcosm of a program.
On 1/19/2024 7:28 PM, Richard Damon wrote:
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.
The fact that I wrote the x86utm operating system where
HH correctly simulates itself simulating DD and bases
its halt status decision on the x86 machine code trace
(My own program decodes the control flow machine code).
proves that I know these things very well.
I have been working in the 8088 assembly language since
it was new. The x86 language with flat addressing is
much better. 64k segmented architecture was a bit of
a nightmare.
On 1/19/2024 7:58 PM, André G. Isaak wrote:
On 2024-01-19 18:26, olcott wrote:
The full state of D was repeated.
The only thing that changed was the stack address.
The contents of the stack and the stack address are *part* of the
state of the machine. If they change, you are not repeating the same
state.
André
Everything is identical across recursive simulations besides
the stack address. The stack address is irrelevant to whether
or not DD halts.
The easily verified fact that DD simulated by HH cannot possibly
reach its own simulated final state conclusively proves that DD
does not halt.
Begin Local Halt Decider Simulation Execution Trace Stored at:113027
[00001c42][00113013][00113017] 55 push ebp [00001c43][00113013][00113017] 8bec mov ebp,esp [00001c45][0011300f][00102fe3] 51 push ecx [00001c46][0011300f][00102fe3] 8b4508 mov eax,[ebp+08] ; DD [00001c49][0011300b][00001c42] 50 push eax ; DD
[00001c4a][0011300b][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD [00001c4d][00113007][00001c42] 51 push ecx ; DD
[00001c4e][00113003][00001c53] e80ff7ffff call 00001362 ; HH
New slave_stack at:14da47
[00001c42][0015da3b][0015da3f] 55 push ebp [00001c43][0015da3b][0015da3f] 8bec mov ebp,esp [00001c45][0015da37][0014da0b] 51 push ecx [00001c46][0015da37][0014da0b] 8b4508 mov eax,[ebp+08] ; DD [00001c49][0015da33][00001c42] 50 push eax ; DD
[00001c4a][0015da33][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD [00001c4d][0015da2f][00001c42] 51 push ecx ; DD
[00001c4e][0015da2b][00001c53] e80ff7ffff call 00001362 ; HH
Local Halt Decider: Recursion Simulation Detected Simulation Stopped
On 1/19/2024 8:39 PM, Richard Damon wrote:
On 1/19/24 9:08 PM, olcott wrote:
On 1/19/2024 7:58 PM, André G. Isaak wrote:
On 2024-01-19 18:26, olcott wrote:
The full state of D was repeated.
The only thing that changed was the stack address.
The contents of the stack and the stack address are *part* of the
state of the machine. If they change, you are not repeating the same
state.
André
Everything is identical across recursive simulations besides
the stack address. The stack address is irrelevant to whether
or not DD halts.
Nope, and part of the problem is you stopped looking at the actual
simulaiton of the input. The simulator being simulated at the first
call will be in a different state at the second call to H then it was
when it started, just like the outer HH doing the simulation has built
up the history shown.
That means that, if we continued an actual correct simulation of this
exact input (and thus didn't change HH, but gave the input to a proper
UTM simulator) we would see that the first simulated HH would run one
more level of simulation, and then abort its simulation, and then
return to DD and it would halt.
Thus, your simulation just isn't showing the actual "state" of the
program (in fact, you arn't even showing the state of the program,
since the key state for this program is what is happening in the HH
that DD is calling)
The "recursive" layer SHOULD be showing up as the instruction sequence
of the simulator simulating those instructions, and thus showing that
state being generated.
That second layer never actually shows as a direct simulation in the
proper simulation of the input, except maybe as interspresed comment
of the simulated HH just simulated this instruction.
If you are going to try to abstract out that simulation, you need to
do it properly, and that means that the simulation level IS part of
state.
The easily verified fact that DD simulated by HH cannot possibly
reach its own simulated final state conclusively proves that DD
does not halt.
No, that only hold *IF* HH correctly simulates the input, which means
that HH can NEVER abort its simulation.
Begin Local Halt Decider Simulation Execution Trace Stored >>> at:113027
[00001c42][00113013][00113017] 55 push ebp
[00001c43][00113013][00113017] 8bec mov ebp,esp
[00001c45][0011300f][00102fe3] 51 push ecx
[00001c46][0011300f][00102fe3] 8b4508 mov eax,[ebp+08] ; DD
[00001c49][0011300b][00001c42] 50 push eax ; DD
[00001c4a][0011300b][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD
[00001c4d][00113007][00001c42] 51 push ecx ; DD
[00001c4e][00113003][00001c53] e80ff7ffff call 00001362 ; HH
New slave_stack at:14da47
Note. error in simulation here. Call to HH should be showing the
states of operation of HH
Tell me how the behavior of HH can possibly show that
DD reaches its final state and I will provide a link
with the 151 pages of the execution trace of HH.
[00001c42][0015da3b][0015da3f] 55 push ebp
[00001c43][0015da3b][0015da3f] 8bec mov ebp,esp
[00001c45][0015da37][0014da0b] 51 push ecx
[00001c46][0015da37][0014da0b] 8b4508 mov eax,[ebp+08] ; DD
[00001c49][0015da33][00001c42] 50 push eax ; DD
[00001c4a][0015da33][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD
[00001c4d][0015da2f][00001c42] 51 push ecx ; DD
[00001c4e][0015da2b][00001c53] e80ff7ffff call 00001362 ; HH
Local Halt Decider: Recursion Simulation Detected Simulation Stopped
On 1/19/2024 9:13 PM, Richard Damon wrote:
On 1/19/24 9:55 PM, olcott wrote:
On 1/19/2024 8:39 PM, Richard Damon wrote:
On 1/19/24 9:08 PM, olcott wrote:
On 1/19/2024 7:58 PM, André G. Isaak wrote:
On 2024-01-19 18:26, olcott wrote:
The full state of D was repeated.
The only thing that changed was the stack address.
The contents of the stack and the stack address are *part* of the
state of the machine. If they change, you are not repeating the
same state.
André
Everything is identical across recursive simulations besides
the stack address. The stack address is irrelevant to whether
or not DD halts.
Nope, and part of the problem is you stopped looking at the actual
simulaiton of the input. The simulator being simulated at the first
call will be in a different state at the second call to H then it
was when it started, just like the outer HH doing the simulation has
built up the history shown.
That means that, if we continued an actual correct simulation of
this exact input (and thus didn't change HH, but gave the input to a
proper UTM simulator) we would see that the first simulated HH would
run one more level of simulation, and then abort its simulation, and
then return to DD and it would halt.
Thus, your simulation just isn't showing the actual "state" of the
program (in fact, you arn't even showing the state of the program,
since the key state for this program is what is happening in the HH
that DD is calling)
The "recursive" layer SHOULD be showing up as the instruction
sequence of the simulator simulating those instructions, and thus
showing that state being generated.
That second layer never actually shows as a direct simulation in the
proper simulation of the input, except maybe as interspresed comment
of the simulated HH just simulated this instruction.
If you are going to try to abstract out that simulation, you need to
do it properly, and that means that the simulation level IS part of
state.
The easily verified fact that DD simulated by HH cannot possibly
reach its own simulated final state conclusively proves that DD
does not halt.
No, that only hold *IF* HH correctly simulates the input, which
means that HH can NEVER abort its simulation.
Begin Local Halt Decider Simulation Execution Trace Stored >>>>> at:113027
[00001c42][00113013][00113017] 55 push ebp
[00001c43][00113013][00113017] 8bec mov ebp,esp
[00001c45][0011300f][00102fe3] 51 push ecx
[00001c46][0011300f][00102fe3] 8b4508 mov eax,[ebp+08] ; DD >>>>> [00001c49][0011300b][00001c42] 50 push eax ; DD
[00001c4a][0011300b][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD >>>>> [00001c4d][00113007][00001c42] 51 push ecx ; DD
[00001c4e][00113003][00001c53] e80ff7ffff call 00001362 ; HH >>>>> New slave_stack at:14da47
Note. error in simulation here. Call to HH should be showing the
states of operation of HH
Tell me how the behavior of HH can possibly show that
DD reaches its final state and I will provide a link
with the 151 pages of the execution trace of HH.
It can't in its simulation, but an actually correct simulation of the
input, which HH doesn't do, can.
*When I challenge you to show what the correct detailed*
*line-by-line machine address by machine address steps*
*SHOULD BE you consistently utterly fail because you really*
*don't know Jack about these things and are just bluffing*
Begin Local Halt Decider Simulation Execution Trace Stored at:113027
[00001c42][00113013][00113017] 55 push ebp [00001c43][00113013][00113017] 8bec mov ebp,esp [00001c45][0011300f][00102fe3] 51 push ecx [00001c46][0011300f][00102fe3] 8b4508 mov eax,[ebp+08] ; DD [00001c49][0011300b][00001c42] 50 push eax ; DD
[00001c4a][0011300b][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD [00001c4d][00113007][00001c42] 51 push ecx ; DD
[00001c4e][00113003][00001c53] e80ff7ffff call 00001362 ; HH
New slave_stack at:14da47
[00001c42][0015da3b][0015da3f] 55 push ebp [00001c43][0015da3b][0015da3f] 8bec mov ebp,esp [00001c45][0015da37][0014da0b] 51 push ecx [00001c46][0015da37][0014da0b] 8b4508 mov eax,[ebp+08] ; DD [00001c49][0015da33][00001c42] 50 push eax ; DD
[00001c4a][0015da33][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD [00001c4d][0015da2f][00001c42] 51 push ecx ; DD
[00001c4e][0015da2b][00001c53] e80ff7ffff call 00001362 ; HH
Local Halt Decider: Recursion Simulation Detected Simulation Stopped
_DD()
[00001c42] 55 push ebp
[00001c43] 8bec mov ebp,esp
[00001c45] 51 push ecx
[00001c46] 8b4508 mov eax,[ebp+08] ; DD
[00001c49] 50 push eax ; DD
[00001c4a] 8b4d08 mov ecx,[ebp+08] ; DD
[00001c4d] 51 push ecx ; DD
[00001c4e] e80ff7ffff call 00001362 ; HH
[00001c53] 83c408 add esp,+08
[00001c56] 8945fc mov [ebp-04],eax
[00001c59] 837dfc00 cmp dword [ebp-04],+00
[00001c5d] 7402 jz 00001c61
[00001c5f] ebfe jmp 00001c5f
[00001c61] 8b45fc mov eax,[ebp-04]
[00001c64] 8be5 mov esp,ebp
[00001c66] 5d pop ebp
[00001c67] c3 ret
Size in bytes:(0038) [00001c67]
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.
On 1/19/2024 5:03 PM, Richard Damon wrote:
On 1/19/24 5:29 PM, olcott wrote:
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.
On 1/19/2024 4:40 PM, immibis wrote:
On 1/19/24 23:22, olcott wrote:
On 1/19/2024 3:41 PM, immibis wrote:
On 1/19/24 22:12, 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.
Does the direct executed HH have the exact same instructions as each
simulated HH?
There is only one HH at machine address [00001032].
Does the direct executed HH have the exact same instructions as each
simulated HH?
There is only one HH at machine address [00001032].
There is only one HH at machine address [00001032].
There is only one HH at machine address [00001032].
There is only one HH at machine address [00001032].
There is only one HH at machine address [00001032].
You must have ADD like Richard. I have to repeat
things to Richard hundreds of times before he ever
notices that I said them once.
The full state of D was repeated.
The only thing that changed was the stack address.
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.
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.
On 1/19/2024 6:08 PM, Richard Damon wrote:
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.
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:
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
Op 20.jan.2024 om 01:36 schreef olcott:
On 1/19/2024 6:08 PM, Richard Damon wrote:
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.
It is not D that has a pathological self-reference. D has no
self-reference. It is H that has a self-reference. It uses its own address.
It is not D that contradicts itself. It is H that contradicts itself: At
the one hand it says that, when called, it has infinite recursion, but
at the other hand it aborts and returns a result, which is a contradiction.
Olcott wants to reject self-referencing contradictions, so he should
reject H, not D.
On 1/19/2024 10:07 PM, Richard Damon wrote:
On 1/19/24 10:28 PM, olcott wrote:Trump is a Hitler wanna bee.
On 1/19/2024 9:13 PM, Richard Damon wrote:
On 1/19/24 9:55 PM, olcott wrote:
On 1/19/2024 8:39 PM, Richard Damon wrote:
On 1/19/24 9:08 PM, olcott wrote:
On 1/19/2024 7:58 PM, André G. Isaak wrote:
On 2024-01-19 18:26, olcott wrote:
The full state of D was repeated.
The only thing that changed was the stack address.
The contents of the stack and the stack address are *part* of
the state of the machine. If they change, you are not repeating >>>>>>>> the same state.
André
Everything is identical across recursive simulations besides
the stack address. The stack address is irrelevant to whether
or not DD halts.
Nope, and part of the problem is you stopped looking at the actual >>>>>> simulaiton of the input. The simulator being simulated at the
first call will be in a different state at the second call to H
then it was when it started, just like the outer HH doing the
simulation has built up the history shown.
That means that, if we continued an actual correct simulation of
this exact input (and thus didn't change HH, but gave the input to >>>>>> a proper UTM simulator) we would see that the first simulated HH
would run one more level of simulation, and then abort its
simulation, and then return to DD and it would halt.
Thus, your simulation just isn't showing the actual "state" of the >>>>>> program (in fact, you arn't even showing the state of the program, >>>>>> since the key state for this program is what is happening in the
HH that DD is calling)
The "recursive" layer SHOULD be showing up as the instruction
sequence of the simulator simulating those instructions, and thus
showing that state being generated.
That second layer never actually shows as a direct simulation in
the proper simulation of the input, except maybe as interspresed
comment of the simulated HH just simulated this instruction.
If you are going to try to abstract out that simulation, you need
to do it properly, and that means that the simulation level IS
part of state.
The easily verified fact that DD simulated by HH cannot possibly >>>>>>> reach its own simulated final state conclusively proves that DD
does not halt.
No, that only hold *IF* HH correctly simulates the input, which
means that HH can NEVER abort its simulation.
Begin Local Halt Decider Simulation Execution Trace Stored
at:113027
[00001c42][00113013][00113017] 55 push ebp
[00001c43][00113013][00113017] 8bec mov ebp,esp
[00001c45][0011300f][00102fe3] 51 push ecx
[00001c46][0011300f][00102fe3] 8b4508 mov eax,[ebp+08] ; DD >>>>>>> [00001c49][0011300b][00001c42] 50 push eax ; DD
[00001c4a][0011300b][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD >>>>>>> [00001c4d][00113007][00001c42] 51 push ecx ; DD
[00001c4e][00113003][00001c53] e80ff7ffff call 00001362 ; HH >>>>>>> New slave_stack at:14da47
Note. error in simulation here. Call to HH should be showing the
states of operation of HH
Tell me how the behavior of HH can possibly show that
DD reaches its final state and I will provide a link
with the 151 pages of the execution trace of HH.
It can't in its simulation, but an actually correct simulation of
the input, which HH doesn't do, can.
*When I challenge you to show what the correct detailed*
*line-by-line machine address by machine address steps*
*SHOULD BE you consistently utterly fail because you really*
*don't know Jack about these things and are just bluffing*
i.e. I'm not falling for your strawman and are panicing as badly as
your buddy Trump.
*You failed try again*
I show 16 lines of machine code
*you must show ever detail of your corrected machine code*
*This must include the machine address and the assembly language*
*OR YOU FAIL*
*OR YOU FAIL*
*OR YOU FAIL*
*OR YOU FAIL*
*When I challenge you to show what the correct detailed*
*line-by-line machine address by machine address steps*
*SHOULD BE you consistently utterly fail because you really*
*don't know Jack about these things and are just bluffing*
Begin Local Halt Decider Simulation Execution Trace Stored at:113027
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= [00001c42][00113013][00113017] 55 push ebp [00001c43][00113013][00113017] 8bec mov ebp,esp [00001c45][0011300f][00102fe3] 51 push ecx [00001c46][0011300f][00102fe3] 8b4508 mov eax,[ebp+08] ; DD [00001c49][0011300b][00001c42] 50 push eax ; DD
[00001c4a][0011300b][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD [00001c4d][00113007][00001c42] 51 push ecx ; DD
[00001c4e][00113003][00001c53] e80ff7ffff call 00001362 ; HH
New slave_stack at:14da47
[00001c42][0015da3b][0015da3f] 55 push ebp [00001c43][0015da3b][0015da3f] 8bec mov ebp,esp [00001c45][0015da37][0014da0b] 51 push ecx [00001c46][0015da37][0014da0b] 8b4508 mov eax,[ebp+08] ; DD [00001c49][0015da33][00001c42] 50 push eax ; DD
[00001c4a][0015da33][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD [00001c4d][0015da2f][00001c42] 51 push ecx ; DD
[00001c4e][0015da2b][00001c53] e80ff7ffff call 00001362 ; HH
Local Halt Decider: Recursion Simulation Detected Simulation Stopped
_DD()
[00001c42] 55 push ebp
[00001c43] 8bec mov ebp,esp
[00001c45] 51 push ecx
[00001c46] 8b4508 mov eax,[ebp+08] ; DD
[00001c49] 50 push eax ; DD
[00001c4a] 8b4d08 mov ecx,[ebp+08] ; DD
[00001c4d] 51 push ecx ; DD
[00001c4e] e80ff7ffff call 00001362 ; HH
[00001c53] 83c408 add esp,+08
[00001c56] 8945fc mov [ebp-04],eax
[00001c59] 837dfc00 cmp dword [ebp-04],+00
[00001c5d] 7402 jz 00001c61
[00001c5f] ebfe jmp 00001c5f
[00001c61] 8b45fc mov eax,[ebp-04]
[00001c64] 8be5 mov esp,ebp
[00001c66] 5d pop ebp
[00001c67] c3 ret
Size in bytes:(0038) [00001c67]
On 1/20/2024 4:41 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> 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:
[ .... ]
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
It's like the good professor agreeing that if pigs had wings,
they would fly.
Not at all. He would not risk his credibility that way.
He gave me permission to quote him.
And you're taking that as a license to discuss the pigs' flying
techniques, their lift to drag ratio, and so on. In reality pigs don't
have wings, and they certainly don't fly.
Professor Sipser said what he had to say to avoid getting drawn into an
interminable time wasting exchange with a crank. He's got other things
to do.
I told him that I waited two years before I first called him
so that I did not waste his time. He agreed that I could
quote him, he would not have done that if he thought what
he was agreeing to was nonsense.
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"
Yes. But you haven't yet noticed that little word "if" at the beginning
of his sentence. There is no such thing as a halt decider, simulating or
otherwise, so you could just as well write "If simulating halt decider H
correctly simulates its input D, then pigs would fly.", and it would be
just as true. But just as meaningless and not at all sensible.
Technically in my case it is a partial halt decider or a termination analyzer.
Professor Sipser knew that he was only agreeing that a specific H/D
pair would be decidable as non-halting when the criteria has been met.
Here is my updated paraphrase of (a)
(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
--
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/20/2024 9:43 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 4:41 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> 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:
[ .... ]
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
It's like the good professor agreeing that if pigs had wings,
they would fly.
Not at all. He would not risk his credibility that way.
He gave me permission to quote him.
He would not be risking his credibility.
(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.
That you do not understand that the above is correct proves
that you are insufficiently competent to review my work.
There has been a very extensive reviews of this in comp.theory back in 10/13/2022. You can go see what many other people have said. It was
resolved that Professor Sipser really meant to agree with these words.
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.
--
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/20/2024 4:04 AM, immibis wrote:
On 1/20/24 02:26, olcott wrote:
You think the stack address doesn't matter?
The full state of D was repeated.
The only thing that changed was the stack address.
That each process context has its own stack cannot possibly
have any effect on the halt status determination.
That you don't know this proves that you are insufficiently
technically competent to review my work.
On 1/20/2024 4:04 AM, immibis wrote:
On 1/20/24 01:55, olcott wrote:
Begin Local Halt Decider Simulation Execution Trace Stored >>> at:113027
[00001c42][00113013][00113017] 55 push ebp
[00001c43][00113013][00113017] 8bec mov ebp,esp
[00001c45][0011300f][00102fe3] 51 push ecx
[00001c46][0011300f][00102fe3] 8b4508 mov eax,[ebp+08] ; DD
[00001c49][0011300b][00001c42] 50 push eax ; DD
[00001c4a][0011300b][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD
[00001c4d][00113007][00001c42] 51 push ecx ; DD
[00001c4e][00113003][00001c53] e80ff7ffff call 00001362 ; HH
New slave_stack at:14da47
[00001c42][0015da3b][0015da3f] 55 push ebp
[00001c43][0015da3b][0015da3f] 8bec mov ebp,esp
[00001c45][0015da37][0014da0b] 51 push ecx
[00001c46][0015da37][0014da0b] 8b4508 mov eax,[ebp+08] ; DD
[00001c49][0015da33][00001c42] 50 push eax ; DD
[00001c4a][0015da33][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD
[00001c4d][0015da2f][00001c42] 51 push ecx ; DD
[00001c4e][0015da2b][00001c53] e80ff7ffff call 00001362 ; HH
Local Halt Decider: Recursion Simulation Detected Simulation Stopped
That you cannot tell that the above specifies
non-halting behavior makes you a dunderhead.
This trace dishonestly ignores the instructions that tell HH to check
for non-halting repeated patterns.
Nothing that HH can possibly do can cause DD correctly
simulated by HH to reach its own simulated final state.
*That is the strawman deception and you know it*
You claimed that he agreed with nonsense
and this
is provably false. He agreed that my verbatim
words are correct. He did not agree with nonsense.
On 1/20/2024 4:41 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
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
It's like the good professor agreeing that if pigs had wings, they
would fly.
Not at all. He would not risk his credibility that way.
He gave me permission to quote him.
Yes. But you haven't yet noticed that little word "if" at the beginning
of his sentence. There is no such thing as a halt decider, simulating or >> otherwise, so you could just as well write "If simulating halt decider H
correctly simulates its input D, then pigs would fly.", and it would be
just as true. But just as meaningless and not at all sensible.
Technically in my case it is a partial halt decider or a termination analyzer. Professor Sipser knew that he was only agreeing that a
specific H/D pair would be decidable as non-halting when the criteria
has been met.
Here is my updated paraphrase of (a)
(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
--
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/20/2024 4:01 AM, immibis wrote:
On 1/19/24 23:46, olcott wrote:
On 1/19/2024 4:40 PM, immibis wrote:
On 1/19/24 23:22, olcott wrote:
On 1/19/2024 3:41 PM, immibis wrote:
On 1/19/24 22:12, 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.
Does the direct executed HH have the exact same instructions as
each simulated HH?
There is only one HH at machine address [00001032].
Does the direct executed HH have the exact same instructions as each
simulated HH?
There is only one HH at machine address [00001032].
There is only one HH at machine address [00001032].
There is only one HH at machine address [00001032].
There is only one HH at machine address [00001032].
There is only one HH at machine address [00001032].
You must have ADD like Richard. I have to repeat
things to Richard hundreds of times before he ever
notices that I said them once.
Why can't you answer the question?
I answered the question with all of the technical details
that prove the answer. If there is only one thing in the
universe then is this thing different than itself?
There is only one HH in Halt7.c and it is never copied.
On 1/20/2024 10:26 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 9:43 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 4:41 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> 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:
[ .... ]
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
It's like the good professor agreeing that if pigs had wings,
they would fly.
Not at all. He would not risk his credibility that way.
He gave me permission to quote him.
He would not be risking his credibility.
You've got no reply to this, I see.
(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.
That you do not understand that the above is correct proves
that you are insufficiently competent to review my work.
I understand it fully, thank you very much. You fail to understand it.
If I write "if I correctly state that pigs can fly, then bacon will
correctly go up", then that is the truth, just as much as your (a). It's
inane nonsense, of course, just as your (a) is nonsense.
There has been a very extensive reviews of this in comp.theory back in
10/13/2022. You can go see what many other people have said. It was
resolved that Professor Sipser really meant to agree with these words.
I read, or at least perused, it at the time. The resolution certainly
was not that Professor Sipser likely agreed with what you would
like him to agree with.
*That is the strawman deception and you know it*
You claimed that he agreed with nonsense and this is provably false.
He agreed that my verbatim words are correct. He did not agree with
nonsense.
--
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/20/2024 9:43 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 4:41 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> 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:
[ .... ]
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
It's like the good professor agreeing that if pigs had wings,
they would fly.
Not at all. He would not risk his credibility that way.
He gave me permission to quote him.
He would not be risking his credibility.
(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.
That you do not understand that the above is correct proves
that you are insufficiently competent to review my work.
There has been a very extensive reviews of this in
comp.theory back in 10/13/2022. You can go see what
many other people have said. It was resolved that
Professor Sipser really meant to agree with these
words.
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.
On 1/20/2024 11:23 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 10:26 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 9:43 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 4:41 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> 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:
[ .... ]
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
It's like the good professor agreeing that if pigs had wings,
they would fly.
Not at all. He would not risk his credibility that way.
He gave me permission to quote him.
He would not be risking his credibility.
You've got no reply to this, I see.
You've still got no reply.
(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.
That you do not understand that the above is correct proves
that you are insufficiently competent to review my work.
I understand it fully, thank you very much. You fail to understand it. >>>> If I write "if I correctly state that pigs can fly, then bacon will
correctly go up", then that is the truth, just as much as your (a).
It's
inane nonsense, of course, just as your (a) is nonsense.
There has been a very extensive reviews of this in comp.theory back in >>>>> 10/13/2022. You can go see what many other people have said. It was
resolved that Professor Sipser really meant to agree with these words.
I read, or at least perused, it at the time. The resolution certainly >>>> was not that Professor Sipser likely agreed with what you would
like him to agree with.
*That is the strawman deception and you know it*
That's an unwarranted insult. It was what I surmised from those
exchanges at the time. You likely have a different impression of them,
just as you have different impressions of lots of things you post here.
You claimed that he agreed with nonsense and this is provably false.
He agreed that my verbatim words are correct. He did not agree with
nonsense.
He both agreed that your verbatim words were correct and agreed with
nonsense. Those words, although pedantically true, _are_ inane nonsense,
The consensus of opinion at the time was that he
agreed to those literal words and those literal
words were correct thus not nonsense, thus yet
again the strawman deception on your part.
On 1/20/2024 11:10 AM, immibis wrote:
On 1/20/24 16:38, olcott wrote:
On 1/20/2024 4:04 AM, immibis wrote:
On 1/20/24 01:55, olcott wrote:
Begin Local Halt Decider Simulation Execution Trace Stored >>>>> at:113027
[00001c42][00113013][00113017] 55 push ebp
[00001c43][00113013][00113017] 8bec mov ebp,esp
[00001c45][0011300f][00102fe3] 51 push ecx
[00001c46][0011300f][00102fe3] 8b4508 mov eax,[ebp+08] ; DD >>>>> [00001c49][0011300b][00001c42] 50 push eax ; DD
[00001c4a][0011300b][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD >>>>> [00001c4d][00113007][00001c42] 51 push ecx ; DD
[00001c4e][00113003][00001c53] e80ff7ffff call 00001362 ; HH >>>>> New slave_stack at:14da47
[00001c42][0015da3b][0015da3f] 55 push ebp
[00001c43][0015da3b][0015da3f] 8bec mov ebp,esp
[00001c45][0015da37][0014da0b] 51 push ecx
[00001c46][0015da37][0014da0b] 8b4508 mov eax,[ebp+08] ; DD >>>>> [00001c49][0015da33][00001c42] 50 push eax ; DD
[00001c4a][0015da33][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD >>>>> [00001c4d][0015da2f][00001c42] 51 push ecx ; DD
[00001c4e][0015da2b][00001c53] e80ff7ffff call 00001362 ; HH >>>>> Local Halt Decider: Recursion Simulation Detected Simulation Stopped >>>>>
That you cannot tell that the above specifies
non-halting behavior makes you a dunderhead.
This trace dishonestly ignores the instructions that tell HH to
check for non-halting repeated patterns.
Nothing that HH can possibly do can cause DD correctly
simulated by HH to reach its own simulated final state.
HH detects a non-halting pattern and returns 0, which causes DD to
reach its final state.
DD keeps HH stuck in recursive simulation until HH sees this
and aborts its simulation
On 1/20/2024 11:20 AM, immibis wrote:
On 1/20/24 16:25, olcott wrote:
On 1/20/2024 4:01 AM, immibis wrote:IF they are the same thing (whatever that means) then I am sure you
On 1/19/24 23:46, olcott wrote:
On 1/19/2024 4:40 PM, immibis wrote:
On 1/19/24 23:22, olcott wrote:
On 1/19/2024 3:41 PM, immibis wrote:
On 1/19/24 22:12, 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.
Does the direct executed HH have the exact same instructions as >>>>>>>> each simulated HH?
There is only one HH at machine address [00001032].
Does the direct executed HH have the exact same instructions as
each simulated HH?
There is only one HH at machine address [00001032].
There is only one HH at machine address [00001032].
There is only one HH at machine address [00001032].
There is only one HH at machine address [00001032].
There is only one HH at machine address [00001032].
You must have ADD like Richard. I have to repeat
things to Richard hundreds of times before he ever
notices that I said them once.
Why can't you answer the question?
I answered the question with all of the technical details
that prove the answer. If there is only one thing in the
universe then is this thing different than itself?
There is only one HH in Halt7.c and it is never copied.
agree they have the exact same instructions?
You did not seem to understand that a thing is necessarily the same as itself.
On 1/20/2024 11:11 AM, immibis wrote:
On 1/20/24 16:56, olcott wrote:
On 1/20/2024 4:07 AM, immibis wrote:Nonetheless, it is a verified fact that a Turing machine/initial tape
On 1/20/24 01:36, olcott wrote:
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.
A Turing machine/initial tape pair has only one execution sequence.
The Peter Linz Proof version of H1 is called H.
The Peter Linz Proof version of H is called embedded_H.
Because ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
reach its own simulated final state of ⟨Ĥ.qn⟩ and halt
embedded_H correctly transitions to its own final state of Ĥ.qn.
When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
(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
pair has only one execution sequence.
(a) embedded_H applied ⟨Ĥ⟩ ⟨Ĥ⟩
has a different execution sequence than
(b) H applied ⟨Ĥ⟩ ⟨Ĥ⟩
On 1/20/2024 11:17 AM, immibis wrote:
On 1/20/24 15:59, olcott wrote:
On 1/20/2024 4:41 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
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
It's like the good professor agreeing that if pigs had wings, they
would fly.
Not at all. He would not risk his credibility that way.
He gave me permission to quote him.
There is no risk to your credibility by saying that if pigs had wings,
they would fly. It is most likely true that if pigs had wings, they
would fly. However, pigs do not have wings, and simulating halt
decider H does not correctly simulate its input until H correctly
determines that its simulated D would never stop running unless aborted.
Yes. But you haven't yet noticed that little word "if" at the
beginning
of his sentence. There is no such thing as a halt decider,
simulating or
otherwise, so you could just as well write "If simulating halt
decider H
correctly simulates its input D, then pigs would fly.", and it would be >>>> just as true. But just as meaningless and not at all sensible.
Technically in my case it is a partial halt decider or a termination
analyzer. Professor Sipser knew that he was only agreeing that a
specific H/D pair would be decidable as non-halting when the criteria
has been met.
It gives the wrong answer on the program it's designed to give a right
answer for.
Here is my updated paraphrase of (a)
(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
That's the same thing. It doesn't matter whether you call it a halt
decider or a termination analyzer. Those are two different names for
the same thing and H does not correctly determine that D correctly
simulated by H cannot possibly reach its own simulated final state and
terminate normally.
The consensus of opinion at the time was that Professor
Sipser agreed with my words and my words are correct.
The two objections were:
(a) My own words do not mean what I think they mean.
(b) DD is not correctly simulated by HH.
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.
On 1/20/2024 11:11 AM, immibis wrote:
On 1/20/24 16:43, olcott wrote:
On 1/20/2024 4:04 AM, immibis wrote:
On 1/20/24 02:26, olcott wrote:
You think the stack address doesn't matter?
The full state of D was repeated.
The only thing that changed was the stack address.
That each process context has its own stack cannot possibly
have any effect on the halt status determination.
That you don't know this proves that you are insufficiently
technically competent to review my work.
You keep saying the code address matters even if the code at that
address is identical.
By the same logic the stack address matters, even if the data on the
stack is identical.
That is not the same logic. Why do you insist
on relying on your own ignorance as a basis?
On 1/20/2024 11:10 AM, immibis wrote:
On 1/20/24 16:38, olcott wrote:
On 1/20/2024 4:04 AM, immibis wrote:
On 1/20/24 01:55, olcott wrote:
Begin Local Halt Decider Simulation Execution Trace Stored >>>>> at:113027
[00001c42][00113013][00113017] 55 push ebp
[00001c43][00113013][00113017] 8bec mov ebp,esp
[00001c45][0011300f][00102fe3] 51 push ecx
[00001c46][0011300f][00102fe3] 8b4508 mov eax,[ebp+08] ; DD >>>>> [00001c49][0011300b][00001c42] 50 push eax ; DD
[00001c4a][0011300b][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD >>>>> [00001c4d][00113007][00001c42] 51 push ecx ; DD
[00001c4e][00113003][00001c53] e80ff7ffff call 00001362 ; HH >>>>> New slave_stack at:14da47
[00001c42][0015da3b][0015da3f] 55 push ebp
[00001c43][0015da3b][0015da3f] 8bec mov ebp,esp
[00001c45][0015da37][0014da0b] 51 push ecx
[00001c46][0015da37][0014da0b] 8b4508 mov eax,[ebp+08] ; DD >>>>> [00001c49][0015da33][00001c42] 50 push eax ; DD
[00001c4a][0015da33][00001c42] 8b4d08 mov ecx,[ebp+08] ; DD >>>>> [00001c4d][0015da2f][00001c42] 51 push ecx ; DD
[00001c4e][0015da2b][00001c53] e80ff7ffff call 00001362 ; HH >>>>> Local Halt Decider: Recursion Simulation Detected Simulation Stopped >>>>>
That you cannot tell that the above specifies
non-halting behavior makes you a dunderhead.
This trace dishonestly ignores the instructions that tell HH to
check for non-halting repeated patterns.
Nothing that HH can possibly do can cause DD correctly
simulated by HH to reach its own simulated final state.
HH detects a non-halting pattern and returns 0, which causes DD to
reach its final state.
DD keeps HH stuck in recursive simulation until HH sees this
and aborts its simulation making it impossible for any simulated
HH to return any value to a simulated DD.
If you were an expert in the C programming language this
would be dead obvious to you. That you disagree on the basis
of your ignorance cannot possibly be a valid rebuttal.
On 1/20/2024 11:11 AM, immibis wrote:
On 1/20/24 16:56, olcott wrote:
On 1/20/2024 4:07 AM, immibis wrote:Nonetheless, it is a verified fact that a Turing machine/initial tape
On 1/20/24 01:36, olcott wrote:
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.
A Turing machine/initial tape pair has only one execution sequence.
The Peter Linz Proof version of H1 is called H.
The Peter Linz Proof version of H is called embedded_H.
Because ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
reach its own simulated final state of ⟨Ĥ.qn⟩ and halt
embedded_H correctly transitions to its own final state of Ĥ.qn.
When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
(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
pair has only one execution sequence.
(a) embedded_H applied ⟨Ĥ⟩ ⟨Ĥ⟩
has a different execution sequence than
(b) H applied ⟨Ĥ⟩ ⟨Ĥ⟩
(c) D correctly simulated by H
has a different execution sequence than
(d) D correctly simulated by H1
The only salient difference between (a) and (b)
and (c) and (d) is that in the first element of
the pair the input calls its own decider and the
second element of the pair the input does not
call its own decider.
On 1/20/2024 11:23 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 10:26 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
(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.
That you do not understand that the above is correct proves that
you are insufficiently competent to review my work.
I understand it fully, thank you very much. You fail to understand
it. If I write "if I correctly state that pigs can fly, then bacon
will correctly go up", then that is the truth, just as much as your
(a). It's inane nonsense, of course, just as your (a) is nonsense.
There has been a very extensive reviews of this in comp.theory back
in 10/13/2022. You can go see what many other people have said. It
was resolved that Professor Sipser really meant to agree with these
words.
I read, or at least perused, it at the time. The resolution
certainly was not that Professor Sipser likely agreed with what you
would like him to agree with.
*That is the strawman deception and you know it*
That's an unwarranted insult. It was what I surmised from those
exchanges at the time. You likely have a different impression of them,
just as you have different impressions of lots of things you post here.
You claimed that he agreed with nonsense and this is provably false.
He agreed that my verbatim words are correct. He did not agree with
nonsense.
He both agreed that your verbatim words were correct and agreed with
nonsense. Those words, although pedantically true, _are_ inane
nonsense,
The consensus of opinion at the time was that he agreed to those
literal words and those literal words were correct thus not nonsense,
thus yet again the strawman deception on your part.
--
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/20/2024 4:10 PM, Alan Mackenzie wrote:
It's not a matter of opinion, it's a matter of analysing these words,
which I have done, and you have not. "If I correctly state that pigs can >> fly, then bacon will correctly go up." is a sentence of the same form as
your (a). They are both vacuous nonsense.
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.
After careful review by many people it was agreed that the
above words are true and correct and thus not vacuous nonsense.
No one even hinted that Professor Sipser agreed to vacuous nonsense.
When this possibility was proposed it was rejected.
On 1/20/2024 4:10 PM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 11:23 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 10:26 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
(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.
That you do not understand that the above is correct proves that >>>>>>> you are insufficiently competent to review my work.
I understand it fully, thank you very much. You fail to understand >>>>>> it. If I write "if I correctly state that pigs can fly, then bacon >>>>>> will correctly go up", then that is the truth, just as much as your >>>>>> (a). It's inane nonsense, of course, just as your (a) is nonsense.
There has been a very extensive reviews of this in comp.theory back >>>>>>> in 10/13/2022. You can go see what many other people have said. It >>>>>>> was resolved that Professor Sipser really meant to agree with these >>>>>>> words.
I read, or at least perused, it at the time. The resolution
certainly was not that Professor Sipser likely agreed with what you >>>>>> would like him to agree with.
*That is the strawman deception and you know it*
That's an unwarranted insult. It was what I surmised from those
exchanges at the time. You likely have a different impression of them, >>>> just as you have different impressions of lots of things you post here.
You claimed that he agreed with nonsense and this is provably false. >>>>> He agreed that my verbatim words are correct. He did not agree with
nonsense.
He both agreed that your verbatim words were correct and agreed with
nonsense. Those words, although pedantically true, _are_ inane
nonsense,
The consensus of opinion at the time was that he agreed to those
literal words and those literal words were correct thus not nonsense,
thus yet again the strawman deception on your part.
It's not a matter of opinion, it's a matter of analysing these words,
which I have done, and you have not. "If I correctly state that pigs can
fly, then bacon will correctly go up." is a sentence of the same form as
your (a). They are both vacuous nonsense.
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.
After careful review by many people it was agreed that the
above words are true and correct and thus not vacuous nonsense.
No one even hinted that Professor Sipser agreed to vacuous nonsense.
When this possibility was proposed it was rejected.
--
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/20/2024 4:45 PM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 4:10 PM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 11:23 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 10:26 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
(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.
That you do not understand that the above is correct proves that >>>>>>>>> you are insufficiently competent to review my work.
I understand it fully, thank you very much. You fail to understand >>>>>>>> it. If I write "if I correctly state that pigs can fly, then bacon >>>>>>>> will correctly go up", then that is the truth, just as much as your >>>>>>>> (a). It's inane nonsense, of course, just as your (a) is nonsense.
There has been a very extensive reviews of this in comp.theory back >>>>>>>>> in 10/13/2022. You can go see what many other people have said. It >>>>>>>>> was resolved that Professor Sipser really meant to agree with these >>>>>>>>> words.
I read, or at least perused, it at the time. The resolution
certainly was not that Professor Sipser likely agreed with what you >>>>>>>> would like him to agree with.
*That is the strawman deception and you know it*
That's an unwarranted insult. It was what I surmised from those
exchanges at the time. You likely have a different impression of them, >>>>>> just as you have different impressions of lots of things you post here.
You claimed that he agreed with nonsense and this is provably false. >>>>>>> He agreed that my verbatim words are correct. He did not agree with >>>>>>> nonsense.
He both agreed that your verbatim words were correct and agreed with >>>>>> nonsense. Those words, although pedantically true, _are_ inane
nonsense,
The consensus of opinion at the time was that he agreed to those
literal words and those literal words were correct thus not nonsense, >>>>> thus yet again the strawman deception on your part.
It's not a matter of opinion, it's a matter of analysing these words,
which I have done, and you have not. "If I correctly state that pigs can >>>> fly, then bacon will correctly go up." is a sentence of the same form as >>>> your (a). They are both vacuous nonsense.
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.
After careful review by many people it was agreed that the
above words are true and correct and thus not vacuous nonsense.
The only careful review done appears to be mine.
No one even hinted that Professor Sipser agreed to vacuous nonsense.
When this possibility was proposed it was rejected.
I can't accept this.
Go look at the posts, I gave you the dates: 10/13/2022 11:46 AM
--
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/20/2024 4:45 PM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 4:10 PM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 11:23 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
On 1/20/2024 10:26 AM, Alan Mackenzie wrote:
In comp.theory olcott <polcott2@gmail.com> wrote:
(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.
That you do not understand that the above is correct proves that >>>>>>>>> you are insufficiently competent to review my work.
I understand it fully, thank you very much. You fail to understand >>>>>>>> it. If I write "if I correctly state that pigs can fly, then bacon >>>>>>>> will correctly go up", then that is the truth, just as much as your >>>>>>>> (a). It's inane nonsense, of course, just as your (a) is nonsense.
There has been a very extensive reviews of this in comp.theory back >>>>>>>>> in 10/13/2022. You can go see what many other people have said. It >>>>>>>>> was resolved that Professor Sipser really meant to agree with these >>>>>>>>> words.
I read, or at least perused, it at the time. The resolution
certainly was not that Professor Sipser likely agreed with what you >>>>>>>> would like him to agree with.
*That is the strawman deception and you know it*
That's an unwarranted insult. It was what I surmised from those
exchanges at the time. You likely have a different impression of them, >>>>>> just as you have different impressions of lots of things you post here.
You claimed that he agreed with nonsense and this is provably false. >>>>>>> He agreed that my verbatim words are correct. He did not agree with >>>>>>> nonsense.
He both agreed that your verbatim words were correct and agreed with >>>>>> nonsense. Those words, although pedantically true, _are_ inane
nonsense,
The consensus of opinion at the time was that he agreed to those
literal words and those literal words were correct thus not nonsense, >>>>> thus yet again the strawman deception on your part.
It's not a matter of opinion, it's a matter of analysing these words,
which I have done, and you have not. "If I correctly state that pigs can >>>> fly, then bacon will correctly go up." is a sentence of the same form as >>>> your (a). They are both vacuous nonsense.
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.
After careful review by many people it was agreed that the
above words are true and correct and thus not vacuous nonsense.
The only careful review done appears to be mine.
No one even hinted that Professor Sipser agreed to vacuous nonsense.
When this possibility was proposed it was rejected.
I can't accept this.
*Here it is*
On 10/13/2022 1:53 PM, Ben Bacarisse wrote:
Jeff Barnett <jbb@notatt.com> writes:
Isn't the "brushoff with implied agreement" a method to decrank one's
mailbox that was mentioned in Dudley's "The Trisectors"? Can't find
my copy to check it out.
No, I think Dudley explicitly says not to do that. His two
recommendations are to be flattering while plainly pointing out the
error in the end result without engaging with the argument in any way.
--
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/20/2024 4:34 PM, immibis wrote:
On 1/20/24 23:21, olcott wrote:
On 1/20/2024 4:10 PM, Alan Mackenzie wrote:
It's not a matter of opinion, it's a matter of analysing these words,
which I have done, and you have not. "If I correctly state that
pigs can
fly, then bacon will correctly go up." is a sentence of the same
form as
your (a). They are both vacuous nonsense.
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.
After careful review by many people it was agreed that the
above words are true and correct and thus not vacuous nonsense.
No one even hinted that Professor Sipser agreed to vacuous nonsense.
When this possibility was proposed it was rejected.
You don't understand what Alan just said.
You and Alan don't seem to know the difference between
vacuous truths:
(a) All the living T-rexes in my living room have orange and blue stripes
and Non vacuous truths:
(b) 2 + 3 = 5.
On 1/20/2024 4:34 PM, immibis wrote:
On 1/20/24 23:21, olcott wrote:
On 1/20/2024 4:10 PM, Alan Mackenzie wrote:
It's not a matter of opinion, it's a matter of analysing these words,
which I have done, and you have not. "If I correctly state that
pigs can
fly, then bacon will correctly go up." is a sentence of the same
form as
your (a). They are both vacuous nonsense.
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.
After careful review by many people it was agreed that the
above words are true and correct and thus not vacuous nonsense.
No one even hinted that Professor Sipser agreed to vacuous nonsense.
When this possibility was proposed it was rejected.
You don't understand what Alan just said.
You and Alan don't seem to know the difference between
vacuous truths:
(a) All the living T-rexes in my living room have orange and blue stripes
and Non vacuous truths:
(b) 2 + 3 = 5.
On 1/20/2024 6:11 PM, immibis wrote:
On 1/21/24 00:26, olcott wrote:
On 1/20/2024 4:34 PM, immibis wrote:
On 1/20/24 23:21, olcott wrote:
On 1/20/2024 4:10 PM, Alan Mackenzie wrote:
It's not a matter of opinion, it's a matter of analysing these words, >>>>>> which I have done, and you have not. "If I correctly state that
pigs can
fly, then bacon will correctly go up." is a sentence of the same
form as
your (a). They are both vacuous nonsense.
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.
After careful review by many people it was agreed that the
above words are true and correct and thus not vacuous nonsense.
No one even hinted that Professor Sipser agreed to vacuous nonsense. >>>>> When this possibility was proposed it was rejected.
You don't understand what Alan just said.
You and Alan don't seem to know the difference between
vacuous truths:
(a) All the living T-rexes in my living room have orange and blue
stripes
and Non vacuous truths:
(b) 2 + 3 = 5.
You don't seem to know the difference between vacuous truths:
(a) All the simulating halt deciders that correctly determine that
their simulated input would never stop running unless aborted can
abort their simulations and correctly report that they specify a
non-halting sequence of configurations.
and Non vacuous truths:
(b) There is a keyboard on my desk.
Simulating termination analyzer is a more accurate term
because it is only required to get at least one input
correctly.
On 1/20/2024 6:54 PM, immibis wrote:
On 1/21/24 01:20, olcott wrote:
On 1/20/2024 6:11 PM, immibis wrote:
On 1/21/24 00:26, olcott wrote:
On 1/20/2024 4:34 PM, immibis wrote:
On 1/20/24 23:21, olcott wrote:
On 1/20/2024 4:10 PM, Alan Mackenzie wrote:
It's not a matter of opinion, it's a matter of analysing these >>>>>>>> words,
which I have done, and you have not. "If I correctly state that >>>>>>>> pigs can
fly, then bacon will correctly go up." is a sentence of the same >>>>>>>> form as
your (a). They are both vacuous nonsense.
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.
After careful review by many people it was agreed that the
above words are true and correct and thus not vacuous nonsense.
No one even hinted that Professor Sipser agreed to vacuous nonsense. >>>>>>> When this possibility was proposed it was rejected.
You don't understand what Alan just said.
You and Alan don't seem to know the difference between
vacuous truths:
(a) All the living T-rexes in my living room have orange and blue
stripes
and Non vacuous truths:
(b) 2 + 3 = 5.
You don't seem to know the difference between vacuous truths:
(a) All the simulating halt deciders that correctly determine that
their simulated input would never stop running unless aborted can
abort their simulations and correctly report that they specify a
non-halting sequence of configurations.
and Non vacuous truths:
(b) There is a keyboard on my desk.
Simulating termination analyzer is a more accurate term
because it is only required to get at least one input
correctly.
It does get at least one input correctly. But not D. It gets D wrong.
That proves that simulating halt decider is not a vacuous term.
On 1/21/2024 5:16 AM, immibis wrote:
On 1/21/24 02:00, olcott wrote:
On 1/20/2024 6:54 PM, immibis wrote:
On 1/21/24 01:20, olcott wrote:
On 1/20/2024 6:11 PM, immibis wrote:
On 1/21/24 00:26, olcott wrote:
On 1/20/2024 4:34 PM, immibis wrote:
On 1/20/24 23:21, olcott wrote:
On 1/20/2024 4:10 PM, Alan Mackenzie wrote:
It's not a matter of opinion, it's a matter of analysing these >>>>>>>>>> words,
which I have done, and you have not. "If I correctly state >>>>>>>>>> that pigs can
fly, then bacon will correctly go up." is a sentence of the >>>>>>>>>> same form as
your (a). They are both vacuous nonsense.
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.
After careful review by many people it was agreed that the
above words are true and correct and thus not vacuous nonsense. >>>>>>>>> No one even hinted that Professor Sipser agreed to vacuous
nonsense.
When this possibility was proposed it was rejected.
You don't understand what Alan just said.
You and Alan don't seem to know the difference between
vacuous truths:
(a) All the living T-rexes in my living room have orange and blue >>>>>>> stripes
and Non vacuous truths:
(b) 2 + 3 = 5.
You don't seem to know the difference between vacuous truths:
(a) All the simulating halt deciders that correctly determine that >>>>>> their simulated input would never stop running unless aborted can
abort their simulations and correctly report that they specify a
non-halting sequence of configurations.
and Non vacuous truths:
(b) There is a keyboard on my desk.
Simulating termination analyzer is a more accurate term
because it is only required to get at least one input
correctly.
It does get at least one input correctly. But not D. It gets D wrong.
That proves that simulating halt decider is not a vacuous term.
It's still vacuous. Getting one answer right doesn't make it a
simulating halt decider.
I call it a simulating termination analyzer.
They only have to get one answer right.
On 1/21/2024 5:16 AM, immibis wrote:
On 1/21/24 02:00, olcott wrote:
On 1/20/2024 6:54 PM, immibis wrote:
On 1/21/24 01:20, olcott wrote:
On 1/20/2024 6:11 PM, immibis wrote:
On 1/21/24 00:26, olcott wrote:
On 1/20/2024 4:34 PM, immibis wrote:
On 1/20/24 23:21, olcott wrote:
On 1/20/2024 4:10 PM, Alan Mackenzie wrote:
It's not a matter of opinion, it's a matter of analysing these >>>>>>>>>> words,
which I have done, and you have not. "If I correctly state >>>>>>>>>> that pigs can
fly, then bacon will correctly go up." is a sentence of the >>>>>>>>>> same form as
your (a). They are both vacuous nonsense.
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.
After careful review by many people it was agreed that the
above words are true and correct and thus not vacuous nonsense. >>>>>>>>> No one even hinted that Professor Sipser agreed to vacuous
nonsense.
When this possibility was proposed it was rejected.
You don't understand what Alan just said.
You and Alan don't seem to know the difference between
vacuous truths:
(a) All the living T-rexes in my living room have orange and blue >>>>>>> stripes
and Non vacuous truths:
(b) 2 + 3 = 5.
You don't seem to know the difference between vacuous truths:
(a) All the simulating halt deciders that correctly determine that >>>>>> their simulated input would never stop running unless aborted can
abort their simulations and correctly report that they specify a
non-halting sequence of configurations.
and Non vacuous truths:
(b) There is a keyboard on my desk.
Simulating termination analyzer is a more accurate term
because it is only required to get at least one input
correctly.
It does get at least one input correctly. But not D. It gets D wrong.
That proves that simulating halt decider is not a vacuous term.
It's still vacuous. Getting one answer right doesn't make it a
simulating halt decider.
I call it a simulating termination analyzer.
They only have to get one answer right.
On 1/21/2024 11:57 AM, immibis wrote:
On 1/21/24 16:41, olcott wrote:
On 1/21/2024 5:16 AM, immibis wrote:
On 1/21/24 02:00, olcott wrote:
On 1/20/2024 6:54 PM, immibis wrote:
On 1/21/24 01:20, olcott wrote:That proves that simulating halt decider is not a vacuous term.
On 1/20/2024 6:11 PM, immibis wrote:
On 1/21/24 00:26, olcott wrote:
On 1/20/2024 4:34 PM, immibis wrote:
On 1/20/24 23:21, olcott wrote:
On 1/20/2024 4:10 PM, Alan Mackenzie wrote:
It's not a matter of opinion, it's a matter of analysing >>>>>>>>>>>> these words,
which I have done, and you have not. "If I correctly state >>>>>>>>>>>> that pigs can
fly, then bacon will correctly go up." is a sentence of the >>>>>>>>>>>> same form as
your (a). They are both vacuous nonsense.
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.
After careful review by many people it was agreed that the >>>>>>>>>>> above words are true and correct and thus not vacuous nonsense. >>>>>>>>>>> No one even hinted that Professor Sipser agreed to vacuous >>>>>>>>>>> nonsense.
When this possibility was proposed it was rejected.
You don't understand what Alan just said.
You and Alan don't seem to know the difference between
vacuous truths:
(a) All the living T-rexes in my living room have orange and >>>>>>>>> blue stripes
and Non vacuous truths:
(b) 2 + 3 = 5.
You don't seem to know the difference between vacuous truths:
(a) All the simulating halt deciders that correctly determine
that their simulated input would never stop running unless
aborted can abort their simulations and correctly report that
they specify a non-halting sequence of configurations.
and Non vacuous truths:
(b) There is a keyboard on my desk.
Simulating termination analyzer is a more accurate term
because it is only required to get at least one input
correctly.
It does get at least one input correctly. But not D. It gets D wrong. >>>>>
It's still vacuous. Getting one answer right doesn't make it a
simulating halt decider.
I call it a simulating termination analyzer.
They only have to get one answer right.
Even programs that aren't supposed to decide halting get one answer
right. Even prime number deciders get some halting answers right.
When a simulating termination analyzer gets one answer correctly
by determining that its input cannot possibly reach its own final
state in 1 to ∞ steps of correct simulation this conclusively proves
that the term {simulating termination analyzer} is not vacuous.
People stuck in rebuttal mode seem to have no problem with directly contradicting verified facts.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 429 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 117:18:11 |
| Calls: | 9,056 |
| Calls today: | 3 |
| Files: | 13,396 |
| Messages: | 6,016,551 |