On 7/27/21 8:24 AM, olcott wrote:
> On 7/27/2021 4:42 AM, Malcolm McLean wrote:
>> On Tuesday, 27 July 2021 at 04:55:26 UTC+1, André G. Isaak wrote:
>>> On 2021-07-26 21:31, olcott wrote:
>>>>
>>>>
>>>> I have explained this totally several times now.
>>>> if H(P,P) != P(P)
>>>> incorrect input
>>>> else
>>>> correct input.
>>> Will you please explain what is meant by H(P,P) != P(P)?
>>>
>>> As written, it mean 'if the result returned by H(P, P) does not equal
>>> the result returned by P(P)', but as I said I *think* by P(P) you
>>> actually mean 'the halting status of P'.
>>>
>>> If that is what you mean then how is H(P,P) != P(P) supposed to be
>>> evaluated *by a Turing Machine*? Rice's Theorem is about what can be
>>> computed, not just about things that can be stated.
>>>
>>> H(P, P) gets P(P) wrong, but it doesn't *know* that it gets this wrong
>>> (otherwise you'd be able to easily fix H to get it right).
>>>
>> We've had a development. The claim that H(P,P) = false is correct when
>> P(P) halts has been modified.
>> Now we run H on P(P), and run P(P). If they match, then obviously H has
>> done its job. If they don't, then that means that the input is
>> "pathological".
>> The special case suggested by Linz has been detected.
>>
>> There are snags with this approach, of course. For example, if P(P) is
>> non-halting, how would you know when to terminate it?  Ben said that
>> this suggestion always comes up (UCL is a pretty high status university
>> with the UK that attracts intelligent students).
>
> No one has ever gotten as far as I have. No one has ever previously
> shown that the input to a simulating halt decider specifies infinitely
> nested simulation to this halt decider in the HP counter-example cases.

Except that you haven't, in fact, you have provided a trace that shows
that P(P) does NOT specify an infinitely nested simulation for any H
that answers H(H^,H^) as non-halting.

>
> Any rebuttals to this assertion require complete citations.

(Maybe YOU should start citing sources for your 'obvious' claims)

On 4/27/21 12:55 AM, olcott wrote:
Message-ID: <Teudndbu59GVBBr9nZ2dnUU7-V2dnZ2d@giganews.com>
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> }
>
>
> int main()
> {
> H_Hat((u32)H_Hat);
> }
>
>
> _H_Hat()
> [00000b98](01) 55 push ebp
> [00000b99](02) 8bec mov ebp,esp
>
[00000b9b](01) 51 push ecx
> [00000b9c](03) 8b4508 mov eax,[ebp+08]
> [00000b9f](01) 50 push eax
> [00000ba0](03) 8b4d08 mov ecx,[ebp+08]
> [00000ba3](01) 51 push ecx
> [00000ba4](05) e88ffdffff call 00000938
> [00000ba9](03) 83c408 add esp,+08
> [00000bac](03) 8945fc mov [ebp-04],eax
> [00000baf](04) 837dfc00 cmp dword [ebp-04],+00
> [00000bb3](02) 7402 jz 00000bb7
> [00000bb5](02) ebfe jmp 00000bb5
> [00000bb7](02) 8be5 mov esp,ebp
> [00000bb9](01) 5d pop ebp
> [00000bba](01) c3 ret
> Size in bytes:(0035) [00000bba]
>
> _main()
> [00000bc8](01) 55 push ebp
> [00000bc9](02) 8bec mov ebp,esp
> [00000bcb](05) 68980b0000 push 00000b98
> [00000bd0](05) e8c3ffffff call 00000b98
> [00000bd5](03) 83c404 add esp,+04
> [00000bd8](02) 33c0 xor eax,eax
> [00000bda](01) 5d pop ebp
> [00000bdb](01) c3 ret
> Size in bytes:(0020) [00000bdb]
>
> ===============================
> ...[00000bc8][001015d4][00000000](01) 55 push ebp
> ...[00000bc9][001015d4][00000000](02) 8bec mov ebp,esp
> ...[00000bcb][001015d0][00000b98](05) 68980b0000 push 00000b98
> ...[00000bd0][001015cc][00000bd5](05) e8c3ffffff call 00000b98
> ...[00000b98][001015c8][001015d4](01) 55 push ebp
> ...[00000b99][001015c8][001015d4](02) 8bec mov ebp,esp
> ...[00000b9b][001015c4][00000000](01) 51 push ecx
> ...[00000b9c][001015c4][00000000](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][001015c0][00000b98](01) 50 push eax
> ...[00000ba0][001015c0][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][001015bc][00000b98](01) 51 push ecx
> ...[00000ba4][001015b8][00000ba9](05) e88ffdffff call 00000938
> Begin Local Halt Decider Simulation at Machine Address:b98
> ...[00000b98][00211674][00211678](01) 55 push ebp
> ...[00000b99][00211674][00211678](02) 8bec mov ebp,esp
> ...[00000b9b][00211670][00201644](01) 51 push ecx
> ...[00000b9c][00211670][00201644](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][0021166c][00000b98](01) 50 push eax
> ...[00000ba0][0021166c][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][00211668][00000b98](01) 51 push ecx
> ...[00000ba4][00211664][00000ba9](05) e88ffdffff call 00000938
> ...[00000b98][0025c09c][0025c0a0](01) 55 push ebp
> ...[00000b99][0025c09c][0025c0a0](02) 8bec mov ebp,esp
> ...[00000b9b][0025c098][0024c06c](01) 51 push ecx
> ...[00000b9c][0025c098][0024c06c](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][0025c094][00000b98](01) 50 push eax
> ...[00000ba0][0025c094][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][0025c090][00000b98](01) 51 push ecx
> ...[00000ba4][0025c08c][00000ba9](05) e88ffdffff call 00000938
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Above decision was from the call the Halts inside H_Hat, deciding that
H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
processed below:

