On 5/5/2022 8:17 PM, Dennis Bush wrote:
> On Thursday, May 5, 2022 at 9:06:12 PM UTC-4, olcott wrote:
>> On 5/5/2022 5:42 PM, Dennis Bush wrote:
>>> On Thursday, May 5, 2022 at 6:28:10 PM UTC-4, olcott wrote:
>>>> On 5/5/2022 5:06 PM, Dennis Bush wrote:
>>>>> On Thursday, May 5, 2022 at 5:47:07 PM UTC-4, olcott wrote:
>>>>>> On 5/5/2022 1:52 PM, Dennis Bush wrote:
>>>>>>> On Thursday, May 5, 2022 at 2:39:16 PM UTC-4, olcott wrote:
>>>>>>>> On 5/5/2022 12:28 PM, Dennis Bush wrote:
>>>>>>>>> On Thursday, May 5, 2022 at 1:17:38 PM UTC-4, olcott wrote:
>>>>>>>>>> On 5/5/2022 7:27 AM, Malcolm McLean wrote:
>>>>>>>>>>> On Thursday, 5 May 2022 at 12:54:54 UTC+1, richar...@gmail.com wrote:
>>>>>>>>>>>> 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.
>>>>>>>>>>>>
>>>>>>>>>>> In parapsychology, there's something called "the experimenter effect". The same
>>>>>>>>>>> experiment will show a parapsychological effect or not, depending on who is
>>>>>>>>>>> performing the experiment. This has been described as parapsychology's one finding.
>>>>>>>>>>> If true in an interesting way, it also strikes at the heart of the scientific method.
>>>>>>>>>>>
>>>>>>>>>>> But intuitively, it's not implausible that an experiment would "work" for an experimenter
>>>>>>>>>>> with gypsy blood, for example. You can't simply reject the experimenter effect on the
>>>>>>>>>>> basis that, if it means more than that certain experimenters are more gullible than
>>>>>>>>>>> others, it leaves the rest of science in tatters.
>>>>>>>>>>>
>>>>>>>>>>> PO says that a machine has one behaviour when run, and another behaviour when
>>>>>>>>>>> "correctly simulated". That claim, if true, similarly leaves the whole of computer science
>>>>>>>>>>> in tatters. Which means that it's his responsibility to provide a much better explanation
>>>>>>>>>>> of what he means than he has done currently.
>>>>>>>>>>>
>>>>>>>>>>> But he's been clear about this. He's asserting what anyone who knows just a tiny amount
>>>>>>>>>>> about computers must consdier to be nonsense. At first glance. But the idea that
>>>>>>>>>>> i^2 = j^2 = k^2 = -1 whilst ijk also = -1 also seems like nonsense at first glance. The
>>>>>>>>>>> difference is that more details were forthcoming.
>>>>>>>>>> Anyone knowing the x86 language can verify that H(P,P) and H1(P,P)
>>>>>>>>>> compute the mapping from their input parameters to their own final state
>>>>>>>>>> correctly. Arguing with verified facts is a fools folly.
>>>>>>>>>
>>>>>>>>> So in other words, a decider is always correct about what it's own input does.
>>>>>>>>>
>>>>>>>> Yes this is an easily verified fact on the basis of the execution trace
>>>>>>>> derived from the correct simulation of its input parameters.
>>>>>>>>> If you believe that to be true, then you also believe that anyone knowing the x86 language can verify that Ha3(N,5) correctly computes the mapping from its input to a non-halting state.
>>>>>>>>>
>>>>>>>> H2(Ha3,N,5) would get the correct halt status for Ha3.
>>>>>>>>
>>>>>>>> From what I recall Ha3(N,5) is merely a computation that was defined to
>>>>>>>> make sure it gets the wrong answer. If you disagree then remind me again
>>>>>>>> what it means.
>>>>>>>
>>>>>>> Ha3 uses as its abort criteria any computation that proceeds for more that 3 steps.
>>>>>> WHAT ARE YOU NUTS ???
>>>>>>
>>>>>> Trying to push total bullshit likes this proves that you are only a
>>>>>> troll playing head games and an honest dialogue is the last thing on
>>>>>> your mind.
>>>>>>
>>>>>
>>>>> Not at all, I'm just illustrating the flaws in your logic, as you can't show that Ha3 is wrong without also showing that H is also wrong....
>>>>>
>>>>>> A halt decider must simulate its input until it can prove that the
>>>>>> simulation would never end.
>>>>>
>>>>> ... just like this.
>>>>>
>>>>> What you states above is sufficient to show that Ha3(N,5) is not correct to abort, and Ha7(N,5) simulating to a final state and reporting halting proves that Ha3 didn't simulate for long enough.
>>>> OK finally back to an honest dialogue.
>>>
>>> It always was. You're apparently unable to see where I was going with this.
>>>
>>>>>
>>>>> Now let's apply that to H(P,P).
>>>>>
>>>>> H(P,P) is not correct to abort, and H1(P,P) simulating to a final state and reporting halting proves that H didn't simulate for long enough.
>>>>>
>>>>> Therefore H(P,P) == false is provable INCORRECT.
>>>> It is easily proven on the basis of verified facts that H(P,P) and
>>>> H1(P,P) do correctly compute the halt function for their input parameters.
>>>
>>> You don't seem to understand. H1 proves that H is wrong
>> Both H(P,P) and H1(P,P) correctly compute the mapping from their input
>> parameters to the halt status specified by these inputs.
>
> FALSE. Remember, you said:
>
> A halt decider must simulate its input until it can prove that the simulation would never end.
>
> Proving that the simulation would never end means that NO simulator can simulate that input to a final state.

You continue to believe that your imagination overrules verified facts:

That the correct simulation of the input to H(P,P) provably would never
end conclusively proves that H(P,P)==false is correct.

You must be really dumb, oh wait we know otherwise by you top 0.02%
rating, then dishonest (probably) or psychotic (probably not).

--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer