On Thu, 1 Sep 2022 09:31:01 -0500
olcott <none-ya@beez-wax.com> wrote:

> On 9/1/2022 6:14 AM, Richard Damon wrote:
> >
> > On 8/31/22 11:43 PM, olcott wrote:
> >> On 8/31/2022 10:19 PM, Richard Damon wrote:
> >>> On 8/31/22 9:46 PM, olcott wrote:
> >>>> On 8/31/2022 8:41 PM, Richard Damon wrote:
> >>>>> On 8/31/22 9:29 PM, olcott wrote:
> >>>>>> On 8/31/2022 8:16 PM, Richard Damon wrote:
> >>>>>>> On 8/31/22 9:08 PM, olcott wrote:
> >>>>>>>> On 8/31/2022 8:04 PM, Richard Damon wrote:
> >>>>>>>>> On 8/31/22 8:54 PM, olcott wrote:
> >>>>>>>>>> On 8/31/2022 7:46 PM, Richard Damon wrote:
> >>>>>>>>>>>
> >>>>>>>>>>> On 8/31/22 8:24 PM, olcott wrote:
> >>>>>>>>>>>> On 8/31/2022 7:14 PM, Richard Damon wrote:
> >>>>>>>>>>>>> On 8/31/22 7:59 PM, olcott wrote:
> >>>>>>>>>>>>>> On 8/31/2022 6:49 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>> On 8/31/22 7:44 PM, olcott wrote:
> >>>>>>>>>>>>>>>> On 8/31/2022 6:04 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>> On 8/31/22 10:37 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 8/31/2022 5:58 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>> On 8/30/22 11:30 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 8/30/2022 10:11 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>> On 8/30/22 10:51 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 9:22 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 10:12 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 9:01 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 9:53 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:44 PM, Richard Damon
> >>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 9:35 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:19 PM, Richard Damon
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 8:52 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 7:40 PM, Richard Damon
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 7:46 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 5:37 PM, Richard Damon
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF Px REALLY does call Simulate,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether it is the simulate you show
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (which doesn't actually simulates,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but just calls its input), then
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, THAT Px is Non-Halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great an honest reply. Now if
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) was supposed to predict the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of a correct and complete
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input as if H was
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate, then H(P,P) would be
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct return return 0.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You didn't read the rest.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is supposed to predict whether
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or not a pure simulation of its input
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> performed by Simulate (instead of H)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will never stop running and H returns
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0 then H is necessarily correct no
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matter what process that H uses to
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> make this determination.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> But remember, P doesn't call simulate,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> it calls H.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly predicts that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(x,y) never halts:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> H(ptr x, ptr y)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> But, assuming we are still talking about
> >>>>>>>>>>>>>>>>>>>>>>>>>>> the P that calls H(P,P), Simulate(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>> does Halt if H(P,P) return 0, so that
> >>>>>>>>>>>>>>>>>>>>>>>>>>> answer is wrong.
> >>>>>>>>>>>>>>>>>>>>>>>>>> void Simulate(ptr x, ptr y)
> >>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>> x(y);
> >>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> void Pz(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> If Fred is supposed to determine whether
> >>>>>>>>>>>>>>>>>>>>>>>>>> or not Simulate(Pz, Pz) halts:
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> u32 Fred()
> >>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>> return 0;
> >>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> *Then Fred is necessarily correct*
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Right, H(Pz,Pz) is correct to say 0
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> void PP(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>> H(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(PP, PP));
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> void Pz(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>> Simulate(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> H(PP,PP) is correct to return 0 when
> >>>>>>>>>>>>>>>>>>>>>>>> returning 0 means that Simulate(Pz,Pz)
> >>>>>>>>>>>>>>>>>>>>>>>> never halts.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> How are you justifying that H(PP,PP) is
> >>>>>>>>>>>>>>>>>>>>>>> answering about a TOTALLY DIFFERENT input
> >>>>>>>>>>>>>>>>>>>>>>> Pz,Pz?
> >>>>>>>>>>>>>>>>>>>>>> Every function that returns 0 (interpreted as
> >>>>>>>>>>>>>>>>>>>>>> Boolean) is correctly answering: Does
> >>>>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz) halt?
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> If that is the question it is supposed to be
> >>>>>>>>>>>>>>>>>>>>> answering.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> So, your trying to claim victory by giving the
> >>>>>>>>>>>>>>>>>>>>> "right' answer to the worng question.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> I am not done yet.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> *We can move* *ON* *when you agree that this is
> >>>>>>>>>>>>>>>>>>>> true* H(PP,PP) is correct to return 0 when
> >>>>>>>>>>>>>>>>>>>> returning 0 means that
> >>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz) never halts.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> So, you are stipulating that H isn't a halt
> >>>>>>>>>>>>>>>>>>> decider.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> I am stipulating that H(PP,PP) is a halt decider
> >>>>>>>>>>>>>>>>>> for Simulate(Pz,Pz)
> >>>>>>>>>>>>>>>>>> Thus H(PP,PP)==0 is correct.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> What is Hz? did you mean Pz?
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Yes it was a typo.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> And how is it that? Since H hasn't been given
> >>>>>>>>>>>>>>>>> anything about Pz, so how can it be being asked
> >>>>>>>>>>>>>>>>> about it.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> If when I say "there is a black cat sitting on my
> >>>>>>>>>>>>>>>> head" is code for 2 + 3 = 5, then "there is a black
> >>>>>>>>>>>>>>>> cat sitting on my head" is true.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> In this same way when I say that when H(PP,PP)
> >>>>>>>>>>>>>>>> returns 0 this means that Simulate(Pz,Pz) never
> >>>>>>>>>>>>>>>> halts then H(PP,PP)==0 is correct.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> And things based on nonsense are just nonsense.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> You misdefine too many things to be allowed to play
> >>>>>>>>>>>>>>> that game.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> FAIL.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Being "Correct" means does what it is supposed to do.
> >>>>>>>>>>>>>>> Until you actually DEFINE how H is "correct" to do
> >>>>>>>>>>>>>>> this, you are just stating non-sense.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Remember, you aren't allowed to stipulate something
> >>>>>>>>>>>>>>> is correct.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> This is a mandatory prerequisite to the rest of my
> >>>>>>>>>>>>>> proof. I understand if you just want to disagree and
> >>>>>>>>>>>>>> don't want to understand.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If it is a mandatory prerequisite, then your proof is
> >>>>>>>>>>>>>
> invalid.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If you can't explain the GROUNDS that H is using to be
> >>>>>>>>>>>>> ABLE to decide about Simulate(Pz,Pz) when given PP,PP,
> >>>>>>>>>>>>> then your logic is just broken.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> Because your only purpose is to be disagreeable I force
> >>>>>>>>>>>> the cost of a continuing dialogue to be mutual
> >>>>>>>>>>>> agreement at key points in the dialogue.
> >>>>>>>>>>>>
> >>>>>>>>>>>> I am unwilling to have any dialogue besides an honest
> >>>>>>>>>>>> dialogue. An honest dialogue require points of mutual
> >>>>>>>>>>>> agreement.
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> Right, so you need to explain HOW it is possible for
> >>>>>>>>>>> H(PP,PP) to be able to actually decide on
> >>>>>>>>>>> Simulate(Pz,Pz).
> >>>>>>>>>>
> >>>>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> Yes, so answer my questions so we can agree.
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>>
> >>>>>>>>
> >>>>>>>
> >>>>>>> So make the move to reach agreement. MUTUAL agreement isn't
> >>>>>>> one
> way.
> >>>>>>
> >>>>>> *You must agree with my point or I will not move on to the
> >>>>>> next point*
> >>>>>>
> >>>>>>
> >>>>>
> >>>>> Nope, I've given my objection, and until you answer it, I will
> >>>>> not move on.
> >>>>
> >>>> You have not given any objection to the precise words that said
> >>>> and there is no correct objection to the precise words that I
> >>>> said because they are proven to be true entirely on the basis
> >>>> of their meaning.
> >>>>
> >>>> Not agreeing with words that are true on the basis of their
> >>>> meaning is a sign of dishonesty.
> >>>>
> >>>
> >>> No, I have objected to calling something a correct decider when
> >>> the thing it was deciding on was not given in any way as an
> >>> input.
> >>
> >> You are not going to be able to understand the next step until you
> >> understand that the prior step is true.
> >>
> >> H(PP,PP)==0 is stipulated to mean that Simulate(Pz,Pz) never
> >> halts.
> >
> > You can't stipulate something which is illogical or can't exist.
> >
> When I stipulate "there is a what cat sitting on my head" is code for
> the meaning that 2+3=5 then, "there is a what cat sitting on my head"
> is true.
>
>
> When I stipulate that H(P,P)==0 is code for Simulate(Pz,Pz) never
> stops running then H(P,P)==0 is true.
>
> In BASIC when
> 100 let X = 5
> when it not free to interprets that value of X as anthing besides 5.
>
> >>
> >> It could have been that "xyz" was stipulated to mean that
> >> Simulate(Pz,Pz) never halts.
> >>
> >
> > But "xyz" doesn't have the bagage of being implied to be a decider.
> >
> > A Decider can only decide based on its input. Pz is not PP, so it
> > can't decide on something based on Pz when given PP.
> >
> Ah so not you are saying that the fact that P(P) halts ( P(P) is not
> an input) does not contradict the fact that H(P,P)==0.
>
> > You can't "stipulate" that H was correct at doing something it can
> >
> not do.
> I can stipulate "I really want a cup of tea" is code for
> Simulate(Pz,Pz) never halts.
>
> >
> > You need to explain HOW H is able to decide on Pz when given PP.
> H is deciding what its own behavior would be if it never aborted the
> simulation of its input. It does that by analyzing the behavior of
> its proxy.
>
> void Infinite_Recursion(int N)
> {
> Infinite_Recursion(N);
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
> }
>
> H(Infinite_Recursion, 0x777) analyzes the behavior of
> Simulate(Infinite_Recursion, 0x777).
>
> void Infinite_Loop()
> {
> HERE: goto HERE;
> }
>
> H0(Infinite_Loop) analyzes the behavior of Simulate(Infinite_Loop).
>
> Simulate(Pz,Pz) never stops running is the proxy for H(P,P) when H
> never aborts the simulation of its input.
>
> When H never aborts the simulation of its input then H(P,P) <*IS*>
> Simulate(Pz,Pz).

This isn't the Halting Problem, though: in the Halting Problem P is
calling H not Simulate and here you are talking about something
different again whereby P is not even calling H or Simulate. Stop
pretending you are talking about the Halting Problem when you are not.

/Flibble