Re: Incorrect questions and halt deciders --Liars?--

On 3/15/2024 12:20 AM, Richard Damon wrote:

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

On 3/14/2024 11:33 PM, Richard Damon wrote:

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

On 3/14/2024 11:08 PM, Richard Damon wrote:

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

On 3/14/2024 8:29 PM, Richard Damon wrote:

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

On 3/14/2024 5:03 PM, Richard Damon wrote:

On 3/14/24 2:43 PM, olcott wrote:

On 3/14/2024 4:18 PM, Richard Damon wrote:

On 3/14/24 12:07 PM, olcott wrote:

On 3/14/2024 11:41 AM, immibis wrote:

On 14/03/24 06:03, olcott wrote:

On 3/13/2024 11:48 PM, Richard Damon wrote:

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

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

On 3/13/24 8:46 PM, olcott wrote:

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

On 3/13/24 6:35 PM, olcott wrote:

On 3/13/2024 7:09 PM, Richard Damon wrote:

On 3/13/24 4:20 PM, olcott wrote:

For any program H that might determine whether programs
halt, a "pathological" program D, called with some input,
can pass its own source and its input to H and then
specifically do the opposite of what H predicts D will do.
No H can exist that handles this case.
https://en.wikipedia.org/wiki/Halting_problem

>
Yes, but the correct answer for the question given to H exists.
>

>
There is no mapping from
(a) Specific TM: H(D,D) to Halts(D,D)
(b) Specific unmarried_man to stopped_beating_wife(YES/NO)
>

>
When you ask a man that has never been married:
Have you stopped beating your wife?
https://groups.google.com/g/sci.lang/c/AO5Vlupeelo/m/nxJy7N2vULwJ

>
Which is a different issue.
>

>
Although there is a mapping from some men to YES/NO
there is no mapping from never married men to YES/NO
thus the question is incorrect for all unmarried men.

>
Invalid, because it asks about a non-existant person.

and a non-existent halt decider H
>

Also, because it presumes facts that are not true.
>

>
There is no mapping from
(a) Specific TM: H(D,D) to Halts(D,D)

>
>
Which s a lying comment since nothing in the question asks for one.
>

>
There is no mapping from the specific TM/input pair H(D,D) to Halts(D,D)

>
Which isn't the mapping the question asks about.
>

The same question exists in a hierarchy of generality to specificity.
There is a mapping from    D(D) to Halts(D,D).
There is a mapping from H1(D,D) to Halts(D,D)
There is no mapping from H(D,D) to Halts(D,D)

>
YOU ARE JUST BEING STUPID.
>
The Question, Does the Computation Described by your inpt (in this case D(D) ) halt when run does NOT ask about a mappig from anything OTHER than D(D) to Halts (D,D)
>

>
This is simply a degree of detail that you choose to ignore.
There is a mapping from H1(D,D) to Halts(D,D)==1
There is no mapping from H(D,D) to Halts(D,D)???
>

H1(D,D) or H(D,D) are NOT "more specific" thatn D(D) when asking about D(D)
>
And you are just a stupid pathological liar for saying so.
>
Where on earth do you get that H1 or H are in ANY WAY a "stand-in" for the behavior of the input they are trying to decide on.
>
They are the thing being TESTED.
>
You are just showing your TOTAL and UTTER STUPIDITY here.
>
>

>

That would be mre like what decider gets the Halting Question right the pathological input?
>
Not, Does the input Halt when run?
>
Look at the wrong question and of course you get the wrong answer.
>
And repeatedly doing that is just another form of DECEPTION and LYING.
>
The QUESTION ask for the mapping of D D -> {Halting, Non-Halting}
>
anything else is just a LIE.
>

isomorphic to
mapping from specific_unmarried_man to stopped_beating_wife(YES/NO)
>

The question ask for the mapping from D,D to Halts(D,D), which exists.
Remeber, the question is, and only is:
>

That is not the question that H(D,D) is being asked.

>
So, you continue to lie about that.
>
I guess you are just incurably stupid.
>
Do you still remember the question of the Halting Problem?
>
THE REAL ONE
>

The same as the specific_unmarried_man
>
The logical law of polar questions
Feb 20, 2015, 11:38:48 AM  sci.lang
>
When posed to a man whom has never been married,
the question: Have you stopped beating your wife?
Is an incorrect polar question because neither yes nor
no is a correct answer.
>

