On 5/5/2022 1:50 PM, Dennis Bush wrote:
> On Thursday, May 5, 2022 at 2:45:46 PM UTC-4, olcott wrote:
>> On 5/5/2022 1:03 PM, Dennis Bush wrote:
>>> On Thursday, May 5, 2022 at 2:01:28 PM UTC-4, olcott wrote:
>>>> On 5/5/2022 6:57 AM, Dennis Bush wrote:
>>>>> On Thursday, May 5, 2022 at 7:50:02 AM UTC-4, richar...@gmail.com wrote:
>>>>>> On 5/4/22 11:42 PM, olcott wrote:
>>>>>>> On 5/4/2022 10:38 PM, André G. Isaak wrote:
>>>>>>>> On 2022-05-04 21:35, olcott wrote:
>>>>>>>>> On 5/4/2022 10:17 PM, André G. Isaak wrote:
>>>>>>>>>> On 2022-05-04 21:09, 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:
>>>>>>>>>>
>>>>>>>>>>>>> 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?
>>>>>>>>>>
>>>>>>>>>> You didn't actually answer this question.
>>>>>>>>>>
>>>>>>>>>>> *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.
>>>>>>>>>>
>>>>>>>>>> Please define your use of the term "correct simulation".
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Good question.
>>>>>>>>> The behavior of the simulated input exactly matches the correct
>>>>>>>>> execution trace of the behavior in a real hardware machine.
>>>>>>>>
>>>>>>>> So if P(P), when executed directly, halts, how can a 'correct
>>>>>>>> simulation' possibly not halt?
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> As soon as you very carefully study every single detail of the above
>>>>>>> paragraph you will realize that it proves that I am correct as soon as
>>>>>>> the paragraph itself is proved to be factually correct.
>>>>>>>
>>>>>> No, it proves that you don't know what you are saying. The only machine
>>>>>> to use to "Correctly simulate the input (P,P) is P(P), sp that is what
>>>>>> must define the correct answer.
>>>>>>
>>>>>> If it looks at H, then by your definition ALL simulating decider are
>>>>>> "correct", as it is there simulation, no matter how awful, that defines
>>>>>> the answer.
>>>>>
>>>>> To PO: the above is exactly where the conclusion that Ha3(N,5) == false is coming from.
>>>> Ha3() is merely a decider that was intentionally designed to get the
>>>> wrong answer thus no evidence what-so-ever that a decider that gets the
>>>> right answer does not exist.
>>>
>>> Then you should have no problem specifying *exactly* how Ha3 gets the wrong answer in a generalized way that also describes how H(P,P) gets the right answer.
>> You know how it gets the wrong answer, you designed it that way.
>> TM's that are intentionally defined to get the wrong answer are off
>> topic please STFU about them.
>
> Ha3 was designed to follow the correctness criteria that you gave.
>
> So why does Ha3(N,5) not perform a correct simulation but H(P,P) does?

As I already pointed out Ha3 was NOT designed to follow the correctness
criteria that I gave. It skipped some of the elements of the criteria.

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

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.

On 5/5/2022 8:14 AM, Ben wrote:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>
>> 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.
>
> Why are you talking about first glances and missing details? PO has
> been saying this stuff, with slight variations, for 18 years. The
> points being put to him are not made by ingenues startled by first
> glances; they are being made by people who understand what PO is saying
> better than he does.
>
> Whilst he's obviously hiding some details, he's had to let slip enough
> that it's clear what's going on. I take your main point, though, that a
> genuine researcher would publish all the details, but you should know by
> now that PO is not such a person.
>

H1(P,P)==true is empirically proven to be correct
H(P,P)==false is empirically proven to be correct

*ALL THESE THINGS ARE EASILY VERIFIABLE FACTS*
Both H() and H1() 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.

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.

That you lack the technical knowledge of the x86 language to verify
these facts does not entail that they are not facts.

Furthermore stating that they are not facts lacking this required
technical knowledge is dishonest.

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

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.
>

On Thursday, May 5, 2022 at 5:53:58 PM UTC-4, olcott wrote:
> On 5/5/2022 8:14 AM, Ben wrote:
> > Malcolm McLean <malcolm.ar...@gmail.com> writes:
> >
> >> 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.
> >
> > Why are you talking about first glances and missing details? PO has
> > been saying this stuff, with slight variations, for 18 years. The
> > points being put to him are not made by ingenues startled by first
> > glances; they are being made by people who understand what PO is saying
> > better than he does.
> >
> > Whilst he's obviously hiding some details, he's had to let slip enough
> > that it's clear what's going on. I take your main point, though, that a
> > genuine researcher would publish all the details, but you should know by
> > now that PO is not such a person.
> >
> H1(P,P)==true is empirically proven to be correct
> H(P,P)==false is empirically proven to be correct

The fact that H1(P,P) == true empirically proves that H(P,P) == false is INCORRECT.

> *ALL THESE THINGS ARE EASILY VERIFIABLE FACTS*
> Both H() and H1() 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.

H(P,P) == false is NOT "provably correct". The fact H1(P,P) == true by simulating this same input to a final state directly proves this point.

> 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.
> That you lack the technical knowledge of the x86 language to verify
> these facts does not entail that they are not facts.
>
> Furthermore stating that they are not facts lacking this required
> technical knowledge is dishonest.
> --
> Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
> Genius hits a target no one else can see." Arthur Schopenhauer

On 5/5/2022 8:29 AM, Ben wrote:
> olcott <polcott2@gmail.com> writes:
>
>> On 5/4/2022 9:28 PM, Ben wrote:
>>> olcott <polcott2@gmail.com> writes:
>>>
>>>> On 5/4/2022 7:59 PM, Ben wrote:
>>>>> olcott <polcott2@gmail.com> writes:
>>>>>
>>>>>> On 5/4/2022 9:16 AM, Ben wrote:
>>>>>>> olcott <polcott2@gmail.com> writes:
>>>>>>>
>>>>>>>> On 5/2/2022 6:10 PM, Ben wrote:
>>>>>>>>> olcott <polcott2@gmail.com> writes:
>>>>>>>>>
>>>>>>>>>> On 5/2/2022 11:39 AM, Ben wrote:
>>>>>>>>>>> olcott <polcott2@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
>
>> 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. ALL THESE THINGS ARE VERIFIED FACTS !
>
> Your mantra is doing sterling work, allowing you to pretend you are
> taking about the halting problem while hiding what it is that your
> deciders are deciding. Whatever you are hiding behind the words
> "correct simulations of this same input" it is obviously not the halting
> of P(P).

You seem to have a short-circuit in your brain, I have told you this
many times and you have not seen it once.

H1(P,P) IS THE HALT STATUS OF P(P)
H1(P,P) IS THE HALT STATUS OF P(P)
H1(P,P) IS THE HALT STATUS OF P(P)
H1(P,P) IS THE HALT STATUS OF P(P)
H1(P,P) IS THE HALT STATUS OF P(P)

> For one thing, there is only one correct answer to the halting
> or otherwise of a computation, and for another, H(X,Y) is obviously not
> telling the world what it wants to know -- the halting of the
> computation X(Y).
>

Since you know that a decider (halting or otherwise) only computes the
mapping from its inputs and that you insist that a halt decider compute
its mapping from non inputs it is either psychosis or deception on your
part.

> Do you have anything at all left to say about the real halting problem?
> I really think you should at least state, explicitly, that you now
> accept that no function D exists such that D(X,Y) == true if an only if
> X(Y) halts and false otherwise.
>

H1(P,P)==true is empirically proven to be correct
H(P,P)==false is empirically proven to be correct

That you keep contradicting verified facts that you already accept as
true seems quite nuts. Halt deciders (like all deciders) compute the
mapping from their inputs.

It turns out that the halting behavior of the correct simulation of the
input to H1(P,P) is the same as the halting behavior of P(P).

It turns out that the halting behavior of the correct simulation of the
input to H(P,P) is NOT the same as the halting behavior of P(P).

The ultimate measure is that H(P,P) does compute the mapping from its
inputs to its final reject state. This can be easily verified by anyone
with sufficient expertise in the x86 language.

> I am sure some people will still want to talk about the mistakes in what
> you call the "correct simulations of this same input" but you should be
> honest about halting problem as defined above. And if people do stop
> talking to you about halting, you can always switch back to Gödel or
> Tarski.

I made good progress on Simplest TM interpreter yesterday. The detailed
design is halfway done. The trickiest part is the state change function.
I think that I am going to use a std::set that is indexed on state + input.

struct Quintuple
{ u32 state;
u32 symbol;
u32 write_symbol;
u32 next_state;
u8 Tape_Head_Move;
}

std::set<Quintuple> States;

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

On 5/5/2022 3:00 PM, Ben wrote:
> olcott <polcott2@gmail.com> writes:
>
>> On 5/5/2022 4:19 AM, Mikko wrote:
>
>>> There is no category error in the theorem. An infinitely recursive
>>> computation is still in the category of computations.
>>
>> Not according to Linz. Linz says that all computations must halt.
>
> That's a gem! I'm keeping that one!
>

He does say that.

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

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.

On 5/5/2022 5:11 PM, Dennis Bush wrote:
> On Thursday, May 5, 2022 at 5:53:58 PM UTC-4, olcott wrote:
>> On 5/5/2022 8:14 AM, Ben wrote:
>>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>>
>>>> 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.
>>>
>>> Why are you talking about first glances and missing details? PO has
>>> been saying this stuff, with slight variations, for 18 years. The
>>> points being put to him are not made by ingenues startled by first
>>> glances; they are being made by people who understand what PO is saying
>>> better than he does.
>>>
>>> Whilst he's obviously hiding some details, he's had to let slip enough
>>> that it's clear what's going on. I take your main point, though, that a
>>> genuine researcher would publish all the details, but you should know by
>>> now that PO is not such a person.
>>>
>> H1(P,P)==true is empirically proven to be correct
>> H(P,P)==false is empirically proven to be correct
>
> The fact that H1(P,P) == true empirically proves that H(P,P) == false is INCORRECT.
>
>> *ALL THESE THINGS ARE EASILY VERIFIABLE FACTS*
>> Both H() and H1() 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.
>
> H(P,P) == false is NOT "provably correct". The fact H1(P,P) == true by simulating this same input to a final state directly proves this point.

It is easily proven that H(P,P) does compute the mapping from its input
parameters to its own final reject state.

That people on this forum say that they believe that the halt decider
must compute the mapping from non-inputs when they already know that no
decider (including every halt decider) ever computes that mapping from
non-inputs is either dishonest or psychotic.

>> 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.
>> That you lack the technical knowledge of the x86 language to verify
>> these facts does not entail that they are not facts.
>>
>> Furthermore stating that they are not facts lacking this required
>> technical knowledge is dishonest.
>> --
>> Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see." Arthur Schopenhauer

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

On 5/5/22 4:00 PM, Ben wrote:
> olcott <polcott2@gmail.com> writes:
>
>> On 5/5/2022 4:19 AM, Mikko wrote:
>
>>> There is no category error in the theorem. An infinitely recursive
>>> computation is still in the category of computations.
>>
>> Not according to Linz. Linz says that all computations must halt.
>
> That's a gem! I'm keeping that one!
>

There is one version of the definition of a computation that says that
if it doesn't halt, it isn't a computation, just a machine running an input.

With that definition, the Halting Problem becomes the question of does a
given Machine processing a given input perform a Computation, because it
Halt, or is it not a Computation.

This sort of thing makes it very important to actually specify what you
mean by your words, which of course Peter tends to fail to do so, but
uses ambiguities like this and using different meanings in different
parts to prove incorrect statements.

Things like "The Input".

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.

Peter Olcott wrote:
....
> I made good progress on Simplest TM interpreter yesterday. The detailed
> design is halfway done. The trickiest part is the state change function.
> I think that I am going to use a std::set that is indexed on state + input.
>
> struct Quintuple
> {
>   u32 state;
>   u32 symbol;
>   u32 write_symbol;
>   u32 next_state;
>    u8 Tape_Head_Move;
> }
>
> std::set<Quintuple> States;

Four hours you said, yesterday? LOL.

On 5/5/2022 7:58 PM, Python wrote:
> Peter Olcott wrote:
> ...
>> I made good progress on Simplest TM interpreter yesterday. The
>> detailed design is halfway done. The trickiest part is the state
>> change function. I think that I am going to use a std::set that is
>> indexed on state + input.
>>
>> struct Quintuple
>> {
>>    u32 state;
>>    u32 symbol;
>>    u32 write_symbol;
>>    u32 next_state;
>>     u8 Tape_Head_Move;
>> }
>>
>> std::set<Quintuple> States;
>
> Four hours you said, yesterday? LOL.
>
>

Instead of going for a speed record I worked as I usually do a few
minutes here and there while doing other things.

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

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

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.

olcott <polcott2@gmail.com> writes:

> On 5/5/2022 3:00 PM, Ben wrote:
>> olcott <polcott2@gmail.com> writes:
>>
>>> On 5/5/2022 4:19 AM, Mikko wrote:
>>
>>>> There is no category error in the theorem. An infinitely recursive
>>>> computation is still in the category of computations.
>>>
>>> Not according to Linz. Linz says that all computations must halt.
>>
>> That's a gem! I'm keeping that one!
>
> He does say that.

<sigh>
Something does not become a "category error" because people use terms in
different ways. What matters is the category not the name of the
category.

--
Ben.
"le génie humain a des limites, quand la bêtise humaine n’en a pas"
Alexandre Dumas (fils)

Peter Olcott a écrit :
> On 5/5/2022 7:58 PM, Python wrote:
>> Peter Olcott wrote:
>> ...
>>> I made good progress on Simplest TM interpreter yesterday. The
>>> detailed design is halfway done. The trickiest part is the state
>>> change function. I think that I am going to use a std::set that is
>>> indexed on state + input.
>>>
>>> struct Quintuple
>>> {
>>>    u32 state;
>>>    u32 symbol;
>>>    u32 write_symbol;
>>>    u32 next_state;
>>>     u8 Tape_Head_Move;
>>> }
>>>
>>> std::set<Quintuple> States;
>>
>> Four hours you said, yesterday? LOL.
>>
>>
>
> Instead of going for a speed record I worked as I usually do a few
> minutes here and there while doing other things.

So why did *you* mention this 4 hours interval to begin with?

Oh come on Peter, you're a terrible programmer. You'll never
achieve writing this program, all of your "opponents" could
do in a few hours btw. It should ring a bell (it won't).

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.

On 5/5/2022 8:21 PM, Ben wrote:
> olcott <polcott2@gmail.com> writes:
>
>> On 5/5/2022 3:00 PM, Ben wrote:
>>> olcott <polcott2@gmail.com> writes:
>>>
>>>> On 5/5/2022 4:19 AM, Mikko wrote:
>>>
>>>>> There is no category error in the theorem. An infinitely recursive
>>>>> computation is still in the category of computations.
>>>>
>>>> Not according to Linz. Linz says that all computations must halt.
>>>
>>> That's a gem! I'm keeping that one!
>>
>> He does say that.
>
> <sigh>
> Something does not become a "category error" because people use terms in
> different ways. What matters is the category not the name of the
> category.
>

According to Linz:
If a sequence of configurations never halts then it is not a computation.

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

On Thursday, May 5, 2022 at 9:36:41 PM UTC-4, olcott wrote:
> 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.

On 5/5/2022 8:59 PM, Dennis Bush wrote:
> On Thursday, May 5, 2022 at 9:36:41 PM UTC-4, olcott wrote:
>> 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.
>
> It is a verified fact that H(P,P) does NOT perform a correct simulation of its input.

On Thursday, May 5, 2022 at 10:08:31 PM UTC-4, olcott wrote:
> On 5/5/2022 8:59 PM, Dennis Bush wrote:
> > On Thursday, May 5, 2022 at 9:36:41 PM UTC-4, olcott wrote:
> >> 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.
> >
> > It is a verified fact that H(P,P) does NOT perform a correct simulation of its input.
> That the execution trace of the simulated input to H(P,P) exactly
> matches the behavior specified by its x86 source-code provides the
> ultimate measure of a correct simulation thus overriding and superseding
> any and all other measures.
>
> _P()
> [000009d6](01) 55 push ebp
> [000009d7](02) 8bec mov ebp,esp
> [000009d9](03) 8b4508 mov eax,[ebp+08]
> [000009dc](01) 50 push eax // push P
> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
> [000009e0](01) 51 push ecx // push P
> [000009e1](05) e840feffff call 00000826 // call H
> [000009e6](03) 83c408 add esp,+08
> [000009e9](02) 85c0 test eax,eax
> [000009eb](02) 7402 jz 000009ef
> [000009ed](02) ebfe jmp 000009ed
> [000009ef](01) 5d pop ebp
> [000009f0](01) c3 ret // Final state
> Size in bytes:(0027) [000009f0]
>
> Begin Local Halt Decider Simulation
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
> ...[000009dc][00211364][000009d6] 50 push eax // Push P
> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> --
> Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
> Genius hits a target no one else can see." Arthur Schopenhauer

On 5/5/2022 9:18 PM, Dennis Bush wrote:
> On Thursday, May 5, 2022 at 10:08:31 PM UTC-4, olcott wrote:
>> On 5/5/2022 8:59 PM, Dennis Bush wrote:
>>> On Thursday, May 5, 2022 at 9:36:41 PM UTC-4, olcott wrote:
>>>> 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.
>>>
>>> It is a verified fact that H(P,P) does NOT perform a correct simulation of its input.
>> That the execution trace of the simulated input to H(P,P) exactly
>> matches the behavior specified by its x86 source-code provides the
>> ultimate measure of a correct simulation thus overriding and superseding
>> any and all other measures.
>>
>> _P()
>> [000009d6](01) 55 push ebp
>> [000009d7](02) 8bec mov ebp,esp
>> [000009d9](03) 8b4508 mov eax,[ebp+08]
>> [000009dc](01) 50 push eax // push P
>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
>> [000009e0](01) 51 push ecx // push P
>> [000009e1](05) e840feffff call 00000826 // call H
>> [000009e6](03) 83c408 add esp,+08
>> [000009e9](02) 85c0 test eax,eax
>> [000009eb](02) 7402 jz 000009ef
>> [000009ed](02) ebfe jmp 000009ed
>> [000009ef](01) 5d pop ebp
>> [000009f0](01) c3 ret // Final state
>> Size in bytes:(0027) [000009f0]
>>
>> Begin Local Halt Decider Simulation
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>> --
>> Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see." Arthur Schopenhauer
>
> All this trace shows is that H aborted its input.

olcott <polcott2@gmail.com> writes:

> On 5/5/2022 8:29 AM, Ben wrote:
>> olcott <polcott2@gmail.com> writes:

>>> H1(P,P)==true is empirically proven to be correct
>>> H(P,P)==false is empirically proven to be correct
>>
>>> 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. ALL THESE THINGS ARE VERIFIED FACTS !
>>
>> Your mantra is doing sterling work, allowing you to pretend you are
>> taking about the halting problem while hiding what it is that your
>> deciders are deciding. Whatever you are hiding behind the words
>> "correct simulations of this same input" it is obviously not the halting
>> of P(P).
>
> You seem to have a short-circuit in your brain, I have told you this
> many times and you have not seen it once.
>
> H1(P,P) IS THE HALT STATUS OF P(P)

So what? Everyone know that there are an infinity of functions that are
correct about the halting of P(P). It's H that's wrong, not H1.

The only interesting thing about H1 is that you say it does that same as
H but gets a different answer. Now that's a rabbit hole that other
people might follow you down, but I don't care. You are wrong about too
many things to be bothered about all of them.

The important point is that your H is wrong because H(P,P) == false even
though P(P) halts.

>> For one thing, there is only one correct answer to the halting
>> or otherwise of a computation, and for another, H(X,Y) is obviously not
>> telling the world what it wants to know -- the halting of the
>> computation X(Y).
>
> Since you know that a decider (halting or otherwise) only computes the
> mapping from its inputs and that you insist that a halt decider
> compute its mapping from non inputs it is either psychosis or
> deception on your part.

Remember all those other times you thought I was mad? Remember the last
time? It was because you didn't know what a sequence was.

Hint: every time you think I am lying or playing games or psychotic it's
because your conviction that you can't be wrong has butted up against
cold facts. You know, at some level of consciousness, that a C-like
halt decider, bool D(ptr X, ptr Y);, returns true or false based on the
halting of X(Y) as here:

>> Do you have anything at all left to say about the real halting problem?
>> I really think you should at least state, explicitly, that you now
>> accept that no function D exists such that D(X,Y) == true if an only if
>> X(Y) halts and false otherwise.

We could make progress if you would accept that no such D can exist for
whatever reason you choose to give -- even it's because you think X(Y)
is a "non-input". But then there's no reason to think you will make
such a clear statement.

> H1(P,P)==true is empirically proven to be correct
> H(P,P)==false is empirically proven to be correct
>
> That you keep contradicting verified facts that you already accept as
> true seems quite nuts.

H1 is irrelevant, and H is wrong by definition. Whatever H has been
"empirically proven to be correct" about you are clear that it's not
correct about the halting of P(P).

> Halt deciders (like all deciders) compute the
> mapping from their inputs.

.... to specified true/false properties of those inputs. In the case of
H, we want it to report on the halting or otherwise of its first
argument when called with the second argument. Your H fails at that.

> It turns out that the halting behavior of the correct simulation of
> the input to H1(P,P) is the same as the halting behavior of P(P).

And that is true of an infinity of equally irrelevant functions.

> It turns out that the halting behavior of the correct simulation of
> the input to H(P,P) is NOT the same as the halting behavior of P(P).

Which is why H does not meet the specification of being a halt decider.

> The ultimate measure is that H(P,P) does compute the mapping from its
> inputs to its final reject state. This can be easily verified by
> anyone with sufficient expertise in the x86 language.

Yes, H just wrong to reject (P,P) because of how the halting problem is
defined. No one disputes the fact that H(P,P) == false even though P(P)
halts. The /only/ fact is dispute is the specification that H should
meet.

> I made good progress on Simplest TM interpreter yesterday. The
> detailed design is halfway done. The trickiest part is the state
> change function. I think that I am going to use a std::set that is
> indexed on state + input.
>
> struct Quintuple
> {
> u32 state;
> u32 symbol;
> u32 write_symbol;
> u32 next_state;
> u8 Tape_Head_Move;
> }
>
> std::set<Quintuple> States;

Why is a set of objects that are not states called "States"?

Would you like some help with the design? Over the years I've written
about a dozen TM interpreters in at least three languages, as well as
having graded literally dozens of students' attempts at doing the same.
Having a set of quintuples is of little help. It's a dead end.

--
Ben.
"le génie humain a des limites, quand la bêtise humaine n’en a pas"
Alexandre Dumas (fils)

On 5/5/22 6:31 PM, olcott wrote:

> It is easily proven that H(P,P) does compute the mapping from its input
> parameters to its own final reject state.
>

It computes *A* mapping, but not *THE* mapping being asked for by the
Halting Problem. (doesn't P(P) halt)

Thus H fails to be a Halting Decider.

You seem to claim that it is impposible to ask it the right questions,
or at least the obvious way to ask it is asking about something
different, thus your claim is basically a PROOF of the theory.

H can NOT correct decide the halting status of all combinations of
Turing Machines and input tapes, as it seems impossible to ask it the
question about H^ (which you call P) applied to <H^>, which it the case
that Linz says it can't, so you haven't refuted the claim of Linz.

All you seem to be trying to do is say that it is somehow improper to
ask it that question, but that is a natural consequence of the
requirement to be able to answer for ALL Turing Machines and ALL inputs.

So, all your convoluted arguement has done is reinforce, not refute, the
claim of the Halting Problem Theory.