On 7/28/21 1:06 PM, olcott wrote:
> On 7/28/2021 1:40 PM, André G. Isaak wrote:
>> On 2021-07-28 10:38, olcott wrote:
>>> On 7/28/2021 10:31 AM, André G. Isaak wrote:
>>>> On 2021-07-28 08:09, olcott wrote:
>>>>> On 7/27/2021 10:39 PM, André G. Isaak wrote:
>>>>
>>>>>> So does P(P) halt or not?
>>>>>>
>>>>>
>>>>> Even though the first P in the invocation sequence reaches its
>>>>> final state the fact that it only reaches its final state because
>>>>> the second P in the invocation sequence was aborted proves that
>>>>> H(P,P)==0 is correct.
>>>>
>>>> If a car only crashes because its brakes failed, that does not imply
>>>> that it didn't crash.
>>>>
>>>> If a program returns the wrong result only because it has a bug,
>>>> that does not imply that it didn't return the right answer.
>>>>
>>>> If a program only halts because the second P was aborted, that does
>>>> not imply that it didn't halt.
>>>>
>>>
>>> If an infinitely recursive sequence of function calls is aborted on
>>> the second call instead of the first call that does not mean that it
>>> was not an infinitely recursive sequence.
>>
>> But the definition of halting makes no mention of infinitely recursive
>> sequences or aborted function calls. It only requires that P(P) reach
>> a final state in a finite amount of time. P(P) meets this definition.
>>
>
> If we base the decision on whether or not P halts entirely on the fact
> that it reaches its final state then we have the same situation as "This
> sentence is not true." It is indeed not true and the definition of a
> true sentence is whether or not its assertion is satisfied.

No, that is NOT true. Remember, to ask the Halting Question, does P(I)
Halt when run or not, P has to be specified, thus if P is H^, then H^
has to be specified, and by the definition of H^, H has to be specified.

Thus, arguments like, 'What should H return?' are improper at this
point. H HAS been specified to get here, so that answer might have been
asked earlier, but its answer has been chosen.

Given that, The question 'Does H^(H^) Halt when run?' has definitive answer.

If H(H^,H^) returns non-halting, then by the rules of constructing H^
then H^(H^) will Halt.

If H*H^,H^) returns halting, then by the rules of constructing H^ then
H^(H^) will fall into an infinite loop.

These are the ONLY possibilities for an H that meets the requirements of
a decider. And in both cases H is wrong.

The other possibilities are H(H^,H^) might get stuck in an infinite
loop, in which case H^(H^) will also be non-halting, or H(H^,H^) might
Halt in some other state and not answer, making H^(H^) also Halt. In
both of these cases H fails to even meet the requirements of a decider.

In both of the first two cases, It is quite easy to build a decider to
get the answer right (since H^ is built on the original H, not this new
decider), so it isn't true that there is no possible answer as in the
liar's paradox.

>
> When we explicitly take into account the self-contradictory nature of
> these two cases things are not as cut-and-dried.
>
> "This sentence is not true." is indeed not true yet when we apply this
> to the satisfaction of the whole sentence and not just its assertion
> then we get a contradiction. If it is true that it is not true then that
> makes is not true.

The difference it the statement "This sentence is not true" can not be
assigned a valid truth value.

The question "Does H^(H^) Halt when run (for a SPECIFIC H)?" Has a
specific answer, and this answer is even Provably true if we can prove
what answer H(H^,H^) will give.

Thus, your argument is WRONG, The Halting Question is NOT Paradoxical,
or Pathelogical.

>
> It is an easily verifiable fact that the input to H(P,P) cannot possibly
> reach its final state while H remains a pure simulator. Because H
> remains a pure simulator until after it makes its halt status decision
> then its decision that its input never halts is necessarily correct.

Right, but it doesn't prove the statement you want it to, all it proves
is that no H can actually PROVE that H^(H^) is Halting. This does NOT
show that H^(H^) is non-halting. That can be proved, for H(H^,H^) saying
non-halting, but just running or simulating H^(H^), which shows it halts.

You are adding the FALSE premise that all Truth is Provable.

>
> That the first P in the infinitely recursive sequence reaches its final
> state after H has made its correct halt status decision is just like
> saying the liar paradox is true on the basis that its assertion is
> satisfied.

No. UNSOUND LOGIC.

P Halting shows that P IS a Halting Computation.

That No H can simulate to this just shows that no H can prove this answer.

Since Truth is NOT always provable, this is a perfectly fine results.

In fact, your argument basically proves this fact, we have a result that
is Provably true with a larger logic, but within the logic of H, the
fact that H^(H^) is Halting is not Provable.

>
>>>>> Because this is too difficult to understand and accept I have
>>>>> temporarily changed the subject to refuting Rice's theorem. The
>>>>> fact that the first P reaches its final state and the second P is
>>>>> aborted can   be used as the criterion measure to consistently
>>>>> reject all and only self-contradictory inputs. This does refute
>>>>> Rices theorem.
>>>>>
>>>>>> You have on the one hand acknowledged that it does, while at the
>>>>>> same time claimed that it doesn't halt in a 'pure simulator'. So
>>>>>> if your 'global simulator' is not a pure simulator, what kind of
>>>>>> simulator is it?
>>>>
>>>> You didn't answer the above. In the past you've claimed (falsely)
>>>> that in a pure simulator, P(P) doesn't halt.
>>>>
>>>
>>> While H remains a pure simulator of its input H(P,P) its input never
>>> halts thus proving that its input never halts.
>>
>> But the definition of halting makes no mention of what happens inside
>> H, regardless of whether it remains a 'pure simulator'. It only
>> requires that the actual computation P(P) reach a final state in a
>> finite amount of time. P(P) meets this definition.
>>
>>>> Now you appear to be using your 'global simulator' to recognise that
>>>> P(P) does halt so that you can compare this with the results of H(P,
>>>> P).
>>>
>>> It is still true that H(P,P) did correctly decide that its input
>>> never halts. Because this is difficult to understand I am temporarily
>>> changing the subject to Rice's theorem.
>>
>> No, it is not. The definition of halting is clearly defined, and P(P)
>> clearly meets the definition of halting. Rice's theorem has no bearing
>> on the fact that P(P) is halting computation.
>>
>
> In this exact same way we would have to say that the liar paradox is
> true because its assertion that it is not true is fully satisfied.
>
> Whenever the assertion of a declarative sentence is satisfied we know
> that this declarative sentence is true unless this declarative sentence
> is self-contradictory.
>
> Whenever H decides that its input never halts its input never reaches a
> final state. When its input is self-contradictory then another different
> instance of the program that is not an input to H may halt.

But the MACHINE the input represents DOES reach the Halting State, which
is the ACTUAL Question that H is supposed to be answering, and thus we
can PROVE that H^(H^) is Halting and that H(H^,H^) saying non-halting is
WRONG.

>
>>>> But if P(P) doesn't halt in a 'pure simulator' then what kind of
>>>
>>> I did not say that P(P) does not halt in a pure simulator, you must
>>> pay careful attention to every single word that I say. When you skip
>>> a single word that reverses the meaning of what I say.
>>>
>>> The input to H(P,P) never halts while H remains in pure simulator mode.
>>
>> So what's the difference between a 'pure simulator' and H running in
>> 'pure simulator mode'? One would have assumed that the latter meant
>> that H was acting as a pure simulator.
>>
>
> H is evaluating the halt status of its input on the basis of what the
> behavior of this input would be if H never aborts the simulation of this
> input.

Right, it is analysing its input under a FALSE assumption, and thus it
reaches an UNSOUND conclusion, and thus it can be WRONG.

>
> As Ben has unequivocally agreed any simulation that only halts because
> it was aborted is a non-halting computation.

Right, but that isn't what you have, you have a simulation that gets
aborted even though it didn't need to, as can be seen because UTM(H^,H^)
comes to a halt in finite time (at least if H(H^,H^) is non-halting).

Thus H was WRONG, because it didn't need to.

>
>>>> simulator is your 'global simulator' which, apparently, correctly
>>>> detects that P(P) halts?
>>>>
>>>
>>> It correctly detects that the P of int main() { P(P); } reaches its
>>> final state.
>>
>> Which means that P(P) meets the definition of halting and is therefore
>> a halting computation.
>>
>>>>>>> There will not actually be any function call Simulate(P,P) per
>>>>>>> say and this code has not been designed yet.
>>>>>>>
>>>>>>> The very easy part that you should have understood many messages
>>>>>>> ago is that when the code somehow determines that the halt
>>>>>>> decider return value is not consistent with the behavior of P
>>>>>>> this is freaking used to freaking refute Rice.
>>>>>> The problem is that H isn't doing the detecting. To the extent
>>>>>> that what you say makes sense it is some other software which
>>>>>> tests the result of H(P,P) against the result of your 'global
>>>>>> simulator'. But *that* piece of software will have its *own* H_Hat
>>>>>> which will be just as susceptible to the Linz proof as your H.
>>>>>>
>>>>>> Every putative halt decider has its *own* H_Hat which it will not
>>>>>> be able to decide, which is perfectly in line with Rice.
>>>>>>
>>>>>> André
>>>>>
>>>>> That each of these putative halt deciders recognize and reject all
>>>>> and only self-contradictory inputs refutes Rice.
>>>>
>>>> And you've demonstrated this where, exactly?
>>>>
>>>> As far as I can tell your H doesn't reject anything. It simply gets
>>>> some cases wrong.
>>>>
>>>
>>> The code to reject inputs has not even been fully designed yet.
>>
>> So why talk about it, then? Until you actually have it you're just
>> blowing smoke.
>>
>>> It is easy to see that the criteria for this already exists.
>>
>> No. It isn't.
>>
>>>> Your H(P, P) claims that P(P) doesn't halt, which is wrong.
>>>>
>>>
>>> The input to H(P,P) never halts while H remains in pure simulator mode.
>>
>> But the definition of halting makes no mention of what happens inside
>> H, regardless of whether it remains in 'pure simulator mode'. It makes
>> no mention of H at all. It only requires that the *actual* computation
>> P(P) reach a final state in a finite amount of time. P(P) meets this
>> definition.
>>
>> André
>>
>>>> You claim that you can reject this based on the fact that it doesn't
>>>> match which your 'global simulator' concludes.
>>>>
>>>> But that means that neither the global simulator nor H on their own
>>>> are capable of rejecting anything.
>>>>
>>>
>>> So what?
>>>
>>>> Whatever code is comparing these two values is what is doing the
>>>> rejecting. And we can construct from *that* piece of code another
>>>> H_Hat which *that* piece of code cannot answer correctly.
>>>>
>>>> André
>>>>
>>>
>>> I am not going to go down the path of infinitely nested operating
>>> systems.
>>>
>>
>>
>
> The bottom line is that self-contradiction must be treated differently,
> the conventional rules do not apply to self-contradiction.

Nope, Definitions are Definitions.

LIARS ARE LIARS.

> When the assertion of a declarative sentence is satisfied this makes the
> sentence true unless the sentence is self-contradictory.

Does H^(H^) Halt when run give that H(H^,H^) says Non-Halting? is a
PROVABLY TRUE STATEMENT.

>
> The fact that "This sentence is not true." is not true does not make the
> sentence true because the sentence is self-contradictory.
>
> When a simulating halt decider reports that its input does not halt then
> no instance of the same program ever reaches a final state unless the
> input program specifies self-contradiction.
>

WRONG.

UNSOUND LOGIC.

LIAR LIAR YOUR PANTS ARE ON FIRE.