> ...[00000ba9][001015c4][00000000](03) 83c408 add esp,+08
> ...[00000bac][001015c4][00000000](03) 8945fc mov [ebp-04],eax
> ...[00000baf][001015c4][00000000](04) 837dfc00 cmp dword [ebp-04],+00
> ...[00000bb3][001015c4][00000000](02) 7402 jz 00000bb7
> ...[00000bb7][001015c8][001015d4](02) 8be5 mov esp,ebp
> ...[00000bb9][001015cc][00000bd5](01) 5d pop ebp
> ...[00000bba][001015d0][00000b98](01) c3 ret
> ...[00000bd5][001015d4][00000000](03) 83c404 add esp,+04
> ...[00000bd8][001015d4][00000000](02) 33c0 xor eax,eax
> ...[00000bda][001015d8][00100000](01) 5d pop ebp
> ...[00000bdb][001015dc][00000098](01) c3 ret

SEE IT HALTED!

> Number_of_User_Instructions(39)
> Number of Instructions Executed(26567)

Since P(P) is shown to be Halting, any accurate simulation of P(P) will,
by definition, Halt.

Your error is that you start to argue about a DIFFERENT question,

>
> Since no one has ever previously accomplished this key insight this
> makes it impossible that anyone created any software system that
> correctly recognizes and reports this infinitely nested simulation.

>
> When the global simulator reports that the P of int main(){ P(P); }
> halts this is encoded here as P(P)==1
>
> When the local partial halt decider H reports that P(P) never halts
> this is encoded here as H(P,P)==0
>
> When they are out-of-sync for inputs with the pathological
> self-reference(Olcott 2004) error we say P(P) != H(P,P)

I.E. H was wrong.

>
> We will show that this error is exactly the same as the Liar Paradox in
> that both Boolean values are contradicted.

Wrong. The question is "Does the Machine H^(H^) Halt when run, for a
GIVEN H?" That question has a specific unique answer, so it is NOT the
liar paradox.

If H(P,P) == 0, the then answer to the question is that H^(H^) does
Halt, and a different Halt decider could give this answer.

The fact that H can't give the answer is NOT a Liar's paradox, because
the Halting Problem Question is NOT What can H return to be right, but
what does H^ do for given H^ machine (which implies a given H)

>
> When P(P) != H(P,P) if we change H(P,P)==0 to correspond with P(P)==1
> then the P of int main(){ P(P); } never halts.

And that is a DIFFERENT set of machines for which H is wrong because
that H never returns an answer for H(P,P).

>
> Because P was intentionally defined to do the opposite of whatever
> halt status value that H reports neither Boolean value is correct.

Right, the TEMPLATE H^ is constructed so that

>
> This is exactly the same result as the Liar Paradox.

WRONG, see above. It only generates the Liar Paradox if you look at the
DESIGN question of what can H do to beat this template, and this shows
that it is impossible for an H to exist that gets the answer right.

I.E, There does not exist an H that can get the H^ template right,
therefor you have just ESTABLISH that Linz is right.

>
> Because it is true that no P ever halts unless some P is aborted it
> still seems to me that H(P,P)==0 is correct and the fact that the P of
> int main(){ P(P); } halts is the error.

No, P(P) Halts because that is what its algorithm says it should do. It
isn't an error. It just shows that you logic is in error

>
> Because no P ever halts unless some P is aborted seems to prove that int
> main(){ P(P); } specifies a non-halting computation.

NO. UNSOUND LOGIC.

>
>> The suggestion is to detect
>> the Linz input and special case it.
>>
>
> I don't even have to write any more code. Whenever a human sees that
> H(P,P) reports 0 and the P of int main(){ P(P); } reaches its final
> state we know this is a case of the self-contradictory input
> pathological self-reference(Olcott 2004) error.
>

UNCOUND LOGIC.

> Applying this same idea to a fully elaborated complete halt decider
> would derive a halt decider where the only time that the input reaches a
> final state and the halt decider reports that this input never halts are
> the self-contradictory input pathological self-reference(Olcott 2004)
> error cases.
>
>

UNSOUND LOGIC. You are basically trying to redefine 'correct' to say
that wrong answers are right because I can't give a right answer, rather
than admit that you can't be right.

WHen you can show that wrong == right, then you have just proved that
your logic system has gone inconsistent and is worthless.