On 7/29/2021 12:00 AM, André G. Isaak wrote:
> On 2021-07-28 22:31, olcott wrote:
>> On 7/28/2021 11:15 PM, André G. Isaak wrote:
>>> On 2021-07-28 21:51, olcott wrote:
>>>> On 7/28/2021 6:36 PM, André G. Isaak wrote:
>>>>> On 2021-07-28 14:06, 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
>>>>>
>>>>> That's the DEFINITION of halting, so of course that's the only
>>>>> thing we should base the decision of whether P halts on.
>>>>>
>>>>
>>>> This is equally the definition of not halting:
>>>> Every input to a simulating halt decider that only stops running
>>>> when its simulation is aborted unequivocally specifies a computation
>>>> that never halts.
>>>
>>> No, it isn't a definition of halting. At best, it is something which
>>> you have proposed as a *test* for halting, but it is a broken test
>>> since, at least according to you, it sometimes gives an answer that
>>> does *not* correspond to the *actual* definition of halting.
>>>
>>
>> It is computationally equivalent to not halting.
>
> By the definition of halting, P(P) halts.
>
> According to you, your definition leads to the conclusion that P(P)
> doesn't halt.
>
> They cannot be equivalent if they lead to different results (and I have
> no idea why you use the expression 'computationally equivalent').
>

We have two different equally correct definitions of halting that have a
contradictory result thus proving garbage in garbage out.
Self-contradictory inputs derive contradictory conclusions.

>>>
>>>>>> 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.
>>>>>
>>>>> I fail to see any parallels between P and the liar.
>>>>>
>>>>>> When we explicitly take into account the self-contradictory nature
>>>>>> of these two cases things are not as cut-and-dried.
>>>>>
>>>>> There's nothing self-contradictory about it.
>>>>>
>>>>>> "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
>>>>>
>>>>> That is gibberish.
>>>>>
>>>>>> then we get a contradiction. If it is true that it is not true
>>>>>> then that makes is not true.
>>>>>>
>>>>>> 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
>>>>>
>>>>> But the definition of halting makes no reference to what H does at
>>>>> all, nor to pure simulators. whether P(P) halts is based solely on
>>>>> the behaviour of P(P).
>>>>>
>>>>
>>>> The definition of UTM does make reference to computational
>>>> equivalence forcing this statement to be necessarily true:
>>>
>>> Please show me a definition of UTM which makes reference to
>>> computational equivalence.
>>>
>>
>> The simulation of the TM description of TM P on input I is stipulated
>> to be computationally equivalent to P(I). In an honest dialogue I
>> would not have to repeat this fifty times.
>
> I asked you to show me a *definition* of UTM which refers to
> computational equivalence. The above is not a definition.

Perhaps you are proving that you are unqualified to evaluate my work?
....anything which can be “computed”, can also be computed by that one
universal machine. Conversely, any problem that is not computable by the
universal machine is considered to be uncomputable.
https://plato.stanford.edu/entries/turing-machine/#TuriUnivMach

>>>> Every input to a simulating halt decider that only stops running
>>>> when its simulation is aborted unequivocally specifies a computation
>>>> that never halts.
>>>
>>> A 'simulating halt decider' and UTM are different things.
>>>
>>
>> Not while the simulating halt decider is in pure simulator mode.
>
> UTM(P, P) halts.
>
> You claim that your 'simulating halt decider in pure simulator mode'
> doesn't halt on input P, P.
>

Which is another way of saying:
Every input to a simulating halt decider that only stops running when
its simulation is aborted unequivocally specifies a computation that
never halts.

> Therefore they are not the same thing.
>
> And why does it matter what happens in a 'simulating halt decider in
> pure simulator mode'?
>
> The definition of halting is only concerned with what the computation
> P(P) does, not with what happens inside a 'simulating halt decider in
> pure simulator mode'.
>

None-the-less my definitions are computationally equivalent to the
standard ones on this basis: UTM(P,I) ≡ P(I)

That you deny this seems to indicate that you do not know the subject
matter well enough to be qualified to evaluate my work.

>>>>>> remains a pure simulator until after it makes its halt status
>>>>>> decision then its decision that its input never halts is
>>>>>> necessarily correct.
>>>>>>
>>>>>> 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. That the first P reaches its final state means that P(P) halts.
>>>>> The definition of halting doesn't care how or why it reaches this
>>>>> state. Only that it does.
>>>>
>>>> So then we must conclude the the self contradictory input causes the
>>>> logic of the system to be inconsistent because it proves that P
>>>> halts and it proves that P never halts.
>>>
>>> It shows the logic of the *decider* to be inconsistent. It doesn't
>>> show anything inconsistent about the definition of halting, nor does
>>> it provide to treat a computation which halts as anything other than
>>> a computation which halts.
>>>
>>
>> Within the hypothesis that this is correct:
>> Within the hypothesis that this is correct:
>> Within the hypothesis that this is correct:
>> Within the hypothesis that this is correct:
>>
>> Every input to a simulating halt decider that only stops running when
>> its simulation is aborted unequivocally specifies a computation that
>> never halts.
>>
>> Then the fact that the first P of int main(){ P(P); } reaches its
>> final state wold seem to prove that we are getting the same
>> contradiction as the liar paradox.
>
> Bad logic on your part leads to bad results on your part. Your
> 'hypothesis' as you interpret it is *not* correct.
>
>> This make perfect sense:
>> garbage in  (self contradictory input)
>> garbage out (contradictory result).
>
> No. It does not make perfect sense since P(P) very clearly meets the
> actual definition of halting.

And in this exact same way the fact that the following sentence is not
true: "this sentence is not true" should make it true, but it does not.

>>     The input is defined to contradict whatever the halt decider decides
>>     Now we construct a new Turing machine D with H as a subroutine.
>>     This new TM calls H to determine what M does when the input to
>>     M is its own description ⟨M⟩. Once D has determined this information,
>>     it does the opposite.  (Sipser:1997:165)
>
> Where does a 'self-contradictory expression of language' appear in the
> above? Nowhere that I can see.
>

When we encode the above in C and this function is executed with input:
P its behavior contradicts every halt status that H can return.

void P(u32 x)
{ if (H(x, x))
HERE: goto HERE;
}

> André
>
> <snip remainder, including, asinine, juvenile repetition>
>
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein