On 3/27/22 7:37 PM, olcott wrote:
On 3/27/2022 6:34 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 7:26:34 PM UTC-4, olcott wrote:
On 3/27/2022 6:22 PM, Richard Damon wrote:
I told him that his question was just liked counting to ten: 1,2,3
On 3/27/22 7:16 PM, olcott wrote:
On 3/27/2022 6:05 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 6:55:02 PM UTC-4, olcott wrote:
On 3/27/2022 5:47 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 6:43:43 PM UTC-4, olcott wrote: >>>>>>>>>> On 3/27/2022 5:38 PM, Dennis Bush wrote:That is an intentionally stupid question.
On Sunday, March 27, 2022 at 6:12:47 PM UTC-4, olcott wrote: >>>>>>>>>>>> On 3/27/2022 3:50 PM, Dennis Bush wrote:You might as well define counting to ten: 1,2,3 DONE.
On Sunday, March 27, 2022 at 4:40:59 PM UTC-4, olcott wrote: >>>>>>>>>>>>>> On 3/27/2022 3:24 PM, Dennis Bush wrote:There is no H3, <N> or <3>. There is an ⟨Ĥ3⟩
On Sunday, March 27, 2022 at 3:35:17 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>> On 3/27/2022 2:23 PM, Richard Damon wrote:That is a common misconception. Please read my paper. >>>>>>>>>>>>>>
Which it doesn't, because Ĥ applied to ⟨Ĥ⟩ halts, and >>>>>>>>>>>>>>> that isOn 3/27/22 2:56 PM, olcott wrote:
On 3/27/2022 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 3/27/22 2:44 PM, olcott wrote:
On 3/27/2022 1:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:22 PM, olcott wrote:So might be infinite, and thus H fails to answer in >>>>>>>>>>>>>>>>>>> finite time.
On 3/27/2022 1:17 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 1:44 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 11:20 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>
On 3/26/2022 7:30 PM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>
what the correct answer for it is, is determined >>>>>>>>>>>>>>>>>>>>>>>>>>> solely byThat is not true.
whether or
not Ĥ halts on input ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>
You don't get to say what the halting problem is. >>>>>>>>>>>>>>>>>>>>>>>>> It's already
been
specified.
Every string either represents a halting >>>>>>>>>>>>>>>>>>>>>>>>> computation or it does
not.
There is no context other than some prior agreed >>>>>>>>>>>>>>>>>>>>>>>>> encoding about
how a TM
and an input should be represented. A halt decide >>>>>>>>>>>>>>>>>>>>>>>>> must accept
exactly
those strings that represent halting computations. >>>>>>>>>>>>>>>>>>>>>>>>>
The fact that you need to reject the very >>>>>>>>>>>>>>>>>>>>>>>>> definition of the
problem is
clear evidence that you know that no TM is a halt >>>>>>>>>>>>>>>>>>>>>>>>> decider.
This is true:It does not matter why the computation represented >>>>>>>>>>>>>>>>>>>>>>>>> a particular
The directly executed Ĥ applied to ⟨Ĥ⟩ is the >>>>>>>>>>>>>>>>>>>>>>>>>> first invocation of
infinite recursion that only terminates normally >>>>>>>>>>>>>>>>>>>>>>>>>> because of its
one-way dependency relationship on embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>> aborting the second
invocation of this otherwise infinite recursion. >>>>>>>>>>>>>>>>>>>>>>>>>
string
halts. You've been trying to pull this "it only >>>>>>>>>>>>>>>>>>>>>>>>> halts because"
nonsense
for years.
As long as the simulated input to embedded_H could >>>>>>>>>>>>>>>>>>>>>>>> never reach
its final state in any finite number of steps of >>>>>>>>>>>>>>>>>>>>>>>> correct
simulation then its rejection of this input is >>>>>>>>>>>>>>>>>>>>>>>> necessarily
correct and everything else in the universe is >>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>>>>>>>> inputs (not
anything else in the universe besides it inputs) to >>>>>>>>>>>>>>>>>>>>>>>> its own
accept or reject state based on the actual behavior >>>>>>>>>>>>>>>>>>>>>>>> specified by
these actual inputs (not any behavior of anything >>>>>>>>>>>>>>>>>>>>>>>> else in the
universe).
We also know that the actual behavior specified by >>>>>>>>>>>>>>>>>>>>>>>> these inputs
must be the same as the behavior of the simulation >>>>>>>>>>>>>>>>>>>>>>>> of N steps of
this input by a UTM. On this basis we know that any >>>>>>>>>>>>>>>>>>>>>>>> behavior
that diverges from this behavior is not the correct >>>>>>>>>>>>>>>>>>>>>>>> basis for
the halt status decision.
The string ⟨Ĥ⟩ ⟨Ĥ⟩ represents some computation.
If it is simulated outside of Ĥ then it must have >>>>>>>>>>>>>>>>>>>>>>>> the same
behavior as Ĥ applied to ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>
If it is simulated inside of Ĥ then several >>>>>>>>>>>>>>>>>>>>>>>> steps of
Ĥ have
already been executed when this simulation >>>>>>>>>>>>>>>>>>>>>>>> begins thus
specifying a different sequence of configurations >>>>>>>>>>>>>>>>>>>>>>>> then when Ĥ
starts at its beginning.
I assume you have notWhen Ĥ is simulated in the middle of Ĥ this is >>>>>>>>>>>>>>>>>>>>>>>> different than
been deceiving us for years, and you know that the >>>>>>>>>>>>>>>>>>>>>>>>> computation it
represents is Ĥ applied to the string ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>
when Ĥ is simulated at the beginning of Ĥ. >>>>>>>>>>>>>>>>>>>>>>>>
That either is or is not a
halting computation. There is no >>>>>>>>>>>>>>>>>>>>>>>>> context-dependence
(other
than the
void Infinite_Recursion(int N) >>>>>>>>>>>>>>>>>>>>>>>> {
Infinite_Recursion(N);
}
It is obvious that the above sequence is infinitely >>>>>>>>>>>>>>>>>>>>>>>> recursive.
If the halt decider aborts the second recursive >>>>>>>>>>>>>>>>>>>>>>>> call
then the
first recursive call would halt. That the first >>>>>>>>>>>>>>>>>>>>>>>> recursive call
halts does not indicate that it is a halting >>>>>>>>>>>>>>>>>>>>>>>> computation.
agreed encoding). There is no dispensation from >>>>>>>>>>>>>>>>>>>>>>>>> "special"
kinds of
halting.
Don't you think that having to have these sort of >>>>>>>>>>>>>>>>>>>>>>>>> basic matter
explained
to you, year in, year out, indicates that maybe >>>>>>>>>>>>>>>>>>>>>>>>> you
should be
doing
something else?
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY >>>>>>>>>>>>>>>>>>>>>>>> TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY >>>>>>>>>>>>>>>>>>>>>>>> TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY >>>>>>>>>>>>>>>>>>>>>>>> TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY >>>>>>>>>>>>>>>>>>>>>>>> TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY >>>>>>>>>>>>>>>>>>>>>>>> TRUE.
As long as the simulated input to embedded_H could >>>>>>>>>>>>>>>>>>>>>>>> never reach
its final state in any finite number of steps of >>>>>>>>>>>>>>>>>>>>>>>> correct
simulation then its rejection of this input is >>>>>>>>>>>>>>>>>>>>>>>> necessarily
correct and everything else in the universe is >>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.
No, YOU do not grasp that the definitions that were >>>>>>>>>>>>>>>>>>>>>>> established
ARE the definitions you need to use, >>>>>>>>>>>>>>>>>>>>>>
Because a halt decider must compute the mapping from >>>>>>>>>>>>>>>>>>>>>> its input
finite strings based on the actual behavior specified >>>>>>>>>>>>>>>>>>>>>> by these
strings which is correctly measured by a correct >>>>>>>>>>>>>>>>>>>>>> simulation of N
steps of these strings you already know that I am >>>>>>>>>>>>>>>>>>>>>> correct.
Nope, wrong definition, wrong answer. >>>>>>>>>>>>>>>>>>>>>
Do you have a reference for adding the 'of N steps' >>>>>>>>>>>>>>>>>>>>> into the
definition?
N = "simulating it for as many steps as it will take" >>>>>>>>>>>>>>>>>>>
You already that this is an infinite pattern: >>>>>>>>>>>>>>>>>>
When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates
⟨Ĥ0⟩ ⟨Ĥ1⟩
Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 >>>>>>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 >>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 >>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩
⟨Ĥ4⟩...
Note, the ... notation means that you intend the >>>>>>>>>>>>>>>>> pattern to
keep on
repeating for ever, so you are SHOWING 3 steps, but >>>>>>>>>>>>>>>>> stateing that more
occur.
What I said, was that pattern only repeats infinity if >>>>>>>>>>>>>>>>> embedded_H never
aborts its simulation.
When embedded_H correctly computes the mapping from its >>>>>>>>>>>>>>>> input finite
strings ⟨Ĥ⟩ ⟨Ĥ⟩ to its own final reject state >>>>>>>>>>>>>>>
the behavior that embedded_H (and therefore H) is stipulated >>>>>>>>>>>>>>> to answer about. So anything you say that follows doesn't >>>>>>>>>>>>>>> matter.
Halting problem undecidability and infinitely nested >>>>>>>>>>>>>> simulation (V4)
https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
I've read it, and it's bogus. It says nothing more than what >>>>>>>>>>>>> you've been saying before.
To repeat:
When H3 correctly computes the mapping from its input finite >>>>>>>>>>>>> strings <N> <3> to its own final reject state
on the basis that there is
no finite number N of steps of correct simulation of this >>>>>>>>>>>>> input
by the
UTM within H3 then H3 has correctly decided that its >>>>>>>>>>>>> input never halts.
Sure there is, I defined them earlier. But just so there's no >>>>>>>>>>> confusion with your ⟨Ĥ3⟩. I'll call it Ha3 instead. So Ha3 uses
as its halt status criteria: simulate for 3 steps and abort. >>>>>>>>>> That is ridiculously stupid.
So Ha3 is obviously wrong? What criteria do you use to
determine that?
I want to hear your answer. What criteria do you use to show that >>>>>>> Ha3 applied to <N><5> reporting non-halting is incorrect?
I take it that you want me to ignore everything you say.
This work is intended to be my legacy before I die.
If you just want to play head games go fornicate yourself.
The fact you have trouble with these simple questions shows how bad
your
logic is.
DONE.
So in other words H3a is not simulating for enough steps?
TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
As long as the simulated input to embedded_H could never reach its
final state in any finite number of steps of correct simulation by
embedded_H then its rejection of this input is necessarily correct.
Like, you need to use THE ACTUAL DEFINITION OF WHAT H IS SUPPOSED TO DO?
On 3/27/22 8:36 PM, olcott wrote:
On 3/27/2022 7:33 PM, Richard Damon wrote:
On 3/27/22 8:22 PM, olcott wrote:
On 3/27/2022 6:56 PM, Richard Damon wrote:
On 3/27/22 7:37 PM, olcott wrote:That is out-of-scope. You must find an error in my exact words and
On 3/27/2022 6:34 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 7:26:34 PM UTC-4, olcott wrote:
On 3/27/2022 6:22 PM, Richard Damon wrote:
I told him that his question was just liked counting to ten:
On 3/27/22 7:16 PM, olcott wrote:
On 3/27/2022 6:05 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 6:55:02 PM UTC-4, olcott wrote: >>>>>>>>>>>> On 3/27/2022 5:47 PM, Dennis Bush wrote:I take it that you want me to ignore everything you say.
On Sunday, March 27, 2022 at 6:43:43 PM UTC-4, olcott wrote: >>>>>>>>>>>>>> On 3/27/2022 5:38 PM, Dennis Bush wrote:That is an intentionally stupid question.
So Ha3 is obviously wrong? What criteria do you use to >>>>>>>>>>>>> determine that?On Sunday, March 27, 2022 at 6:12:47 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>> On 3/27/2022 3:50 PM, Dennis Bush wrote:You might as well define counting to ten: 1,2,3 DONE. >>>>>>>>>>>>>
Sure there is, I defined them earlier. But just so >>>>>>>>>>>>>>> there's noOn Sunday, March 27, 2022 at 4:40:59 PM UTC-4, olcott >>>>>>>>>>>>>>>>> wrote:There is no H3, <N> or <3>. There is an ⟨Ĥ3⟩ >>>>>>>>>>>>>>>
On 3/27/2022 3:24 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 3:35:17 PM UTC-4, olcott >>>>>>>>>>>>>>>>>>> wrote:That is a common misconception. Please read my paper. >>>>>>>>>>>>>>>>>>
On 3/27/2022 2:23 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:56 PM, olcott wrote:Which it doesn't, because Ĥ applied to ⟨Ĥ⟩ halts, and >>>>>>>>>>>>>>>>>>> that is
On 3/27/2022 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:44 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:22 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:17 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 1:44 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 11:20 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On 3/26/2022 7:30 PM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
what the correct answer for it is, is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determinedThat is not true.
solely by
whether or
not Ĥ halts on input ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You don't get to say what the halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is.
It's already
been
specified.
Every string either represents a halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation or it does >>>>>>>>>>>>>>>>>>>>>>>>>>>>> not.
There is no context other than some prior >>>>>>>>>>>>>>>>>>>>>>>>>>>>> agreed
encoding about
how a TM
and an input should be represented. A halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>> decide
must accept
exactly
those strings that represent halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>> computations.
The fact that you need to reject the very >>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the
problem is
clear evidence that you know that no TM is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> a halt
decider.
This is true:
The directly executed Ĥ applied to ⟨Ĥ⟩ is the
first invocation of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion that only terminates >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally
because of its
one-way dependency relationship on embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborting the second >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of this otherwise infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion.
It does not matter why the computation >>>>>>>>>>>>>>>>>>>>>>>>>>>>> represented
a particular
string
halts. You've been trying to pull this "it >>>>>>>>>>>>>>>>>>>>>>>>>>>>> only
halts because"
nonsense
for years.
As long as the simulated input to embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>> could
never reach
its final state in any finite number of >>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of
correct
simulation then its rejection of this input is >>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
correct and everything else in the universe is >>>>>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.
A halt decider must compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>>>> its
inputs (not
anything else in the universe besides it >>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs) to
its own
accept or reject state based on the actual >>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
specified by
these actual inputs (not any behavior of >>>>>>>>>>>>>>>>>>>>>>>>>>>> anything
else in the
universe).
We also know that the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>> specified by
these inputs
must be the same as the behavior of the >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
of N steps of
this input by a UTM. On this basis we know >>>>>>>>>>>>>>>>>>>>>>>>>>>> that any
behavior
that diverges from this behavior is not the >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct
basis for
the halt status decision. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
The string ⟨Ĥ⟩ ⟨Ĥ⟩ represents some >>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation.
If it is simulated outside of Ĥ then it must >>>>>>>>>>>>>>>>>>>>>>>>>>>> have
the same
behavior as Ĥ applied to ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
If it is simulated inside of Ĥ then several >>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of
Ĥ have
already been executed when this simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>> begins thus
specifying a different sequence of >>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations
then when Ĥ
starts at its beginning. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
I assume you have not >>>>>>>>>>>>>>>>>>>>>>>>>>>>> been deceiving us for years, and you know >>>>>>>>>>>>>>>>>>>>>>>>>>>>> that theWhen Ĥ is simulated in the middle of Ĥ this is >>>>>>>>>>>>>>>>>>>>>>>>>>>> different than
computation it
represents is Ĥ applied to the string ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
when Ĥ is simulated at the beginning of Ĥ. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
That either is or is not a >>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computation. There is no >>>>>>>>>>>>>>>>>>>>>>>>>>>>> context-dependence
(other
than the
void Infinite_Recursion(int N) >>>>>>>>>>>>>>>>>>>>>>>>>>>> {
Infinite_Recursion(N); >>>>>>>>>>>>>>>>>>>>>>>>>>>> }
It is obvious that the above sequence is >>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
recursive.
If the halt decider aborts the second >>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive call
then the
first recursive call would halt. That the first >>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive call
halts does not indicate that it is a halting >>>>>>>>>>>>>>>>>>>>>>>>>>>> computation.
agreed encoding). There is no dispensation >>>>>>>>>>>>>>>>>>>>>>>>>>>>> from
"special"
kinds of
halting.
Don't you think that having to have these >>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of
basic matter
explained
to you, year in, year out, indicates that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> maybe you
should be
doing
something else?
YOU ARE UNABLE TO GRASP THAT THIS IS >>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS >>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS >>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS >>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS >>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE.
As long as the simulated input to embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>> could
never reach
its final state in any finite number of >>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of
correct
simulation then its rejection of this input is >>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
correct and everything else in the universe is >>>>>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.
No, YOU do not grasp that the definitions >>>>>>>>>>>>>>>>>>>>>>>>>>> that were
established
ARE the definitions you need to use, >>>>>>>>>>>>>>>>>>>>>>>>>>
Because a halt decider must compute the >>>>>>>>>>>>>>>>>>>>>>>>>> mapping from
its input
finite strings based on the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>> specified
by these
strings which is correctly measured by a correct >>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N
steps of these strings you already know that I am >>>>>>>>>>>>>>>>>>>>>>>>>> correct.
Nope, wrong definition, wrong answer. >>>>>>>>>>>>>>>>>>>>>>>>>
Do you have a reference for adding the 'of N >>>>>>>>>>>>>>>>>>>>>>>>> steps'
into the
definition?
N = "simulating it for as many steps as it will >>>>>>>>>>>>>>>>>>>>>>>> take"
So might be infinite, and thus H fails to answer in >>>>>>>>>>>>>>>>>>>>>>> finite time.
You already that this is an infinite pattern: >>>>>>>>>>>>>>>>>>>>>>
When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H
simulates
⟨Ĥ0⟩ ⟨Ĥ1⟩
Then these steps would keep repeating: >>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0
simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1
simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2
simulates ⟨Ĥ3⟩
⟨Ĥ4⟩...
Note, the ... notation means that you intend the >>>>>>>>>>>>>>>>>>>>> pattern to
keep on
repeating for ever, so you are SHOWING 3 steps, but >>>>>>>>>>>>>>>>>>>>> stateing that more
occur.
What I said, was that pattern only repeats infinity if >>>>>>>>>>>>>>>>>>>>> embedded_H never
aborts its simulation.
When embedded_H correctly computes the mapping from its >>>>>>>>>>>>>>>>>>>> input finite
strings ⟨Ĥ⟩ ⟨Ĥ⟩ to its own final reject state >>>>>>>>>>>>>>>>>>>
the behavior that embedded_H (and therefore H) is >>>>>>>>>>>>>>>>>>> stipulated
to answer about. So anything you say that follows >>>>>>>>>>>>>>>>>>> doesn't
matter.
Halting problem undecidability and infinitely nested >>>>>>>>>>>>>>>>>> simulation (V4)
https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
I've read it, and it's bogus. It says nothing more than >>>>>>>>>>>>>>>>> what
you've been saying before.
To repeat:
When H3 correctly computes the mapping from its input >>>>>>>>>>>>>>>>> finite
strings <N> <3> to its own final reject state >>>>>>>>>>>>>>>>> on the basis that there is
no finite number N of steps of correct simulation of >>>>>>>>>>>>>>>>> this input
by the
UTM within H3 then H3 has correctly decided that its >>>>>>>>>>>>>>>>> input never halts.
confusion with your ⟨Ĥ3⟩. I'll call it Ha3 instead. So >>>>>>>>>>>>>>> Ha3 uses
as its halt status criteria: simulate for 3 steps and abort. >>>>>>>>>>>>>> That is ridiculously stupid.
I want to hear your answer. What criteria do you use to show >>>>>>>>>>> that
Ha3 applied to <N><5> reporting non-halting is incorrect? >>>>>>>>>>
This work is intended to be my legacy before I die.
If you just want to play head games go fornicate yourself. >>>>>>>>>>
The fact you have trouble with these simple questions shows how >>>>>>>>> bad your
logic is.
1,2,3 DONE.
So in other words H3a is not simulating for enough steps?
TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
As long as the simulated input to embedded_H could never reach its >>>>>> final state in any finite number of steps of correct simulation by >>>>>> embedded_H then its rejection of this input is necessarily correct. >>>>>
Like, you need to use THE ACTUAL DEFINITION OF WHAT H IS SUPPOSED
TO DO?
explain why it is an error, otherwise we get stuck talking in
circles that are various shades of the strawman error.
The error in your words is that you don't use the right defintion of
Halting,
So in other words you disagree with Linz:
computation that halts … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)
Nope, I agree with him, and he says look at the direct execution of the machine,
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 366 |
Nodes: | 16 (2 / 14) |
Uptime: | 16:54:54 |
Calls: | 7,812 |
Files: | 12,927 |
Messages: | 5,766,217 |