H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees

On 3/11/2024 5:45 AM, Mikko wrote:

On 2024-03-11 04:38:40 +0000, olcott said:
 

On 3/10/2024 11:10 PM, Richard Damon wrote:

On 3/10/24 8:33 PM, olcott wrote:

On 3/10/2024 9:13 PM, Richard Damon wrote:

On 3/10/24 7:05 PM, olcott wrote:

On 3/10/2024 8:52 PM, Richard Damon wrote:

On 3/10/24 6:00 PM, olcott wrote:

On 3/10/2024 2:23 PM, Richard Damon wrote:

On 3/10/24 11:23 AM, olcott wrote:

On 3/10/2024 12:55 PM, Richard Damon wrote:

On 3/10/24 10:17 AM, olcott wrote:

On 3/10/2024 12:08 PM, Richard Damon wrote:

On 3/10/24 9:52 AM, olcott wrote:

On 3/10/2024 10:50 AM, Richard Damon wrote:

On 3/10/24 7:28 AM, olcott wrote:

On 3/10/2024 12:16 AM, Richard Damon wrote:

On 3/9/24 9:49 PM, olcott wrote:

On 3/9/2024 11:36 PM, Richard Damon wrote:

On 3/9/24 9:14 PM, olcott wrote:

On 3/9/2024 10:55 PM, Richard Damon wrote:

On 3/9/24 8:30 PM, olcott wrote:

On 3/9/2024 7:40 PM, immibis wrote:

On 10/03/24 02:37, olcott wrote:

On 3/9/2024 7:32 PM, immibis wrote:

On 10/03/24 02:29, olcott wrote:

On 3/9/2024 7:24 PM, immibis wrote:

On 10/03/24 01:30, olcott wrote:

On 3/9/2024 6:24 PM, immibis wrote:

On 10/03/24 01:22, olcott wrote:

On 3/9/2024 5:57 PM, immibis wrote:

On 10/03/24 00:26, olcott wrote:

On 3/9/2024 5:10 PM, immibis wrote:

On 9/03/24 23:22, olcott wrote:

On 3/9/2024 3:50 PM, immibis wrote:

On 9/03/24 22:34, olcott wrote:

>
What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
wrong answer to provide?
>

>
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria that H ⟨Ĥ⟩ uses.

>
Simulating halt deciders must make sure that they themselves
do not get stuck in infinite execution. This means that they
must abort every simulation that cannot possibly otherwise halt.
>
This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
its simulation.
>
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
does not simulate itself in recursive simulation.
>

>
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria that H ⟨Ĥ⟩ uses.
>

>
*Only because Ĥ.H is embedded within Ĥ and H is not*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>

>
You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.

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

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

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

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

>
*In other words you are denying these verified facts*
*In other words you are denying these verified facts*
*In other words you are denying these verified facts*
>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt

>
That's not a verified fact, that's just something you want to be true.
>
∞ means infinite loop. Infinite loop doesn't halt. You see how stupid it is, to say that an infinite loop halts?
>

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

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

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

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

