On 9/1/2022 9:56 AM, Mr Flibble wrote:
> 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
>

THE MEANING OF THESE WORDS PROVE THAT THEY ARE TRUE
When-so-ever the input/argument to a simulating halt decider (SHD) would
never stop running unless its simulation was aborted is merely another
way of saying that this input never reaches its final state and halts.

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