Re: Proof that H(D,D) meets its abort criteria --incorrect question instance--

On 3/20/24 2:07 PM, olcott wrote:

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

On 3/20/24 12:08 PM, olcott wrote:

On 3/20/2024 11:03 AM, Richard Damon wrote:

On 3/20/24 8:54 AM, olcott wrote:

On 3/20/2024 3:56 AM, Mikko wrote:

On 2024-03-19 14:37:13 +0000, olcott said:
>

On 3/19/2024 4:24 AM, Mikko wrote:

On 2024-03-19 04:37:02 +0000, olcott said:
>

On 3/18/2024 11:23 PM, Richard Damon wrote:

On 3/18/24 8:53 PM, olcott wrote:

On 3/18/2024 9:44 PM, Richard Damon wrote:

On 3/18/24 2:48 PM, olcott wrote:

On 3/18/2024 4:38 PM, Fred. Zwarts wrote:

Op 18.mrt.2024 om 22:18 schreef olcott:

On 3/18/2024 4:11 PM, Fred. Zwarts wrote:

Op 18.mrt.2024 om 21:40 schreef olcott:

On 3/18/2024 3:30 PM, immibis wrote:

On 18/03/24 21:20, olcott wrote:

On 3/18/2024 2:44 PM, Fred. Zwarts wrote:

Op 18.mrt.2024 om 18:43 schreef olcott:

On 3/18/2024 10:11 AM, Fred. Zwarts wrote:

Op 18.mrt.2024 om 15:44 schreef olcott:

On 3/18/2024 1:04 AM, Richard Damon wrote:

On 3/17/24 10:22 PM, olcott wrote:

On 3/18/2024 12:11 AM, Richard Damon wrote:

On 3/17/24 9:42 PM, olcott wrote:

On 3/17/2024 11:39 PM, Richard Damon wrote:

On 3/17/24 9:00 PM, olcott wrote:

On 3/17/2024 10:32 PM, Richard Damon wrote:

On 3/17/24 8:14 PM, olcott wrote:

On 3/17/2024 9:35 PM, Richard Damon wrote:

On 3/17/24 4:27 PM, olcott wrote:

On 3/17/2024 12:37 PM, immibis wrote:

On 17/03/24 14:11, olcott wrote:

On 3/17/2024 12:22 AM, Richard Damon wrote:

On 3/16/24 10:04 PM, olcott wrote:

On 3/17/2024 12:00 AM, Richard Damon wrote:

On 3/16/24 9:42 PM, olcott wrote:

On 3/16/2024 11:28 PM, Richard Damon wrote:

On 3/16/24 9:13 PM, olcott wrote:

On 3/16/2024 10:57 PM, Richard Damon wrote:

On 3/16/24 7:52 PM, olcott wrote:

On 3/16/2024 9:43 PM, Richard Damon wrote:

On 3/16/24 5:50 PM, olcott wrote:

On 3/16/2024 7:21 PM, Richard Damon wrote:

On 3/16/24 8:29 AM, olcott wrote:

On 3/15/2024 11:29 PM, Richard Damon wrote:

On 3/15/24 8:45 PM, olcott wrote:

H(D,D) fails to make the required mistake of reporting on what it does not see.

>
But it DOES make a mistake, because it does answer the question correctly.
>
You are just PROVING you think lying is ok.
>
You TOTALLY don't understand the meaning of truth.
>
You are REALLY just a Pathological Liar, as you have no concept of real truth,
>

>
The original halt status criteria has the impossible requirement
that H(D,D) must report on behavior that it does not actually see.
Requiring H to be clairvoyant is an unreasonable requirement.
*The criteria shown below eliminate the requirement of clairvoyance*
>
(a) 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 correctly simulates its input D until*
Means H does a correct partial simulation of D until H correctly
matches the recursive simulation non-halting behavior pattern.
>
>

>
But turning out to be impposible, doesn't make it incorrect or invalid.

>
*You seems to be ridiculously disingenuous about the self-evident truth*
For every possible way that H can be encoded and D(D) calls H(D,D) either H(D,D) aborts its simulation or D(D) never stops running.
>
>

>
And you are incredably stupid to not see this doesn't prove what you need it to.
>
Yes, if you define H to not abort, the we get a non-haltig D(D), but H doesn't answwer.
>
But, if you define H to abort, then,

>
We see that you changed the subject away from:
[Proof that H(D,D) meets its abort criteria]
>

>
Nope.

>
H is an algorithm that simulates its input and correctly
determines whether or not it needs to abort this simulation.
That is all that this thread's H does.
>
>
>

And what defines "Need"?
>

It is the set of every implementation of its spec:
(a) H(D,D) Simulate input.
(b) Determine if it needs to stop simulating its input to prevent
the simulated D(D) from never halting.
>

>
And thus not a specific algorithm?
>
Again, HOW do you determine NEED?
>
That is not an algorithmic step.
>
We can only verify that in retrospect.

>
Do you fully understand the spec?
>
>

>
Yes, but I think not the way you do.
>
To me, for H to NEED to abort its simulation, that means that when giving the input to a correct simulator, that simulator will not halt.
>

Yes that is correct.

>
You have just proven that H doesn't need abort its simulation and the abort decision is incorrect.

>
The head games of a Troll.
>
For every possible way that H can be encoded and D(D)
calls H(D,D) either H(D,D) aborts its simulation or D(D)
never stops running.
>

>
Which prove NOTHING, as D varies with H, so no D that was built with an H that aborts its simulation has had its actual halting status tested.

>
*That merely changes the wording of the same truism*
∀H ∈ TM ∀D ∈ TMD such that
H(D,D) simulates its input and
D calls H(D,D) and
H(D,D) does not abort its simulation
necessitates simulated D(D) never stops running.
>
>

>
Third times and still not a charm.
>
All those D still use an H that doesn't abort

>
*You keep talking in circles, there are only two sets*
∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
(1) H(D,D) does not abort its simulation then simulated D(D) never stops running.
(2) H(D,D) aborts its simulation then simulated D(D) stops running.
>
>

>
And your top line says NOTHING about the Ds in set (2), since nothing showed them not to run
>
but your (2) admitts that D(D) will stop running, and thus the top level H didn't need to abort its simulation.
>

>
Do you understand that each H(D,D) must either abort or fail to abort?
>
>

>
And do you understand

>
Yes that is what I am asking. It seems that you don't understand
the difference between X being a member of a set and X not being
a member of a set. Very elemental set theory.

>
And you seem to be trying to convientely forget that each D that you talk about is DIFFERENT, base on the H that it was designed to confound.

>
*You keep talking in circles, there are only two sets*
∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
(1) H(D,D) does not abort its simulation then simulated D(D) never stops running.
(2) H(D,D) aborts its simulation then simulated D(D) stops running.
*By whatever means H(D,D) places itself in (2) then H(D,D) is correct*
>

>
By repeating yourself, you run in circles.
There are three possible categories of H functions:
>
1. Hah, It aborts and reports halting.
2. Han, It aborts and repeats non halting.
3. Hss does not abort, but simply simulates.
>

>
What H(D,D) reports is off-topic for this post.
*We are only looking at this*
[Proof that H(D,D) meets its abort criteria --self-evident truth--]
*Thus H(D,D) aborts or H(D,D) fails to abort*
>

>
Be clear in the naming. Is it Dan that is considered, or Dss? Dss must be aborted, because is does not halt, but Dan does halt and does not need to be aborted.

>
*There are only two sets*
∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
(1) H(D,D) does not abort its simulation then simulated D(D) never stops running.
(2) H(D,D) aborts its simulation then simulated D(D) stops running.
>
(a) If simulating abort decider H correctly simulates its input D until H correctly determines that its simulated D would never stop running unless aborted...
>
*Therefore*
*Every element of (1) is incorrect and every element of (2) is correct*
*Pathological thinking to make them both seem incorrect is incorrect*
>

So, Hss(Dss,Dss) should abort, but it does not.
and Han(Dan,Dan) should not abort, but it does.
The Hss that meets the abort criteria does not abort and the Han that does not meet its abort criteria does abort. So, both are wrong.

>

>
Is it Dan that is considered, or Dss? Dss must be aborted, because is does not halt, but Dan does halt and does not need to be aborted.

>
*This is what those naming conventions derive*
Everyone is saying that because H(D,D) did need to abort its simulation
to prevent D(D) from infinite execution that this proves that it never
needed to abort its simulation because it can rely on the fact that it
already aborted its simulation thus never needed to abort it.
>

>
You are almost there. If you stop naming all different H which the same name and all different D with the same name, your confusion may disappear.

>
∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
Every H in the above set must abort its simulated D(D).
>

Hss(Dss,Dss) should abort, but it does not.
and Han(Dan,Dan) should not abort, but it does.
The Hss that meets the abort criteria does not abort and the Han
that does not meet its abort criteria does abort. So, both are wrong.
>

>
Olcott does not understand that if the H in the simulated D aborts, then the simulating H should not abort

>
*You are confused*
If the H in the simulated D aborts then the directly executed H did
not abort. Since the directly executed H sees one more execution
trace then the simulated H then the H in the simulated D never aborts.

>
Nope, YOU are confused If the H in the simulated D aborts,

>
Then a dozen square circles are on sale at Walmart right now for $10.99

>
Interesting, that you retort was to just blantently lie?
>
When presented with FACTS, you respond with LIES.
>
That just shows who you are.
>

>

then the directly executed D MUST abort, or you are agreeing that H's simulation is not correct.
>

>
In other words after we have been over this hundreds and hundreds of times it is still waaaayyy over your head that the executed H always
sees exactly one more execution trace than the executed H?

>
Do you really read your nonsense?
>
How does x, "the executed H" see one more execution trace than x?
>
That means you think that 1 + 1 = 1
>

>

And no, the directed executed vesion of D see no more information then the machine the simulated D represents,

>
The simulated H can not see its own behavior where as its simulator
can thus proving the simulator sees one more execution trace that its simulation.

>
Nope, it may see one more then at the point the simulation reaches,

>
Yes, finally. Thus the executed H(D,D) sees its abort criteria before
any of the simulated ones ever would.
>

but the actual machine that is now being simulated did EVERYTHING that it will do as soon as it was created,
>

No it is not true that x86 machines are oracle machines.
https://en.wikipedia.org/wiki/Oracle_machine
>

You keep on makeing that mistake, confusing the simulation with what actually happens.
>

>

if H aborts the simulation before then, then H just doesn't get to know what happens after that.
>
I will point out, you almost NEVER actually look at the direct execution of D(D), because it just proves that H isn't a correct Halt Decider.
>

>
H(D,D) cannot rely on the behavior of D(D) after it has already aborted
its simulation or it would never abort its simulation and D(D) would
never stop running. This means that the executed H(D,D) see non halting
behavior.
>

>
Right, H is in a no-win pickle. (or its programmer is).

>
Not at all. The requirement for clairvoyance is an incorrect
requirement. H(D,D) cannot be correctly required to report on
what it cannot see.
>

If we wait, we run into the issue that we may never answer. If we abort, we don't know what answer to give.

>
An abort decider would report on whether it aborted or not.
>

That is why the Halting Mapping turns out to be uncomputable.
>

>
*H(D,D) cannot be correctly required to report on what it cannot see*

>
A requirement is correct if it is possible to determine
whether the requirement is satisfied in a particular case.
>

>
Any requirement that ever requires the logically impossible is never correct in these cases where it requires the logically impossible.

>
That is not what the word "correct" means.
>

>
Logical impossibilities never place any actual limit on anyone
or anything.
>
>

>
But knowledge of what is logically impossible helps us to KNOW what are the actual limits.

>
We cannot expect anyone to correctly answer this question:
What time is it (yes or no) ?

>
Right, because that is an INVALID question, as its answer is NOT yes or no
>

>
Likewise every decision problem with undecidable instances is
merely an incorrect question instance in these undecidable instances.
>

>
Nope.
>
Just shows you are continuing to LIE about what the definition of those terms are.
>
And, that you are totally ignorant of those meanings.

 Since I defined the term "incorrect question" and I defined the
term "incorrect question instance" I cannot possibly have defined
them incorrectly. These are stipulative definitions.
https://en.wikipedia.org/wiki/Stipulative_definition

And by stipulating your definition, you havve disconnected it from any other use in the theory, in prticular, just because some question turns out to be an Olcott-Incorrect Question doesn't me it is an improper question to put to a decider to see if it meets its defintion.
This seems to be something you don't understand about Stipulating your definitions.

 An {incorrect question} is any question that has no correct answer.
What time is it (yes or no)? is an incorrect question.
 

So, by YOUR definitoin, the "Halting Question", namely the question, "Does the Computation described by this input Halt?" is not an {incorrect question}, as EVERY specific computation will either Halt or Not.

An {incorrect question instance} is any question that has no
correct answer from the one that this question was posed to.

And, if the "one" that question was posed to, by reason of the "definition" of that "one" just doesn't give the correct answer, are you saying that is enough to make that question instance invalid?
By that meaning, ALL Deciders are correct deciders for ANY question you want to give them, as any input they get wrong is just defined to be invalid.
That isn't a very useful definition, so I think people aren't going to accept your stipulated definition as useful.
In particular, it is a bad definition for ANY question we want to ask of a deterministic entity.

 Can Carol correctly answer “no” to this [yes/no] question?
is an incorrect question instance when posed to Carol.

But Carol is volitional, and thus gets to choose any of the possible answers.
A Computation does not, as it has a fixed algorithm.

 Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
 Does Ĥ ⟨Ĥ⟩ halt? is an incorrect question instance when posed to Ĥ.H
 

Only if your definition includes on of two posibiliteis:
1) That you have just defined that it is invalid to ask any question to any machine that it get wrong, or
2) That you allow CHANGING the question depending on how you ask.
Note, if you are allowing the changing of H to try to get the right answer (to avoid making your definition the very silly case 1) then you have changed the question from asking about a SPECIFIC H^ built on a SPECIFIC H, to asking about the VARIABLE H^ built on what every H you are trying to have decide it, which is NOT a COMPUATION in Computation Theory, so it never tries to ask that question.
This shows that you definition 2 is nothing but a Strawman deception.
So, which is it Silly or Deception?