>
(b) and (c) are not the same as (1) and (2)
Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
(1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(2) which begins at simulated ⟨Ĥ.q0⟩
(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
(b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>
This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more execution
trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see.
>

>
Nope, your just being stuupid, perhaps intentionally.
(c) just moves around to its simulation of a
>
>
(a) H^.q0 (H^)
H^ then makes a copy of its inp
>
(b) H^.H (H^) (H^) == (1) H (H^) (H^)
The algorithm of H begins a simulation of its input, watching the behaior of H^ (H^)
>
(c) = (2)
Which begins at the simulation of H^.q0 (H^)
>
(d = sim a) = (sim a)
Ths Simulated H^.q0 (H^) makes a copy of its input
>
(e = sim b) = (sim b)
The Simulated H^.H (H^) (H^) has is H begin the simulation of its input ...
>
and so on.
>
Both machine see EXACTLY the same level of details.
>
Yes, the top level H is farther along at any given time then its simulated machine, and that is H's problem, it has to act before it sees how its simulation will respond to its copy of its actions.
>
Thus, if it stops, it needs to make its decision "blind" and not with an idea of how the machine it is simulating will perform.
>
If it doesn't stop, the level of recursion just keeps growing and no answer ever comes out.

>
The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
its simulation. Right before its cycle repeats the first time.
>

>
>
So?
>
If it DOES abort there, then so will H^.H when it gets to that point in its simulation, which will be AFTER The point that H has stopped simulating it, so H doesn't know what H^ will do.
>
Thus, if H DOES abort there, we presume from your previous answer it will think the input will not halt and answer qn.
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.

>
And if it does, as I said below, so will H^.H when it is run.

>
Yes.

>
And thus, H^.H will give the same answer as H,
so H^ will act contrary to what H says,
so H will give the wrong answer.

>
Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
simulation to prevent their own infinite execution.

>
NOPE.

>
If no source can be cited then the Olcott thesis
"that no one did this before" remains unrefuted.

>
Since, BY THE DEFINITIONS of what H MUST do to be correct, and what H^ WILL do by its design, as shown in the Linz Proof.

>
If no source can be cited that shows a simulating halt decider can
correctly determine that it must abort its simulation of the Halting
Problem's pathological input to prevent its own non-termination, then
innovation remains attributable to me.
>
<snip>

>
Of course it can abort its simulation.
>
It just needs some way to get the right answer.
>

>
*I have always been using this long before I read about it*
blind variation and selective retention (BVSR)...
Two common phenomena characterize BVSR thinking: superfluity and backtracking. Superfluity means that the creator generates a variety of ideas, one or more of which turn out to be useless.

>
But if you have mo idea how things actually works, this seems to just generate random noise.
>

>
Backtracking signifies that the creator must often return to an earlier approach after blindly going off in the wrong direction.
https://www.scientificamerican.com/article/the-science-of-genius/
>
*I am aware of no one else that had the idea to apply a simulating* *termination analyzer to the halting problem counter-example input*
Professor Hehner had a seed of this idea before I did.

>
Nope, I remember talk of that when I was in college, and they showed why it can't work.
>

>
 From a programmer's point of view, if we apply an interpreter to a
program text that includes a call to that same interpreter with that
same text as argument, then we have an infinite loop. A halting program
has some of the same character as an interpreter: it applies to texts
through abstract interpretation. Unsurprisingly, if we apply a halting
program to a program text that includes a call to that same halting
program with that same text as argument, then we have an infinite loop. https://www.cs.toronto.edu/~hehner/PHP.pdf

>
You THINK so, but if the interpreter is a CONDITIONAL interpreter, that doesn't hold.
>
You seem to miss that fact.
>

>
*Turing Machine and Olcott machine implementations seem to be dead*
*This the (possibly augmented) RASP machine equivalent of x86*
Every machine must be able to get its own machine address.
>

>
And the reason it is a dead end is they make it too hard for you to cheat.
>
You need to hide that your H is trying to get in some extra information to hide that the embedded version of H doesn't give the same answer, which just shows that your H^ is built wrong.

>
My C code proves these two have different behavior:
(a) H1(D,D) + H1_machine_address
(b) H(D,D) + H_machine_address
H1(D,D) does correctly determine the halt status of D(D) because
H(D,D) does NOT correctly determine the halt status of D(D).
>
I say:
H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>
immibis disagrees.
Correct reasoning will show who is correct.
>

>
Yes, and since H1 is a different computation than H, it getting the right answer doesn't keep H from being broken.
>
We can then make a D1 to break H1.
>

>
I think that immibis already said that and I did not notice
the significance of it at the time.
>

>
Of course.
>

Then we are back to undecidability being incorrectly construed
as an actual limit to computation.

>
Strange definition of not an actual limit if not being able to do something isn't a limit.
>

>
Professor's Hehner and Stoddart have only construed this as
applying to the Halting Problem's pathological input.
>
We three perfectly agree on this as it pertains to the
Halting Problem.
>
That two full PhD professors of computer science and I all
agree on this shows that I am not a crackpot/crank on this.
I think that all of the other options may now be exhausted.
>
I am very happy that I quit tolerating the [change the subject]
form of rebuttal that wasted 15 years with Ben Bacarisse.
>
*The focus now must be on finding the best words that prove*
*this original position of mine (thus the concurring positions*
*of professors Hehner and Stoddart) is correct*

>
Go knock yourself out on that.
>

>
Alan Turing's Halting Problem is incorrectly formed (PART-TWO)  sci.logic
On 6/20/2004 11:31 AM, Peter Olcott wrote:
 > PREMISES:
 > (1) The Halting Problem was specified in such a way that a solution
 > was defined to be impossible.

>
Nope.
>
The PROBLEM is the question if a machine can compute the Halting Function.
>
The answer to that, has turned out to be NO.
>
When the problem was first being posed, it was hoped the answer woudl be yes, so it couldn't have bee made specifically to make it impossible.
>
>
The Halting QUESTION, has an answer for every input that it the description of an actual algorithm applied to an actual data input.
>
Note, Not a "Template" that gets appled to the decider, that IS an invalid question, and impossible to build a description of a Turing Machine to ask that.
>
Thus, when you admitted that your input wasn't actually a description of a program, but just a template, you were admitting that you were lying about working on the Halting Problem, as your input isn't of the right type.
>
Yes, asking about a template IS an invalid question.
>

 >
 > (2) The set of questions that are defined to not have any possible
 > correct answer(s) forms a proper subset of all possible questions.
 > …

>
And, when you are asking the actual Halting Question, about a specific machine and input, like a SPECIFIC H^, built to foil a SPECIIFIC H, then that input has a specific and definate behavior and there is a specific and definate answer (That depends on the H that you chose to build it on, but not the decider you are asking the question to).
>

 > CONCLUSION:
 > Therefore the Halting Problem is an ill-formed question.
 >

>
Nope, as explained above. You are just showing that you never understood the actual question or what any of the theory actually means, and have just wasted the last decades of your life on a stupid misconception of your own.
>

USENET Message-ID:
<kZiBc.103407$Gx4.18142@bgtnsc04-news.ops.worldnet.att.net>
>
*Direct Link to original message*
http://al.howardknight.net/?STYPE=msgid&MSGI=%3CkZiBc.103407%24Gx4.18142%40bgtnsc04-news.ops.worldnet.att.net%3E+

>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
That YES and NO are the wrong answer for each implementation of
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ specified by the second ⊢* state transition proves that the
questions asked of these machine/inputs pairs are incorrect questions.

 An incorrect answer does not mean that the question is incorrect.
 

When every element of the infinite set of every possible
implementation of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer then
there is something wrong with the question.
When a decider is required to report on behavior Ĥ ⟨Ĥ⟩
that is different than the behavior it actually sees
then the problem specification is incorrect.
*This alternative specification is decidable*
Will you halt if you never abort your simulation?
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer