On 5/4/22 11:54 PM, olcott wrote:
> On 5/4/2022 10:43 PM, Dennis Bush wrote:
>> On Wednesday, May 4, 2022 at 11:38:54 PM UTC-4, olcott wrote:
>>> On 5/4/2022 10:20 PM, Dennis Bush wrote:
>>>> On Wednesday, May 4, 2022 at 11:09:35 PM UTC-4, olcott wrote:
>>>>> On 5/4/2022 9:59 PM, Dennis Bush wrote:
>>>>>> On Wednesday, May 4, 2022 at 10:55:07 PM UTC-4, olcott wrote:
>>>>>>> On 5/4/2022 9:28 PM, Ben wrote:
>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>
>>>>>>>>> On 5/4/2022 7:59 PM, Ben wrote:
>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 5/4/2022 9:16 AM, Ben wrote:
>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 5/2/2022 6:10 PM, Ben wrote:
>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 5/2/2022 11:39 AM, Ben wrote:
>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is clear that the input to H(P,P) specifies
>>>>>>>>>>>>>>>>> infinitely nested
>>>>>>>>>>>>>>>>> simulation to H.
>>>>>>>>>>>>>>>> What two pointers must be passed to H for H to tell up
>>>>>>>>>>>>>>>> about the halting
>>>>>>>>>>>>>>>> of P(P)? If H can't report on the halting of the
>>>>>>>>>>>>>>>> computation P(P) it is
>>>>>>>>>>>>>>>> not a halt decider, and you have already told use that
>>>>>>>>>>>>>>>> H(P,P) == false
>>>>>>>>>>>>>>>> and that P(P) halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If H can report on the halting of non-input P(P) then it
>>>>>>>>>>>>>>> is not a
>>>>>>>>>>>>>>> decider because deciders only compute the mapping from
>>>>>>>>>>>>>>> inputs to final
>>>>>>>>>>>>>>> states.
>>>>>>>>>>>>>> TM deciders compute mappings from inputs to final states
>>>>>>>>>>>>>> /according to
>>>>>>>>>>>>>> some property of the inputs/
>>>>>>>>>>>>>
>>>>>>>>>>>>> That par is exactly correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> -- whether the input represents, for
>>>>>>>>>>>>>
>>>>>>>>>>>>> That part has been the key error of everyone in that they
>>>>>>>>>>>>> all believe
>>>>>>>>>>>>> that is can represent something other than what it actually
>>>>>>>>>>>>> specifies.
>>>>>>>>>>>>
>>>>>>>>>>>> So now, after thinking otherwise for years, you claim that
>>>>>>>>>>>> there is no
>>>>>>>>>>>> way to even specify the computation P(P) for you pseudo-C
>>>>>>>>>>>> halt decider
>>>>>>>>>>>> H. At least that is a clear admission that the halting of
>>>>>>>>>>>> function
>>>>>>>>>>>> calls like P(P) can not be decided because, apparently,
>>>>>>>>>>>> passing P and P
>>>>>>>>>>>> to H does not specify that computation, and you can't say
>>>>>>>>>>>> what two
>>>>>>>>>>>> arguments /would/ specify it.
>>>>>>>>>>>>
>>>>>>>>>>>> A clear and unambiguous statement that no D such that D(X,Y)
>>>>>>>>>>>> == true if
>>>>>>>>>>>> and only if X(Y) halts and false otherwise is possible would
>>>>>>>>>>>> be the
>>>>>>>>>>>> honest way to move things on. If you were clear about this,
>>>>>>>>>>>> maybe
>>>>>>>>>>>> someone will talk to you about [whatever] it is that your H is
>>>>>>>>>>>> deciding.
>>>>>>>>>> So you won't admit that no algorithm can do what D is
>>>>>>>>>> specified to do?
>>>>>>>>>> You are just going to pretend that no one cares about actual
>>>>>>>>>> halting.
>>>>>>>>>> I hope you see that by ignoring this point you are confirming
>>>>>>>>>> that you
>>>>>>>>>> know D can't exist. If you thought such a D was possible,
>>>>>>>>>> you'd be
>>>>>>>>>> shouting that from the roof tops since it's what everyone else
>>>>>>>>>> says is
>>>>>>>>>> impossible.
>>>>>>>>>>
>>>>>>>>>>> I adapted my system so that I could empirically test this:
>>>>>>>>>>> H1(P,P)==true is empirically proven to be correct
>>>>>>>>>>> H(P,P)==false is empirically proven to be correct
>>>>>>>>>>
>>>>>>>>>> But neither can tell us squat about the halting of P(P) -- the
>>>>>>>>>> thing
>>>>>>>>>> that H was originally supposed to decide.
>>>>>>>>>
>>>>>>>>> Are you simply wired to ignore my words so that you can
>>>>>>>>> disagree with
>>>>>>>>> everything that I say?
>>>>>>>>>
>>>>>>>>> H1(P,P)==true reports on the behavior of P(P).
>>>>>>>>
>>>>>>>> I try to ignore that bits that are irrelevant. These two deciders
>>>>>>>> decide all halting instances between them:
>>>>>>>>
>>>>>>>> bool H1(X, Y) { return true; }
>>>>>>>> bool H2(X, Y) { return false; }
>>>>>>>>
>>>>>>>> Neither is interesting. For H1, the key case is H1(H1_hat,
>>>>>>>> H1_hat) or
>>>>>>>> maybe you call it H1(P1,P1) now since P is what you used to call
>>>>>>>> H_hat.
>>>>>>>
>>>>>>> H1(P,P)==true is empirically proven to be correct
>>>>>>> H(P,P)==false is empirically proven to be correct
>>>>>>
>>>>>> If that is so then H and H1 don't perform the same mapping. This
>>>>>> means that one (or both) do not compute the halting function.
>>>>>>
>>>>>> So which one doesn't compute the halting function?
>>>>> *ALL THESE THINGS ARE EASILY VERIFIABLE FACTS*
>>>>> Both take the machine code of P as input parameters and are provably
>>>>> correct simulations of this same input yet one correctly determines
>>>>> that
>>>>> its input halts and the other correctly determines that its input does
>>>>> not halt.
>>>>
>>>> Which means at least one is not computing the halting function. So
>>>> which one is it?
>>>>
>>> The above paragraph means that it makes no mistakes in computing the
>>> halting function. This is a verifiable fact, not any mere opinion. The
>>> reason that I did the HP in C/x86 was so that every detail can be shown
>>> thus gaps in reasoning revealed.
>>
>> Any decider that maps the halting function performs the *same* mapping
>> of inputs to outputs.
>
> That is now proven to be factually incorrect.
>
> If the above paragraph is proven to be a fact then this proves that both
> H and H1 compute the halting function correctly. The above paragraph can
> be proven to be a fact.

Yes, IF you can prove that cats are dogs, you can prove that H is
correctly computing the Halting Function.

Since you can't, you can't.

In fact, you have just proven that you don't know what you are talking
about, since you just asserted a LIE.

Two machines claiming to compute the same function must generate the
same answer from the same input or one of them is incorrect.

BASIC FACT.

>
>>  Since H and H1 perform different mappings they can't possibly both
>> map the halting function.
>>
>> So which one doesn't?
>
>