Does the Machine and Input described by the input Halt when run.
>
Thus, H only gets ivolved when we are CHECKING the answer.
>

(b) Specific unmarried_man to stopped_beating_wife(YES/NO)
>
(a) and (b) are isomorphic.

>
Only in that H doesn't exist, as oesn't the man's wife.
>

They are both YES/NO questions lacking a correct YES/NO answer.
>

>

>
Although there is a mapping from some TM/input pairs to YES/NO
there is no mapping from H/D to YES/NO
thus the question is incorrect for H/D
>

>
But the question isn't mapping H/D, it is mapping the Machine described by the input (and its input) to if it reaches a final state, which has

>
That <is> one half of the mapping.
To be isomorphic
mapping from specific_unmarried_man to stopped_beating_wife(YES/NO)
we must have mapping from specific TM: H(D,D) to Halts(D,D)

>
Which is just a Red Herring, because we are NOT asking about what H does, but about what its input represents and what H needs to do to be correct.
>

>

an answer, depend on the specifics of the problem, that needed to have specifed before you could ever actually ask the question.
>
You are just LYING about what the question actually is.
>

It now seems to me that you never were lying.
The philosophical foundation of these things is very difficult.
>
It is when you and others ridiculously disagreed with the dead
obvious totally verified facts of the actual behavior behavior
of H1(D,D) and H(D,D) that gave me sufficient reason to conclude
that you and others were lying.
>
The actual truth seems to be that you and others were so biased
against my position on that you and others persistently ignored
my proof that I was correct many many dozens of times.

>
No, we are biased to the truth.
>

>
Even when I said show me the error in the execution trace many
many times you and others totally failed.
>

>
But the queston isn't about the execution trace,

>
Yes it always was.
*You disagreed that H(D,D)==0 and H1(D,D)==1 did what they actually did*
You disagreed with the proven facts.

>
How is it about the execution trace of what H or H1 sees?
>

*You disagreed that H(D,D)==0 and H1(D,D)==1 did what they actually did*
Every step of exactly what they did with D is shown proving the simulation was correct and you denied this anyway.
>

>
Since the question is about the behavior of D(D), that is the ONLY thing that really matters.
>

>
Great, I am glad that you see this too.
>

The traces might help us figure outwhy H got the answer wrong, but CAN'T prove it right, for the ACTUAL QUESTION that you imply is what you are working on.
>

The traces prove that this is correct H(D,D)==0 and H1(D,D)==1
You always disagreed with the facts of that. This was the reason
that I mistook you and others for liars.

>
The traces prove that H(D,D) returns 0. The traces do not prove that 0 is the correct answer for a halting decider when (D,D) is the input.
>
The following is a correct statement:
H(D,D) returns 0.
>
The following is an incorrect statement:
A halting decider returns 0 when (D,D) is the input.

>
The traces prove that H(D,D) returns 0 and H1(D,D) returns 1 and
Richard and many others kept insisting that it was impossible for
it to do what it actually did do, directly denying the easily
verified facts many many dozens of times.
>
*This is why I called all these people despicable liars*
>

>
>
It is IMPOSSIBLE for them to do so IF they were two copies of the same computation, as you claimed.
>

>
I never claimed that they were the same computation, you simply falsely
assumed that on the basis that you adamantly refused to look at the
proof that H1(D,D) and H(D,D) did correctly do exactly what I said that
they did.

>
Yes you did!
>

>

Omitting that qualification just makes your statement a blatant lie.
>

I challenge you to find where I ever said that they are the same
computation.

>
If they weren't then why would you bring H1 up and claim that made H right?
>

>
In other words you know that I never said that they are the same computation, thus I am not the Liar here.
>

>
Nope, I know what you said.
>
Authorize payment of search time, and I wll work on it,
>
I don't work for free.
>
>

>
*I say that I never said that and that you are mistaken yet not lying*
Now that we both understand how H(D,D) and H1(D,D) do compute different
results your claims to the contrary have been fully refuted.

>
And you are just lying about that.
>
Nope, you are just shown to continue the lies.
>
Are you willing to committ to say a 50k bounty (+ collection costs if you don't pay) if I can show your implied and agreed that they were?
>

You make a claim.
I claim you are mistaken.
You can either find the quote and refute me or we drop it as unresolved.

>
We can drop it as it isn't really important.
>

>

>
That you never reviewed the execution traces proving that the steps
of simulation were always correct seemed so ridiculously disingenuous
that this seemed to be a sufficient basis for calling you (and others)
a liar at the time. I now accept that you are not a liar.
>
>

>
But I have, and even commented on them, so you are just mistaken there.

>
You never looked at them well enough to confirm that
H1(D,D) and H(D,D) were simulated correctly.
>

>
Nope, in fact I frequently pointed out that H FAILED to correctly simulate as its simulation of the CALL H assumed that H would not return.
>

The execution traces prove that HH(D,D) must abort and H1(D,D) need not abort.

 Yes, if H was different, and thus the WHOLLE PROBLEM is different, an H that doesn't abort shows that everything gets caught in an infinite loop.
 This does NOT mean that for an H that aborts, it has to abort, as it is looking at a DIFFERENT problem.
 H1 PROVES that the outer H doesn't need to abort the simulation of the D calling an H that does.
 H just can't do two different things, so is on the horns of a dilemma.
 

>

There were MANY arguments where you tried to claim that a partial simulation of N steps WAS a correct simulation that allowed it use to show non-halting.

>
As soon as H(D,D) sees a 100% definite non-halting behavior pattern then H(D,D) must abort the simulation of its input.

 How can it be 100% definite non-halting behavior when you admit that D(D) halts even though it has the pattern in it (And H1 verifies it)
 It may be you can try to claim "Needs to abort" with some strained definitions, but it can't be a correct Halting Determination, which is what the actual problem is.
 

>
*That 100% definite non-halting behavior pattern is shown below*
>
  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00001d22][00102fc9][00000000] 55         push ebp        ; begin main()
[00001d23][00102fc9][00000000] 8bec       mov ebp,esp
[00001d25][00102fc5][00001c22] 68221c0000 push 00001c22   ; push DD
[00001d2a][00102fc1][00001c22] 68221c0000 push 00001c22   ; push DD
[00001d2f][00102fbd][00001d34] e80ef6ffff call 00001342   ; call HH
New slave_stack at:10306d
>
Begin Local Halt Decider Simulation   Execution Trace Stored at:113075
[00001c22][00113061][00113065] 55         push ebp        ; begin DD
[00001c23][00113061][00113065] 8bec       mov ebp,esp
[00001c25][0011305d][00103031] 51         push ecx
[00001c26][0011305d][00103031] 8b4508     mov eax,[ebp+08]
[00001c29][00113059][00001c22] 50         push eax        ; push DD
[00001c2a][00113059][00001c22] 8b4d08     mov ecx,[ebp+08]
[00001c2d][00113055][00001c22] 51         push ecx        ; push DD
[00001c2e][00113051][00001c33] e80ff7ffff call 00001342   ; call HH
New slave_stack at:14da95

 Note, incorrect simulation follows, should be a simulation of H simulating its input
 

[00001c22][0015da89][0015da8d] 55         push ebp        ; begin DD
[00001c23][0015da89][0015da8d] 8bec       mov ebp,esp
[00001c25][0015da85][0014da59] 51         push ecx
[00001c26][0015da85][0014da59] 8b4508     mov eax,[ebp+08]
[00001c29][0015da81][00001c22] 50         push eax        ; push DD
[00001c2a][0015da81][00001c22] 8b4d08     mov ecx,[ebp+08]
[00001c2d][0015da7d][00001c22] 51         push ecx        ; push DD
[00001c2e][0015da79][00001c33] e80ff7ffff call 00001342   ; call HH
Infinite Recursion Detected Simulation Stopped return 0 to main()
>
>

 Which is incorrect
 Since if H does this (returns 0), then the above call to H will also be returned to.
 Unless of course, H isn't actually a computation and thus you have been lying for years.
 You did try to do that, so I won't put you past trying it again.

*I more clearly prove that I have never lied in this post*
[Proof that H(D,D) meets its abort criteria]
That you have simply ignored this every time that I presented it
is so ridiculously disingenuous that I was reasonably justified
(yet incorrect) to call you a liar.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer