Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #58257 > unrolled thread
| Started by | olcott <polcott2@gmail.com> |
|---|---|
| First post | 2022-10-08 19:18 -0500 |
| Last post | 2022-10-10 19:06 -0400 |
| Articles | 20 on this page of 77 — 9 participants |
Back to article view | Back to comp.theory
Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-08 19:18 -0500
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-08 19:29 -0500
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-08 20:49 -0400
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-08 20:22 -0500
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-08 21:43 -0400
Re: Simulating halt deciders refute the halting theorem olcott <none-ya@beez-waxes.com> - 2022-10-08 21:00 -0500
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-08 22:44 -0400
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-08 22:31 -0500
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-09 07:25 -0400
Re: Simulating halt deciders refute the halting theorem olcott <none-ya@beez-waxes.com> - 2022-10-09 09:32 -0500
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 16:40 +0100
Re: Simulating halt deciders refute the halting theorem olcott <none-ya@beez-waxes.com> - 2022-10-09 10:48 -0500
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 17:25 +0100
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 11:40 -0500
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 17:43 +0100
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 17:39 +0100
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 11:46 -0500
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 17:49 +0100
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 12:00 -0500
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 18:10 +0100
Re: Simulating halt deciders refute the halting theorem olcott <none-ya@beez-waxes.com> - 2022-10-09 12:14 -0500
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 18:18 +0100
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 12:22 -0500
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 18:30 +0100
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 12:48 -0500
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 18:51 +0100
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 12:57 -0500
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 19:07 +0100
Re: Simulating halt deciders refute the halting theorem olcott <none-ya@beez-waxes.com> - 2022-10-09 13:10 -0500
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 19:12 +0100
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 13:18 -0500
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 19:23 +0100
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 13:28 -0500
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 19:31 +0100
Re: Simulating halt deciders refute the halting theorem olcott <none-ya@beez-waxes.com> - 2022-10-09 13:40 -0500
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 19:44 +0100
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 14:03 -0500
Re: Simulating halt deciders refute the halting theorem Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-09 20:06 +0100
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-09 14:39 -0400
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 13:51 -0500
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-09 15:03 -0400
Re: Simulating halt deciders refute the halting theorem "Fred. Zwarts" <F.Zwarts@KVI.nl> - 2022-10-10 10:25 +0200
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-10 10:37 -0500
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-10 18:57 -0400
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 10:41 -0500
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-09 14:52 -0400
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 14:09 -0500
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-09 15:23 -0400
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 14:33 -0500
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-09 15:38 -0400
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 14:49 -0500
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-09 20:53 -0400
Re: Simulating halt deciders refute the halting theorem Mikko <mikko.levanto@iki.fi> - 2022-10-09 14:13 +0300
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-09 07:26 -0400
Re: Simulating halt deciders refute the halting theorem Muttley@dastardlyhq.com - 2022-10-09 09:23 +0000
Re: Simulating halt deciders refute the halting theorem Bonita Montero <Bonita.Montero@gmail.com> - 2022-10-09 15:29 +0200
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-09 14:32 -0500
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-09 15:47 -0400
Re: Simulating halt deciders refute the halting theorem olcott <none-ya@beez-waxes.com> - 2022-10-09 15:17 -0500
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-09 16:32 -0400
Re: Simulating halt deciders refute the halting theorem, Tarski and Gödel olcott <polcott2@gmail.com> - 2022-10-10 13:42 -0500
Re: Simulating halt deciders refute the halting theorem, Tarski and Gödel Richard Damon <Richard@Damon-Family.org> - 2022-10-10 18:47 -0400
Re: Simulating halt deciders refute the halting theorem, Tarski and Gödel olcott <polcott2@gmail.com> - 2022-10-10 18:25 -0500
Re: Simulating halt deciders refute the halting theorem, Tarski and Gödel Richard Damon <Richard@Damon-Family.org> - 2022-10-10 19:45 -0400
Re: Simulating halt deciders refute the halting theorem, Tarski and Gödel olcott <none-ya@beez-waxes.com> - 2022-10-10 19:06 -0500
Re: Simulating halt deciders refute the halting theorem, Tarski and Gödel Richard Damon <Richard@Damon-Family.org> - 2022-10-10 20:16 -0400
Re: Simulating halt deciders refute the halting theorem, Tarski and Gödel olcott <polcott2@gmail.com> - 2022-10-10 21:30 -0500
Re: Simulating halt deciders refute the halting theorem, Tarski and Gödel Richard Damon <Richard@Damon-Family.org> - 2022-10-10 23:00 -0400
Re: Simulating halt deciders refute the halting theorem, Tarski and Gödel olcott <polcott2@gmail.com> - 2022-10-10 22:18 -0500
Re: Simulating halt deciders refute the halting theorem, Tarski and Gödel Richard Damon <Richard@Damon-Family.org> - 2022-10-10 23:34 -0400
Re: Simulating halt deciders refute the halting theorem, Tarski and Gödel olcott <polcott2@gmail.com> - 2022-10-10 21:24 -0500
Re: Simulating halt deciders refute the halting theorem, Tarski and Gödel Richard Damon <Richard@Damon-Family.org> - 2022-10-10 22:44 -0400
Re: Simulating halt deciders refute the halting theorem, Tarski and Gödel olcott <polcott2@gmail.com> - 2022-10-10 21:59 -0500
Re: Simulating halt deciders refute the halting theorem, Tarski and Gödel Richard Damon <Richard@Damon-Family.org> - 2022-10-10 23:14 -0400
Re: Simulating halt deciders refute the halting theorem Kaz Kylheku <864-117-4973@kylheku.com> - 2022-10-09 20:43 +0000
Re: Simulating halt deciders refute the halting theorem olcott <polcott2@gmail.com> - 2022-10-10 12:05 -0500
Re: Simulating halt deciders refute the halting theorem Richard Damon <Richard@Damon-Family.org> - 2022-10-10 19:06 -0400
Page 2 of 4 — ← Prev page 1 [2] 3 4 Next page →
| From | olcott <none-ya@beez-waxes.com> |
|---|---|
| Date | 2022-10-09 12:14 -0500 |
| Message-ID | <thuvi1$1ili$1@gioia.aioe.org> |
| In reply to | #58282 |
On 10/9/2022 12:10 PM, Mr Flibble wrote:
> On Sun, 9 Oct 2022 12:00:46 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
>>> On Sun, 9 Oct 2022 11:46:10 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>
>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>
>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>> Once one accepts the notion of a simulating halt
>>>>>>>>>>>>>>>> decider that continues to correctly simulate its input
>>>>>>>>>>>>>>>> until it correctly determines that the this simulated
>>>>>>>>>>>>>>>> input would never stop running then the conventional
>>>>>>>>>>>>>>>> halting problem proofs are refuted.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate until it
>>>>>>>>>>>>>>> CORRECT decides that the ACTUAL input will never halts,
>>>>>>>>>>>>>>> but stops when a DIFFERENT input is shown to not halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>> An intentionally misrepresented proposition that is set
>>>>>>>>>>>>>> up because it is easier to defeat than an opponent's real
>>>>>>>>>>>>>> argument. https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Strawman deception try again using the exact words that I
>>>>>>>>>>>>>> actually said.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which isn't what I did, so you are just shown to be a
>>>>>>>>>>>>> LIAR.
>>>>>>>>>>>>
>>>>>>>>>>>> // P does the opposite of whatever H decides
>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>> if (Halt_Status) // if H(P,P) reports that its
>>>>>>>>>>>> input halts HERE: goto HERE; // P loops and never halts
>>>>>>>>>>>> return; // else P halts
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> You are asserting that the simulation of P by H would
>>>>>>>>>>>> eventually stop running on its own without being aborted by
>>>>>>>>>>>> H?
>>>>>>>>>>>
>>>>>>>>>>> No, THAT is the strawman.
>>>>>>>>>>>
>>>>>>>>>>> I am asserting that the CORRECT simulation of P would
>>>>>>>>>>> eventually reach a final state,
>>>>>>>>>>
>>>>>>>>>> *You changed the words again*
>>>>>>>>>>
>>>>>>>>>> You are asserting that the simulation
>>>>>>>>>> of P by H
>>>>>>>>>> of P by H
>>>>>>>>>> of P by H
>>>>>>>>>> of P by H
>>>>>>>>>> of P by H
>>>>>>>>>> would eventually stop running on its own without being
>>>>>>>>>> aborted by H?
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, that's YOUR strawman.
>>>>>>>> If you knew anything about logic you would understand that this
>>>>>>>> is a premise: *Once one accepts the notion of a simulating halt
>>>>>>>> decider*
>>>>>>>>
>>>>>>>> One is not allowed to reject the premise. One is only allowed
>>>>>>>> to verify that the conclusion follows from the premise.
>>>>>>>
>>>>>>> SHD can only refute halting problem proofs if it is a pure
>>>>>>> function;
>>>>>>
>>>>>> Yes, it took me three full time months to convert H into a pure
>>>>>> function. I merely apply the exact same infinite recursion
>>>>>> criteria that is used to compute the halt status of:
>>>>>>
>>>>>> void Infinite_Recursion(u32 N)
>>>>>> {
>>>>>> Infinite_Recursion(N);
>>>>>> }
>>>>>>
>>>>>> Yet I apply this criteria immediately before recursive simulation
>>>>>> actually occurs. When H recognizes that P is about to call H in
>>>>>> recursive simulation H aborts its simulation of P before its
>>>>>> first call to H is ever invoked.
>>>>>
>>>>> If your H is a pure function and H(P,P) returns 0 then H(P,P)
>>>>> called from P(P) would also return 0
>>>>
>>>> <sarcasm>
>>>> Sure because everyone knows that a function that is never invoked
>>>> must still return a value in the same way we must be able to start
>>>> the engine of a car that has no engine.
>>>> </sarcasm>
>>>
>>> H(P,P) called from P(P) is the FIRST invocation of H(P,P) so is
>>> invoked, i.e. main() calling P(P) instead of H(P,P).
>>>
>>> Your H is not a halt decider as it gets the halting decision wrong.
>>>
>>> /Flibble
>>>
>>
>> Turing computable functions are not allowed to compute the mapping of
>> non-inputs or anything that cannot be encoded as a finite string.
>> That you fail to understand this is not any rebuttal of what I have
>> said.
>
> If H is a pure function and H(P,P) returns 0 then if P(P) is called
> from main() P(P) will halt which means H got the halting decision wrong
> meaning H is not a halt decider.
>
> /Flibble
>
You continue to fail to understand that Turing computable functions are
not allowed to consider the behavior of non-inputs. That you fail to
understand this is not any error on my part.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-10-09 18:18 +0100 |
| Message-ID | <20221009181802.00001ada@reddwarf.jmc.corp> |
| In reply to | #58283 |
On Sun, 9 Oct 2022 12:14:39 -0500
olcott <none-ya@beez-waxes.com> wrote:
> On 10/9/2022 12:10 PM, Mr Flibble wrote:
> > On Sun, 9 Oct 2022 12:00:46 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 10/9/2022 11:49 AM, Mr Flibble wrote:
> >>> On Sun, 9 Oct 2022 11:46:10 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
> >>>>> On Sun, 9 Oct 2022 10:48:51 -0500
> >>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>
> >>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
> >>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
> >>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>
> >>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
> >>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
> >>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
> >>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
> >>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
> >>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
> >>>>>>>>>>>>>>>> Once one accepts the notion of a simulating halt
> >>>>>>>>>>>>>>>> decider that continues to correctly simulate its
> >>>>>>>>>>>>>>>> input until it correctly determines that the this
> >>>>>>>>>>>>>>>> simulated input would never stop running then the
> >>>>>>>>>>>>>>>> conventional halting problem proofs are refuted.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Except that your decider DOESN'T simulate until it
> >>>>>>>>>>>>>>> CORRECT decides that the ACTUAL input will never
> >>>>>>>>>>>>>>> halts, but stops when a DIFFERENT input is shown to
> >>>>>>>>>>>>>>> not halt.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> *straw man*
> >>>>>>>>>>>>>> An intentionally misrepresented proposition that is set
> >>>>>>>>>>>>>> up because it is easier to defeat than an opponent's
> >>>>>>>>>>>>>> real argument.
> >>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Strawman deception try again using the exact words
> >>>>>>>>>>>>>> that I actually said.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Which isn't what I did, so you are just shown to be a
> >>>>>>>>>>>>> LIAR.
> >>>>>>>>>>>>
> >>>>>>>>>>>> // P does the opposite of whatever H decides
> >>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>> if (Halt_Status) // if H(P,P) reports that its
> >>>>>>>>>>>> input halts HERE: goto HERE; // P loops and never halts
> >>>>>>>>>>>> return; // else P halts
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> int main()
> >>>>>>>>>>>> {
> >>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> You are asserting that the simulation of P by H would
> >>>>>>>>>>>> eventually stop running on its own without being aborted
> >>>>>>>>>>>> by H?
> >>>>>>>>>>>
> >>>>>>>>>>> No, THAT is the strawman.
> >>>>>>>>>>>
> >>>>>>>>>>> I am asserting that the CORRECT simulation of P would
> >>>>>>>>>>> eventually reach a final state,
> >>>>>>>>>>
> >>>>>>>>>> *You changed the words again*
> >>>>>>>>>>
> >>>>>>>>>> You are asserting that the simulation
> >>>>>>>>>> of P by H
> >>>>>>>>>> of P by H
> >>>>>>>>>> of P by H
> >>>>>>>>>> of P by H
> >>>>>>>>>> of P by H
> >>>>>>>>>> would eventually stop running on its own without being
> >>>>>>>>>> aborted by H?
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> No, that's YOUR strawman.
> >>>>>>>> If you knew anything about logic you would understand that
> >>>>>>>> this is a premise: *Once one accepts the notion of a
> >>>>>>>> simulating halt decider*
> >>>>>>>>
> >>>>>>>> One is not allowed to reject the premise. One is only allowed
> >>>>>>>> to verify that the conclusion follows from the premise.
> >>>>>>>
> >>>>>>> SHD can only refute halting problem proofs if it is a pure
> >>>>>>> function;
> >>>>>>
> >>>>>> Yes, it took me three full time months to convert H into a pure
> >>>>>> function. I merely apply the exact same infinite recursion
> >>>>>> criteria that is used to compute the halt status of:
> >>>>>>
> >>>>>> void Infinite_Recursion(u32 N)
> >>>>>> {
> >>>>>> Infinite_Recursion(N);
> >>>>>> }
> >>>>>>
> >>>>>> Yet I apply this criteria immediately before recursive
> >>>>>> simulation actually occurs. When H recognizes that P is about
> >>>>>> to call H in recursive simulation H aborts its simulation of P
> >>>>>> before its first call to H is ever invoked.
> >>>>>
> >>>>> If your H is a pure function and H(P,P) returns 0 then H(P,P)
> >>>>> called from P(P) would also return 0
> >>>>
> >>>> <sarcasm>
> >>>> Sure because everyone knows that a function that is never invoked
> >>>> must still return a value in the same way we must be able to
> >>>> start the engine of a car that has no engine.
> >>>> </sarcasm>
> >>>
> >>> H(P,P) called from P(P) is the FIRST invocation of H(P,P) so is
> >>> invoked, i.e. main() calling P(P) instead of H(P,P).
> >>>
> >>> Your H is not a halt decider as it gets the halting decision
> >>> wrong.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Turing computable functions are not allowed to compute the mapping
> >> of non-inputs or anything that cannot be encoded as a finite
> >> string. That you fail to understand this is not any rebuttal of
> >> what I have said.
> >
> > If H is a pure function and H(P,P) returns 0 then if P(P) is called
> > from main() P(P) will halt which means H got the halting decision
> > wrong meaning H is not a halt decider.
> >
> > /Flibble
> >
>
> You continue to fail to understand that Turing computable functions
> are not allowed to consider the behavior of non-inputs. That you fail
> to understand this is not any error on my part.
English is ambiguous, lets try code instead:
int main()
{
Output("Input_Halts = ", H(P, P));
P(P);
Output("P(P) halted ergo H(P, P) should have returned 1");
}
Given the above it is obvious to all that H is not a halt decider.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-10-09 12:22 -0500 |
| Message-ID | <thv01i$h9v6$6@dont-email.me> |
| In reply to | #58284 |
On 10/9/2022 12:18 PM, Mr Flibble wrote:
> On Sun, 9 Oct 2022 12:14:39 -0500
> olcott <none-ya@beez-waxes.com> wrote:
>
>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
>>> On Sun, 9 Oct 2022 12:00:46 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>
>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> Once one accepts the notion of a simulating halt
>>>>>>>>>>>>>>>>>> decider that continues to correctly simulate its
>>>>>>>>>>>>>>>>>> input until it correctly determines that the this
>>>>>>>>>>>>>>>>>> simulated input would never stop running then the
>>>>>>>>>>>>>>>>>> conventional halting problem proofs are refuted.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate until it
>>>>>>>>>>>>>>>>> CORRECT decides that the ACTUAL input will never
>>>>>>>>>>>>>>>>> halts, but stops when a DIFFERENT input is shown to
>>>>>>>>>>>>>>>>> not halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is set
>>>>>>>>>>>>>>>> up because it is easier to defeat than an opponent's
>>>>>>>>>>>>>>>> real argument.
>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Strawman deception try again using the exact words
>>>>>>>>>>>>>>>> that I actually said.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Which isn't what I did, so you are just shown to be a
>>>>>>>>>>>>>>> LIAR.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> // P does the opposite of whatever H decides
>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>> if (Halt_Status) // if H(P,P) reports that its
>>>>>>>>>>>>>> input halts HERE: goto HERE; // P loops and never halts
>>>>>>>>>>>>>> return; // else P halts
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are asserting that the simulation of P by H would
>>>>>>>>>>>>>> eventually stop running on its own without being aborted
>>>>>>>>>>>>>> by H?
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, THAT is the strawman.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am asserting that the CORRECT simulation of P would
>>>>>>>>>>>>> eventually reach a final state,
>>>>>>>>>>>>
>>>>>>>>>>>> *You changed the words again*
>>>>>>>>>>>>
>>>>>>>>>>>> You are asserting that the simulation
>>>>>>>>>>>> of P by H
>>>>>>>>>>>> of P by H
>>>>>>>>>>>> of P by H
>>>>>>>>>>>> of P by H
>>>>>>>>>>>> of P by H
>>>>>>>>>>>> would eventually stop running on its own without being
>>>>>>>>>>>> aborted by H?
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, that's YOUR strawman.
>>>>>>>>>> If you knew anything about logic you would understand that
>>>>>>>>>> this is a premise: *Once one accepts the notion of a
>>>>>>>>>> simulating halt decider*
>>>>>>>>>>
>>>>>>>>>> One is not allowed to reject the premise. One is only allowed
>>>>>>>>>> to verify that the conclusion follows from the premise.
>>>>>>>>>
>>>>>>>>> SHD can only refute halting problem proofs if it is a pure
>>>>>>>>> function;
>>>>>>>>
>>>>>>>> Yes, it took me three full time months to convert H into a pure
>>>>>>>> function. I merely apply the exact same infinite recursion
>>>>>>>> criteria that is used to compute the halt status of:
>>>>>>>>
>>>>>>>> void Infinite_Recursion(u32 N)
>>>>>>>> {
>>>>>>>> Infinite_Recursion(N);
>>>>>>>> }
>>>>>>>>
>>>>>>>> Yet I apply this criteria immediately before recursive
>>>>>>>> simulation actually occurs. When H recognizes that P is about
>>>>>>>> to call H in recursive simulation H aborts its simulation of P
>>>>>>>> before its first call to H is ever invoked.
>>>>>>>
>>>>>>> If your H is a pure function and H(P,P) returns 0 then H(P,P)
>>>>>>> called from P(P) would also return 0
>>>>>>
>>>>>> <sarcasm>
>>>>>> Sure because everyone knows that a function that is never invoked
>>>>>> must still return a value in the same way we must be able to
>>>>>> start the engine of a car that has no engine.
>>>>>> </sarcasm>
>>>>>
>>>>> H(P,P) called from P(P) is the FIRST invocation of H(P,P) so is
>>>>> invoked, i.e. main() calling P(P) instead of H(P,P).
>>>>>
>>>>> Your H is not a halt decider as it gets the halting decision
>>>>> wrong.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Turing computable functions are not allowed to compute the mapping
>>>> of non-inputs or anything that cannot be encoded as a finite
>>>> string. That you fail to understand this is not any rebuttal of
>>>> what I have said.
>>>
>>> If H is a pure function and H(P,P) returns 0 then if P(P) is called
>>> from main() P(P) will halt which means H got the halting decision
>>> wrong meaning H is not a halt decider.
>>>
>>> /Flibble
>>>
>>
>> You continue to fail to understand that Turing computable functions
>> are not allowed to consider the behavior of non-inputs. That you fail
>> to understand this is not any error on my part.
>
> English is ambiguous, lets try code instead:
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> P(P);
> Output("P(P) halted ergo H(P, P) should have returned 1");
> }
>
> Given the above it is obvious to all that H is not a halt decider.
>
> /Flibble
>
The correct simulation of the input to H(P,P) by H is known to be the
behavior that H must measure on the basis that the correct simulation of
a machine description is known to provide the actual behavior of this
machine description.
What you are saying rejects the notion of a UTM.
--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-10-09 18:30 +0100 |
| Message-ID | <20221009183030.000063df@reddwarf.jmc.corp> |
| In reply to | #58285 |
On Sun, 9 Oct 2022 12:22:57 -0500
olcott <polcott2@gmail.com> wrote:
> On 10/9/2022 12:18 PM, Mr Flibble wrote:
> > On Sun, 9 Oct 2022 12:14:39 -0500
> > olcott <none-ya@beez-waxes.com> wrote:
> >
> >> On 10/9/2022 12:10 PM, Mr Flibble wrote:
> >>> On Sun, 9 Oct 2022 12:00:46 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
> >>>>> On Sun, 9 Oct 2022 11:46:10 -0500
> >>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>
> >>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
> >>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
> >>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>
> >>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
> >>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
> >>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
> >>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
> >>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
> >>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
> >>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>> Once one accepts the notion of a simulating halt
> >>>>>>>>>>>>>>>>>> decider that continues to correctly simulate its
> >>>>>>>>>>>>>>>>>> input until it correctly determines that the this
> >>>>>>>>>>>>>>>>>> simulated input would never stop running then the
> >>>>>>>>>>>>>>>>>> conventional halting problem proofs are refuted.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate until it
> >>>>>>>>>>>>>>>>> CORRECT decides that the ACTUAL input will never
> >>>>>>>>>>>>>>>>> halts, but stops when a DIFFERENT input is shown to
> >>>>>>>>>>>>>>>>> not halt.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> *straw man*
> >>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is
> >>>>>>>>>>>>>>>> set up because it is easier to defeat than an
> >>>>>>>>>>>>>>>> opponent's real argument.
> >>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Strawman deception try again using the exact words
> >>>>>>>>>>>>>>>> that I actually said.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Which isn't what I did, so you are just shown to be a
> >>>>>>>>>>>>>>> LIAR.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> // P does the opposite of whatever H decides
> >>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>> if (Halt_Status) // if H(P,P) reports that
> >>>>>>>>>>>>>> its input halts HERE: goto HERE; // P loops and never
> >>>>>>>>>>>>>> halts return; // else P halts
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> You are asserting that the simulation of P by H would
> >>>>>>>>>>>>>> eventually stop running on its own without being
> >>>>>>>>>>>>>> aborted by H?
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> No, THAT is the strawman.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> I am asserting that the CORRECT simulation of P would
> >>>>>>>>>>>>> eventually reach a final state,
> >>>>>>>>>>>>
> >>>>>>>>>>>> *You changed the words again*
> >>>>>>>>>>>>
> >>>>>>>>>>>> You are asserting that the simulation
> >>>>>>>>>>>> of P by H
> >>>>>>>>>>>> of P by H
> >>>>>>>>>>>> of P by H
> >>>>>>>>>>>> of P by H
> >>>>>>>>>>>> of P by H
> >>>>>>>>>>>> would eventually stop running on its own without being
> >>>>>>>>>>>> aborted by H?
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> No, that's YOUR strawman.
> >>>>>>>>>> If you knew anything about logic you would understand that
> >>>>>>>>>> this is a premise: *Once one accepts the notion of a
> >>>>>>>>>> simulating halt decider*
> >>>>>>>>>>
> >>>>>>>>>> One is not allowed to reject the premise. One is only
> >>>>>>>>>> allowed to verify that the conclusion follows from the
> >>>>>>>>>> premise.
> >>>>>>>>>
> >>>>>>>>> SHD can only refute halting problem proofs if it is a pure
> >>>>>>>>> function;
> >>>>>>>>
> >>>>>>>> Yes, it took me three full time months to convert H into a
> >>>>>>>> pure function. I merely apply the exact same infinite
> >>>>>>>> recursion criteria that is used to compute the halt status
> >>>>>>>> of:
> >>>>>>>>
> >>>>>>>> void Infinite_Recursion(u32 N)
> >>>>>>>> {
> >>>>>>>> Infinite_Recursion(N);
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> Yet I apply this criteria immediately before recursive
> >>>>>>>> simulation actually occurs. When H recognizes that P is about
> >>>>>>>> to call H in recursive simulation H aborts its simulation of
> >>>>>>>> P before its first call to H is ever invoked.
> >>>>>>>
> >>>>>>> If your H is a pure function and H(P,P) returns 0 then H(P,P)
> >>>>>>> called from P(P) would also return 0
> >>>>>>
> >>>>>> <sarcasm>
> >>>>>> Sure because everyone knows that a function that is never
> >>>>>> invoked must still return a value in the same way we must be
> >>>>>> able to start the engine of a car that has no engine.
> >>>>>> </sarcasm>
> >>>>>
> >>>>> H(P,P) called from P(P) is the FIRST invocation of H(P,P) so is
> >>>>> invoked, i.e. main() calling P(P) instead of H(P,P).
> >>>>>
> >>>>> Your H is not a halt decider as it gets the halting decision
> >>>>> wrong.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Turing computable functions are not allowed to compute the
> >>>> mapping of non-inputs or anything that cannot be encoded as a
> >>>> finite string. That you fail to understand this is not any
> >>>> rebuttal of what I have said.
> >>>
> >>> If H is a pure function and H(P,P) returns 0 then if P(P) is
> >>> called from main() P(P) will halt which means H got the halting
> >>> decision wrong meaning H is not a halt decider.
> >>>
> >>> /Flibble
> >>>
> >>
> >> You continue to fail to understand that Turing computable functions
> >> are not allowed to consider the behavior of non-inputs. That you
> >> fail to understand this is not any error on my part.
> >
> > English is ambiguous, lets try code instead:
> >
> > int main()
> > {
> > Output("Input_Halts = ", H(P, P));
> > P(P);
> > Output("P(P) halted ergo H(P, P) should have returned 1");
> > }
> >
> > Given the above it is obvious to all that H is not a halt decider.
> >
> > /Flibble
> >
>
> The correct simulation of the input to H(P,P) by H is known to be the
> behavior that H must measure on the basis that the correct simulation
> of a machine description is known to provide the actual behavior of
> this machine description.
>
> What you are saying rejects the notion of a UTM.
What I am saying is that programs are designed to be run rather than
just analyzed by a halt decider.
P(P) halts does it not? i.e. the following PROGRAM halts:
int main()
{
P(P);
}
You claim that H is a pure function and that H(P,P) returns 0 ergo your
H gets the halting decision wrong so is not a halt decider.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-10-09 12:48 -0500 |
| Message-ID | <thv1i8$h9v6$7@dont-email.me> |
| In reply to | #58286 |
On 10/9/2022 12:30 PM, Mr Flibble wrote:
> On Sun, 9 Oct 2022 12:22:57 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 10/9/2022 12:18 PM, Mr Flibble wrote:
>>> On Sun, 9 Oct 2022 12:14:39 -0500
>>> olcott <none-ya@beez-waxes.com> wrote:
>>>
>>>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
>>>>> On Sun, 9 Oct 2022 12:00:46 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
>>>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
>>>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
>>>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
>>>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> Once one accepts the notion of a simulating halt
>>>>>>>>>>>>>>>>>>>> decider that continues to correctly simulate its
>>>>>>>>>>>>>>>>>>>> input until it correctly determines that the this
>>>>>>>>>>>>>>>>>>>> simulated input would never stop running then the
>>>>>>>>>>>>>>>>>>>> conventional halting problem proofs are refuted.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate until it
>>>>>>>>>>>>>>>>>>> CORRECT decides that the ACTUAL input will never
>>>>>>>>>>>>>>>>>>> halts, but stops when a DIFFERENT input is shown to
>>>>>>>>>>>>>>>>>>> not halt.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is
>>>>>>>>>>>>>>>>>> set up because it is easier to defeat than an
>>>>>>>>>>>>>>>>>> opponent's real argument.
>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Strawman deception try again using the exact words
>>>>>>>>>>>>>>>>>> that I actually said.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Which isn't what I did, so you are just shown to be a
>>>>>>>>>>>>>>>>> LIAR.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> // P does the opposite of whatever H decides
>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>> if (Halt_Status) // if H(P,P) reports that
>>>>>>>>>>>>>>>> its input halts HERE: goto HERE; // P loops and never
>>>>>>>>>>>>>>>> halts return; // else P halts
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are asserting that the simulation of P by H would
>>>>>>>>>>>>>>>> eventually stop running on its own without being
>>>>>>>>>>>>>>>> aborted by H?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, THAT is the strawman.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I am asserting that the CORRECT simulation of P would
>>>>>>>>>>>>>>> eventually reach a final state,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *You changed the words again*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are asserting that the simulation
>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>> would eventually stop running on its own without being
>>>>>>>>>>>>>> aborted by H?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, that's YOUR strawman.
>>>>>>>>>>>> If you knew anything about logic you would understand that
>>>>>>>>>>>> this is a premise: *Once one accepts the notion of a
>>>>>>>>>>>> simulating halt decider*
>>>>>>>>>>>>
>>>>>>>>>>>> One is not allowed to reject the premise. One is only
>>>>>>>>>>>> allowed to verify that the conclusion follows from the
>>>>>>>>>>>> premise.
>>>>>>>>>>>
>>>>>>>>>>> SHD can only refute halting problem proofs if it is a pure
>>>>>>>>>>> function;
>>>>>>>>>>
>>>>>>>>>> Yes, it took me three full time months to convert H into a
>>>>>>>>>> pure function. I merely apply the exact same infinite
>>>>>>>>>> recursion criteria that is used to compute the halt status
>>>>>>>>>> of:
>>>>>>>>>>
>>>>>>>>>> void Infinite_Recursion(u32 N)
>>>>>>>>>> {
>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Yet I apply this criteria immediately before recursive
>>>>>>>>>> simulation actually occurs. When H recognizes that P is about
>>>>>>>>>> to call H in recursive simulation H aborts its simulation of
>>>>>>>>>> P before its first call to H is ever invoked.
>>>>>>>>>
>>>>>>>>> If your H is a pure function and H(P,P) returns 0 then H(P,P)
>>>>>>>>> called from P(P) would also return 0
>>>>>>>>
>>>>>>>> <sarcasm>
>>>>>>>> Sure because everyone knows that a function that is never
>>>>>>>> invoked must still return a value in the same way we must be
>>>>>>>> able to start the engine of a car that has no engine.
>>>>>>>> </sarcasm>
>>>>>>>
>>>>>>> H(P,P) called from P(P) is the FIRST invocation of H(P,P) so is
>>>>>>> invoked, i.e. main() calling P(P) instead of H(P,P).
>>>>>>>
>>>>>>> Your H is not a halt decider as it gets the halting decision
>>>>>>> wrong.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> Turing computable functions are not allowed to compute the
>>>>>> mapping of non-inputs or anything that cannot be encoded as a
>>>>>> finite string. That you fail to understand this is not any
>>>>>> rebuttal of what I have said.
>>>>>
>>>>> If H is a pure function and H(P,P) returns 0 then if P(P) is
>>>>> called from main() P(P) will halt which means H got the halting
>>>>> decision wrong meaning H is not a halt decider.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> You continue to fail to understand that Turing computable functions
>>>> are not allowed to consider the behavior of non-inputs. That you
>>>> fail to understand this is not any error on my part.
>>>
>>> English is ambiguous, lets try code instead:
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H(P, P));
>>> P(P);
>>> Output("P(P) halted ergo H(P, P) should have returned 1");
>>> }
>>>
>>> Given the above it is obvious to all that H is not a halt decider.
>>>
>>> /Flibble
>>>
>>
>> The correct simulation of the input to H(P,P) by H is known to be the
>> behavior that H must measure on the basis that the correct simulation
>> of a machine description is known to provide the actual behavior of
>> this machine description.
>>
>> What you are saying rejects the notion of a UTM.
>
> What I am saying is that programs are designed to be run rather than
> just analyzed by a halt decider.
>
> P(P) halts does it not? i.e. the following PROGRAM halts:
>
> int main()
> {
> P(P);
> }
>
> You claim that H is a pure function and that H(P,P) returns 0 ergo your
> H gets the halting decision wrong so is not a halt decider.
>
> /Flibble
>
H1(P,P) specifies a different sequence of configurations than H(P,P)
thus the value that H1 returns can vary from what H(P,P) returns.
When one simply assumes that pathological self-reference has no effect
on a sequence of configurations one is proven to be incorrect.
--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-10-09 18:51 +0100 |
| Message-ID | <20221009185136.00006077@reddwarf.jmc.corp> |
| In reply to | #58287 |
On Sun, 9 Oct 2022 12:48:55 -0500
olcott <polcott2@gmail.com> wrote:
> On 10/9/2022 12:30 PM, Mr Flibble wrote:
> > On Sun, 9 Oct 2022 12:22:57 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 10/9/2022 12:18 PM, Mr Flibble wrote:
> >>> On Sun, 9 Oct 2022 12:14:39 -0500
> >>> olcott <none-ya@beez-waxes.com> wrote:
> >>>
> >>>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
> >>>>> On Sun, 9 Oct 2022 12:00:46 -0500
> >>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>
> >>>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
> >>>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
> >>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>
> >>>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
> >>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
> >>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
> >>>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
> >>>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
> >>>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> Once one accepts the notion of a simulating halt
> >>>>>>>>>>>>>>>>>>>> decider that continues to correctly simulate its
> >>>>>>>>>>>>>>>>>>>> input until it correctly determines that the this
> >>>>>>>>>>>>>>>>>>>> simulated input would never stop running then the
> >>>>>>>>>>>>>>>>>>>> conventional halting problem proofs are refuted.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate until it
> >>>>>>>>>>>>>>>>>>> CORRECT decides that the ACTUAL input will never
> >>>>>>>>>>>>>>>>>>> halts, but stops when a DIFFERENT input is shown
> >>>>>>>>>>>>>>>>>>> to not halt.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> *straw man*
> >>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is
> >>>>>>>>>>>>>>>>>> set up because it is easier to defeat than an
> >>>>>>>>>>>>>>>>>> opponent's real argument.
> >>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Strawman deception try again using the exact words
> >>>>>>>>>>>>>>>>>> that I actually said.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Which isn't what I did, so you are just shown to be
> >>>>>>>>>>>>>>>>> a LIAR.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> // P does the opposite of whatever H decides
> >>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>> if (Halt_Status) // if H(P,P) reports
> >>>>>>>>>>>>>>>> that its input halts HERE: goto HERE; // P loops
> >>>>>>>>>>>>>>>> and never halts return; // else P halts
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> You are asserting that the simulation of P by H would
> >>>>>>>>>>>>>>>> eventually stop running on its own without being
> >>>>>>>>>>>>>>>> aborted by H?
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> No, THAT is the strawman.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> I am asserting that the CORRECT simulation of P would
> >>>>>>>>>>>>>>> eventually reach a final state,
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> *You changed the words again*
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> You are asserting that the simulation
> >>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>> would eventually stop running on its own without being
> >>>>>>>>>>>>>> aborted by H?
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> No, that's YOUR strawman.
> >>>>>>>>>>>> If you knew anything about logic you would understand
> >>>>>>>>>>>> that this is a premise: *Once one accepts the notion of a
> >>>>>>>>>>>> simulating halt decider*
> >>>>>>>>>>>>
> >>>>>>>>>>>> One is not allowed to reject the premise. One is only
> >>>>>>>>>>>> allowed to verify that the conclusion follows from the
> >>>>>>>>>>>> premise.
> >>>>>>>>>>>
> >>>>>>>>>>> SHD can only refute halting problem proofs if it is a pure
> >>>>>>>>>>> function;
> >>>>>>>>>>
> >>>>>>>>>> Yes, it took me three full time months to convert H into a
> >>>>>>>>>> pure function. I merely apply the exact same infinite
> >>>>>>>>>> recursion criteria that is used to compute the halt status
> >>>>>>>>>> of:
> >>>>>>>>>>
> >>>>>>>>>> void Infinite_Recursion(u32 N)
> >>>>>>>>>> {
> >>>>>>>>>> Infinite_Recursion(N);
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> Yet I apply this criteria immediately before recursive
> >>>>>>>>>> simulation actually occurs. When H recognizes that P is
> >>>>>>>>>> about to call H in recursive simulation H aborts its
> >>>>>>>>>> simulation of P before its first call to H is ever
> >>>>>>>>>> invoked.
> >>>>>>>>>
> >>>>>>>>> If your H is a pure function and H(P,P) returns 0 then
> >>>>>>>>> H(P,P) called from P(P) would also return 0
> >>>>>>>>
> >>>>>>>> <sarcasm>
> >>>>>>>> Sure because everyone knows that a function that is never
> >>>>>>>> invoked must still return a value in the same way we must be
> >>>>>>>> able to start the engine of a car that has no engine.
> >>>>>>>> </sarcasm>
> >>>>>>>
> >>>>>>> H(P,P) called from P(P) is the FIRST invocation of H(P,P) so
> >>>>>>> is invoked, i.e. main() calling P(P) instead of H(P,P).
> >>>>>>>
> >>>>>>> Your H is not a halt decider as it gets the halting decision
> >>>>>>> wrong.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> Turing computable functions are not allowed to compute the
> >>>>>> mapping of non-inputs or anything that cannot be encoded as a
> >>>>>> finite string. That you fail to understand this is not any
> >>>>>> rebuttal of what I have said.
> >>>>>
> >>>>> If H is a pure function and H(P,P) returns 0 then if P(P) is
> >>>>> called from main() P(P) will halt which means H got the halting
> >>>>> decision wrong meaning H is not a halt decider.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> You continue to fail to understand that Turing computable
> >>>> functions are not allowed to consider the behavior of
> >>>> non-inputs. That you fail to understand this is not any error on
> >>>> my part.
> >>>
> >>> English is ambiguous, lets try code instead:
> >>>
> >>> int main()
> >>> {
> >>> Output("Input_Halts = ", H(P, P));
> >>> P(P);
> >>> Output("P(P) halted ergo H(P, P) should have returned 1");
> >>> }
> >>>
> >>> Given the above it is obvious to all that H is not a halt decider.
> >>>
> >>> /Flibble
> >>>
> >>
> >> The correct simulation of the input to H(P,P) by H is known to be
> >> the behavior that H must measure on the basis that the correct
> >> simulation of a machine description is known to provide the actual
> >> behavior of this machine description.
> >>
> >> What you are saying rejects the notion of a UTM.
> >
> > What I am saying is that programs are designed to be run rather than
> > just analyzed by a halt decider.
> >
> > P(P) halts does it not? i.e. the following PROGRAM halts:
> >
> > int main()
> > {
> > P(P);
> > }
> >
> > You claim that H is a pure function and that H(P,P) returns 0 ergo
> > your H gets the halting decision wrong so is not a halt decider.
> >
> > /Flibble
> >
>
> H1(P,P) specifies a different sequence of configurations than H(P,P)
> thus the value that H1 returns can vary from what H(P,P) returns.
>
> When one simply assumes that pathological self-reference has no
> effect on a sequence of configurations one is proven to be incorrect.
P(P) is still calling H not this mysterious H1 you have just invented.
Your H gets the halting decision wrong so is not a halt decider.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-10-09 12:57 -0500 |
| Message-ID | <thv21i$h9v6$8@dont-email.me> |
| In reply to | #58288 |
On 10/9/2022 12:51 PM, Mr Flibble wrote:
> On Sun, 9 Oct 2022 12:48:55 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 10/9/2022 12:30 PM, Mr Flibble wrote:
>>> On Sun, 9 Oct 2022 12:22:57 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 10/9/2022 12:18 PM, Mr Flibble wrote:
>>>>> On Sun, 9 Oct 2022 12:14:39 -0500
>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>
>>>>>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
>>>>>>> On Sun, 9 Oct 2022 12:00:46 -0500
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
>>>>>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
>>>>>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> Once one accepts the notion of a simulating halt
>>>>>>>>>>>>>>>>>>>>>> decider that continues to correctly simulate its
>>>>>>>>>>>>>>>>>>>>>> input until it correctly determines that the this
>>>>>>>>>>>>>>>>>>>>>> simulated input would never stop running then the
>>>>>>>>>>>>>>>>>>>>>> conventional halting problem proofs are refuted.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate until it
>>>>>>>>>>>>>>>>>>>>> CORRECT decides that the ACTUAL input will never
>>>>>>>>>>>>>>>>>>>>> halts, but stops when a DIFFERENT input is shown
>>>>>>>>>>>>>>>>>>>>> to not halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is
>>>>>>>>>>>>>>>>>>>> set up because it is easier to defeat than an
>>>>>>>>>>>>>>>>>>>> opponent's real argument.
>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Strawman deception try again using the exact words
>>>>>>>>>>>>>>>>>>>> that I actually said.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Which isn't what I did, so you are just shown to be
>>>>>>>>>>>>>>>>>>> a LIAR.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> // P does the opposite of whatever H decides
>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>> if (Halt_Status) // if H(P,P) reports
>>>>>>>>>>>>>>>>>> that its input halts HERE: goto HERE; // P loops
>>>>>>>>>>>>>>>>>> and never halts return; // else P halts
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are asserting that the simulation of P by H would
>>>>>>>>>>>>>>>>>> eventually stop running on its own without being
>>>>>>>>>>>>>>>>>> aborted by H?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, THAT is the strawman.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I am asserting that the CORRECT simulation of P would
>>>>>>>>>>>>>>>>> eventually reach a final state,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *You changed the words again*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are asserting that the simulation
>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>> would eventually stop running on its own without being
>>>>>>>>>>>>>>>> aborted by H?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, that's YOUR strawman.
>>>>>>>>>>>>>> If you knew anything about logic you would understand
>>>>>>>>>>>>>> that this is a premise: *Once one accepts the notion of a
>>>>>>>>>>>>>> simulating halt decider*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> One is not allowed to reject the premise. One is only
>>>>>>>>>>>>>> allowed to verify that the conclusion follows from the
>>>>>>>>>>>>>> premise.
>>>>>>>>>>>>>
>>>>>>>>>>>>> SHD can only refute halting problem proofs if it is a pure
>>>>>>>>>>>>> function;
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, it took me three full time months to convert H into a
>>>>>>>>>>>> pure function. I merely apply the exact same infinite
>>>>>>>>>>>> recursion criteria that is used to compute the halt status
>>>>>>>>>>>> of:
>>>>>>>>>>>>
>>>>>>>>>>>> void Infinite_Recursion(u32 N)
>>>>>>>>>>>> {
>>>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> Yet I apply this criteria immediately before recursive
>>>>>>>>>>>> simulation actually occurs. When H recognizes that P is
>>>>>>>>>>>> about to call H in recursive simulation H aborts its
>>>>>>>>>>>> simulation of P before its first call to H is ever
>>>>>>>>>>>> invoked.
>>>>>>>>>>>
>>>>>>>>>>> If your H is a pure function and H(P,P) returns 0 then
>>>>>>>>>>> H(P,P) called from P(P) would also return 0
>>>>>>>>>>
>>>>>>>>>> <sarcasm>
>>>>>>>>>> Sure because everyone knows that a function that is never
>>>>>>>>>> invoked must still return a value in the same way we must be
>>>>>>>>>> able to start the engine of a car that has no engine.
>>>>>>>>>> </sarcasm>
>>>>>>>>>
>>>>>>>>> H(P,P) called from P(P) is the FIRST invocation of H(P,P) so
>>>>>>>>> is invoked, i.e. main() calling P(P) instead of H(P,P).
>>>>>>>>>
>>>>>>>>> Your H is not a halt decider as it gets the halting decision
>>>>>>>>> wrong.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> Turing computable functions are not allowed to compute the
>>>>>>>> mapping of non-inputs or anything that cannot be encoded as a
>>>>>>>> finite string. That you fail to understand this is not any
>>>>>>>> rebuttal of what I have said.
>>>>>>>
>>>>>>> If H is a pure function and H(P,P) returns 0 then if P(P) is
>>>>>>> called from main() P(P) will halt which means H got the halting
>>>>>>> decision wrong meaning H is not a halt decider.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> You continue to fail to understand that Turing computable
>>>>>> functions are not allowed to consider the behavior of
>>>>>> non-inputs. That you fail to understand this is not any error on
>>>>>> my part.
>>>>>
>>>>> English is ambiguous, lets try code instead:
>>>>>
>>>>> int main()
>>>>> {
>>>>> Output("Input_Halts = ", H(P, P));
>>>>> P(P);
>>>>> Output("P(P) halted ergo H(P, P) should have returned 1");
>>>>> }
>>>>>
>>>>> Given the above it is obvious to all that H is not a halt decider.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> The correct simulation of the input to H(P,P) by H is known to be
>>>> the behavior that H must measure on the basis that the correct
>>>> simulation of a machine description is known to provide the actual
>>>> behavior of this machine description.
>>>>
>>>> What you are saying rejects the notion of a UTM.
>>>
>>> What I am saying is that programs are designed to be run rather than
>>> just analyzed by a halt decider.
>>>
>>> P(P) halts does it not? i.e. the following PROGRAM halts:
>>>
>>> int main()
>>> {
>>> P(P);
>>> }
>>>
>>> You claim that H is a pure function and that H(P,P) returns 0 ergo
>>> your H gets the halting decision wrong so is not a halt decider.
>>>
>>> /Flibble
>>>
>>
>> H1(P,P) specifies a different sequence of configurations than H(P,P)
>> thus the value that H1 returns can vary from what H(P,P) returns.
>>
>> When one simply assumes that pathological self-reference has no
>> effect on a sequence of configurations one is proven to be incorrect.
>
> P(P) is still calling H not this mysterious H1 you have just invented.
> Your H gets the halting decision wrong so is not a halt decider.
>
> /Flibble
>
H1(P,P) reports on the behavior of int main() { P(P); }
H(P,P) is not allowed to report on the behavior of int main() { P(P); }
--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-10-09 19:07 +0100 |
| Message-ID | <20221009190712.000022d3@reddwarf.jmc.corp> |
| In reply to | #58289 |
On Sun, 9 Oct 2022 12:57:05 -0500
olcott <polcott2@gmail.com> wrote:
> On 10/9/2022 12:51 PM, Mr Flibble wrote:
> > On Sun, 9 Oct 2022 12:48:55 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 10/9/2022 12:30 PM, Mr Flibble wrote:
> >>> On Sun, 9 Oct 2022 12:22:57 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 10/9/2022 12:18 PM, Mr Flibble wrote:
> >>>>> On Sun, 9 Oct 2022 12:14:39 -0500
> >>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>
> >>>>>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 9 Oct 2022 12:00:46 -0500
> >>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>
> >>>>>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
> >>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
> >>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
> >>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
> >>>>>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> Once one accepts the notion of a simulating
> >>>>>>>>>>>>>>>>>>>>>> halt decider that continues to correctly
> >>>>>>>>>>>>>>>>>>>>>> simulate its input until it correctly
> >>>>>>>>>>>>>>>>>>>>>> determines that the this simulated input would
> >>>>>>>>>>>>>>>>>>>>>> never stop running then the conventional
> >>>>>>>>>>>>>>>>>>>>>> halting problem proofs are refuted.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate until
> >>>>>>>>>>>>>>>>>>>>> it CORRECT decides that the ACTUAL input will
> >>>>>>>>>>>>>>>>>>>>> never halts, but stops when a DIFFERENT input
> >>>>>>>>>>>>>>>>>>>>> is shown to not halt.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> *straw man*
> >>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that
> >>>>>>>>>>>>>>>>>>>> is set up because it is easier to defeat than an
> >>>>>>>>>>>>>>>>>>>> opponent's real argument.
> >>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Strawman deception try again using the exact
> >>>>>>>>>>>>>>>>>>>> words that I actually said.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Which isn't what I did, so you are just shown to
> >>>>>>>>>>>>>>>>>>> be a LIAR.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> // P does the opposite of whatever H decides
> >>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>> if (Halt_Status) // if H(P,P) reports
> >>>>>>>>>>>>>>>>>> that its input halts HERE: goto HERE; // P loops
> >>>>>>>>>>>>>>>>>> and never halts return; // else P halts
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> You are asserting that the simulation of P by H
> >>>>>>>>>>>>>>>>>> would eventually stop running on its own without
> >>>>>>>>>>>>>>>>>> being aborted by H?
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> No, THAT is the strawman.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> I am asserting that the CORRECT simulation of P
> >>>>>>>>>>>>>>>>> would eventually reach a final state,
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> *You changed the words again*
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> You are asserting that the simulation
> >>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>> would eventually stop running on its own without
> >>>>>>>>>>>>>>>> being aborted by H?
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> No, that's YOUR strawman.
> >>>>>>>>>>>>>> If you knew anything about logic you would understand
> >>>>>>>>>>>>>> that this is a premise: *Once one accepts the notion
> >>>>>>>>>>>>>> of a simulating halt decider*
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> One is not allowed to reject the premise. One is only
> >>>>>>>>>>>>>> allowed to verify that the conclusion follows from the
> >>>>>>>>>>>>>> premise.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> SHD can only refute halting problem proofs if it is a
> >>>>>>>>>>>>> pure function;
> >>>>>>>>>>>>
> >>>>>>>>>>>> Yes, it took me three full time months to convert H into
> >>>>>>>>>>>> a pure function. I merely apply the exact same infinite
> >>>>>>>>>>>> recursion criteria that is used to compute the halt
> >>>>>>>>>>>> status of:
> >>>>>>>>>>>>
> >>>>>>>>>>>> void Infinite_Recursion(u32 N)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> Infinite_Recursion(N);
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> Yet I apply this criteria immediately before recursive
> >>>>>>>>>>>> simulation actually occurs. When H recognizes that P is
> >>>>>>>>>>>> about to call H in recursive simulation H aborts its
> >>>>>>>>>>>> simulation of P before its first call to H is ever
> >>>>>>>>>>>> invoked.
> >>>>>>>>>>>
> >>>>>>>>>>> If your H is a pure function and H(P,P) returns 0 then
> >>>>>>>>>>> H(P,P) called from P(P) would also return 0
> >>>>>>>>>>
> >>>>>>>>>> <sarcasm>
> >>>>>>>>>> Sure because everyone knows that a function that is never
> >>>>>>>>>> invoked must still return a value in the same way we must
> >>>>>>>>>> be able to start the engine of a car that has no engine.
> >>>>>>>>>> </sarcasm>
> >>>>>>>>>
> >>>>>>>>> H(P,P) called from P(P) is the FIRST invocation of H(P,P) so
> >>>>>>>>> is invoked, i.e. main() calling P(P) instead of H(P,P).
> >>>>>>>>>
> >>>>>>>>> Your H is not a halt decider as it gets the halting decision
> >>>>>>>>> wrong.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Turing computable functions are not allowed to compute the
> >>>>>>>> mapping of non-inputs or anything that cannot be encoded as a
> >>>>>>>> finite string. That you fail to understand this is not any
> >>>>>>>> rebuttal of what I have said.
> >>>>>>>
> >>>>>>> If H is a pure function and H(P,P) returns 0 then if P(P) is
> >>>>>>> called from main() P(P) will halt which means H got the
> >>>>>>> halting decision wrong meaning H is not a halt decider.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> You continue to fail to understand that Turing computable
> >>>>>> functions are not allowed to consider the behavior of
> >>>>>> non-inputs. That you fail to understand this is not any error
> >>>>>> on my part.
> >>>>>
> >>>>> English is ambiguous, lets try code instead:
> >>>>>
> >>>>> int main()
> >>>>> {
> >>>>> Output("Input_Halts = ", H(P, P));
> >>>>> P(P);
> >>>>> Output("P(P) halted ergo H(P, P) should have returned 1");
> >>>>> }
> >>>>>
> >>>>> Given the above it is obvious to all that H is not a halt
> >>>>> decider.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> The correct simulation of the input to H(P,P) by H is known to be
> >>>> the behavior that H must measure on the basis that the correct
> >>>> simulation of a machine description is known to provide the
> >>>> actual behavior of this machine description.
> >>>>
> >>>> What you are saying rejects the notion of a UTM.
> >>>
> >>> What I am saying is that programs are designed to be run rather
> >>> than just analyzed by a halt decider.
> >>>
> >>> P(P) halts does it not? i.e. the following PROGRAM halts:
> >>>
> >>> int main()
> >>> {
> >>> P(P);
> >>> }
> >>>
> >>> You claim that H is a pure function and that H(P,P) returns 0 ergo
> >>> your H gets the halting decision wrong so is not a halt decider.
> >>>
> >>> /Flibble
> >>>
> >>
> >> H1(P,P) specifies a different sequence of configurations than
> >> H(P,P) thus the value that H1 returns can vary from what H(P,P)
> >> returns.
> >>
> >> When one simply assumes that pathological self-reference has no
> >> effect on a sequence of configurations one is proven to be
> >> incorrect.
> >
> > P(P) is still calling H not this mysterious H1 you have just
> > invented. Your H gets the halting decision wrong so is not a halt
> > decider.
> >
> > /Flibble
> >
> H1(P,P) reports on the behavior of int main() { P(P); }
> H(P,P) is not allowed to report on the behavior of int main() { P(P);
> }
>
Given:
int main()
{
H(P,P);
}
H(P,P) is NOT deciding on main() but on P(P) so why would there be a
mysterious H1 deciding on main()?
You claim that H is a pure function in which case it doesn't matter if
it is being called from main() or from P(P) called from main(). You
are now trying to invent something else that decides on main() rather
than what main() calls as some kind of bullshit diversionary tactic.
H(P,P) returns non-halting and yet P(P) halts ergo H is not a halt
decider.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <none-ya@beez-waxes.com> |
|---|---|
| Date | 2022-10-09 13:10 -0500 |
| Message-ID | <thv2rd$16m6$1@gioia.aioe.org> |
| In reply to | #58290 |
On 10/9/2022 1:07 PM, Mr Flibble wrote:
> On Sun, 9 Oct 2022 12:57:05 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 10/9/2022 12:51 PM, Mr Flibble wrote:
>>> On Sun, 9 Oct 2022 12:48:55 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 10/9/2022 12:30 PM, Mr Flibble wrote:
>>>>> On Sun, 9 Oct 2022 12:22:57 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 10/9/2022 12:18 PM, Mr Flibble wrote:
>>>>>>> On Sun, 9 Oct 2022 12:14:39 -0500
>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>
>>>>>>>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
>>>>>>>>> On Sun, 9 Oct 2022 12:00:46 -0500
>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
>>>>>>>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> Once one accepts the notion of a simulating
>>>>>>>>>>>>>>>>>>>>>>>> halt decider that continues to correctly
>>>>>>>>>>>>>>>>>>>>>>>> simulate its input until it correctly
>>>>>>>>>>>>>>>>>>>>>>>> determines that the this simulated input would
>>>>>>>>>>>>>>>>>>>>>>>> never stop running then the conventional
>>>>>>>>>>>>>>>>>>>>>>>> halting problem proofs are refuted.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate until
>>>>>>>>>>>>>>>>>>>>>>> it CORRECT decides that the ACTUAL input will
>>>>>>>>>>>>>>>>>>>>>>> never halts, but stops when a DIFFERENT input
>>>>>>>>>>>>>>>>>>>>>>> is shown to not halt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that
>>>>>>>>>>>>>>>>>>>>>> is set up because it is easier to defeat than an
>>>>>>>>>>>>>>>>>>>>>> opponent's real argument.
>>>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Strawman deception try again using the exact
>>>>>>>>>>>>>>>>>>>>>> words that I actually said.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Which isn't what I did, so you are just shown to
>>>>>>>>>>>>>>>>>>>>> be a LIAR.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> // P does the opposite of whatever H decides
>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // if H(P,P) reports
>>>>>>>>>>>>>>>>>>>> that its input halts HERE: goto HERE; // P loops
>>>>>>>>>>>>>>>>>>>> and never halts return; // else P halts
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are asserting that the simulation of P by H
>>>>>>>>>>>>>>>>>>>> would eventually stop running on its own without
>>>>>>>>>>>>>>>>>>>> being aborted by H?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, THAT is the strawman.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I am asserting that the CORRECT simulation of P
>>>>>>>>>>>>>>>>>>> would eventually reach a final state,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *You changed the words again*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are asserting that the simulation
>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>> would eventually stop running on its own without
>>>>>>>>>>>>>>>>>> being aborted by H?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, that's YOUR strawman.
>>>>>>>>>>>>>>>> If you knew anything about logic you would understand
>>>>>>>>>>>>>>>> that this is a premise: *Once one accepts the notion
>>>>>>>>>>>>>>>> of a simulating halt decider*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> One is not allowed to reject the premise. One is only
>>>>>>>>>>>>>>>> allowed to verify that the conclusion follows from the
>>>>>>>>>>>>>>>> premise.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> SHD can only refute halting problem proofs if it is a
>>>>>>>>>>>>>>> pure function;
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, it took me three full time months to convert H into
>>>>>>>>>>>>>> a pure function. I merely apply the exact same infinite
>>>>>>>>>>>>>> recursion criteria that is used to compute the halt
>>>>>>>>>>>>>> status of:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void Infinite_Recursion(u32 N)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yet I apply this criteria immediately before recursive
>>>>>>>>>>>>>> simulation actually occurs. When H recognizes that P is
>>>>>>>>>>>>>> about to call H in recursive simulation H aborts its
>>>>>>>>>>>>>> simulation of P before its first call to H is ever
>>>>>>>>>>>>>> invoked.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If your H is a pure function and H(P,P) returns 0 then
>>>>>>>>>>>>> H(P,P) called from P(P) would also return 0
>>>>>>>>>>>>
>>>>>>>>>>>> <sarcasm>
>>>>>>>>>>>> Sure because everyone knows that a function that is never
>>>>>>>>>>>> invoked must still return a value in the same way we must
>>>>>>>>>>>> be able to start the engine of a car that has no engine.
>>>>>>>>>>>> </sarcasm>
>>>>>>>>>>>
>>>>>>>>>>> H(P,P) called from P(P) is the FIRST invocation of H(P,P) so
>>>>>>>>>>> is invoked, i.e. main() calling P(P) instead of H(P,P).
>>>>>>>>>>>
>>>>>>>>>>> Your H is not a halt decider as it gets the halting decision
>>>>>>>>>>> wrong.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Turing computable functions are not allowed to compute the
>>>>>>>>>> mapping of non-inputs or anything that cannot be encoded as a
>>>>>>>>>> finite string. That you fail to understand this is not any
>>>>>>>>>> rebuttal of what I have said.
>>>>>>>>>
>>>>>>>>> If H is a pure function and H(P,P) returns 0 then if P(P) is
>>>>>>>>> called from main() P(P) will halt which means H got the
>>>>>>>>> halting decision wrong meaning H is not a halt decider.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> You continue to fail to understand that Turing computable
>>>>>>>> functions are not allowed to consider the behavior of
>>>>>>>> non-inputs. That you fail to understand this is not any error
>>>>>>>> on my part.
>>>>>>>
>>>>>>> English is ambiguous, lets try code instead:
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>> P(P);
>>>>>>> Output("P(P) halted ergo H(P, P) should have returned 1");
>>>>>>> }
>>>>>>>
>>>>>>> Given the above it is obvious to all that H is not a halt
>>>>>>> decider.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> The correct simulation of the input to H(P,P) by H is known to be
>>>>>> the behavior that H must measure on the basis that the correct
>>>>>> simulation of a machine description is known to provide the
>>>>>> actual behavior of this machine description.
>>>>>>
>>>>>> What you are saying rejects the notion of a UTM.
>>>>>
>>>>> What I am saying is that programs are designed to be run rather
>>>>> than just analyzed by a halt decider.
>>>>>
>>>>> P(P) halts does it not? i.e. the following PROGRAM halts:
>>>>>
>>>>> int main()
>>>>> {
>>>>> P(P);
>>>>> }
>>>>>
>>>>> You claim that H is a pure function and that H(P,P) returns 0 ergo
>>>>> your H gets the halting decision wrong so is not a halt decider.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> H1(P,P) specifies a different sequence of configurations than
>>>> H(P,P) thus the value that H1 returns can vary from what H(P,P)
>>>> returns.
>>>>
>>>> When one simply assumes that pathological self-reference has no
>>>> effect on a sequence of configurations one is proven to be
>>>> incorrect.
>>>
>>> P(P) is still calling H not this mysterious H1 you have just
>>> invented. Your H gets the halting decision wrong so is not a halt
>>> decider.
>>>
>>> /Flibble
>>>
>> H1(P,P) reports on the behavior of int main() { P(P); }
>> H(P,P) is not allowed to report on the behavior of int main() { P(P);
>> }
>>
>
> Given:
>
> int main()
> {
> H(P,P);
> }
>
> H(P,P) is NOT deciding on main() but on P(P) so why would there be a
> mysterious H1 deciding on main()?
>
There is no mystery, H1 is an exact copy of H, yet does not have the
pathological self-reference relationship with P. H1 is included in this
project.
Complete halt deciding system (Visual Studio Project)
(a) x86utm operating system
(b) x86 emulator adapted from libx86emu to compile under Windows
(c) Several halt deciders and their sample inputs contained within Halt7.c
https://liarparadox.org/2022_09_07.zip
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-10-09 19:12 +0100 |
| Message-ID | <20221009191241.00006c1a@reddwarf.jmc.corp> |
| In reply to | #58291 |
On Sun, 9 Oct 2022 13:10:51 -0500
olcott <none-ya@beez-waxes.com> wrote:
> On 10/9/2022 1:07 PM, Mr Flibble wrote:
> > On Sun, 9 Oct 2022 12:57:05 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 10/9/2022 12:51 PM, Mr Flibble wrote:
> >>> On Sun, 9 Oct 2022 12:48:55 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 10/9/2022 12:30 PM, Mr Flibble wrote:
> >>>>> On Sun, 9 Oct 2022 12:22:57 -0500
> >>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>
> >>>>>> On 10/9/2022 12:18 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 9 Oct 2022 12:14:39 -0500
> >>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>
> >>>>>>>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 9 Oct 2022 12:00:46 -0500
> >>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
> >>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
> >>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
> >>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> Once one accepts the notion of a simulating
> >>>>>>>>>>>>>>>>>>>>>>>> halt decider that continues to correctly
> >>>>>>>>>>>>>>>>>>>>>>>> simulate its input until it correctly
> >>>>>>>>>>>>>>>>>>>>>>>> determines that the this simulated input
> >>>>>>>>>>>>>>>>>>>>>>>> would never stop running then the
> >>>>>>>>>>>>>>>>>>>>>>>> conventional halting problem proofs are
> >>>>>>>>>>>>>>>>>>>>>>>> refuted.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate
> >>>>>>>>>>>>>>>>>>>>>>> until it CORRECT decides that the ACTUAL
> >>>>>>>>>>>>>>>>>>>>>>> input will never halts, but stops when a
> >>>>>>>>>>>>>>>>>>>>>>> DIFFERENT input is shown to not halt.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> *straw man*
> >>>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition
> >>>>>>>>>>>>>>>>>>>>>> that is set up because it is easier to defeat
> >>>>>>>>>>>>>>>>>>>>>> than an opponent's real argument.
> >>>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Strawman deception try again using the exact
> >>>>>>>>>>>>>>>>>>>>>> words that I actually said.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Which isn't what I did, so you are just shown to
> >>>>>>>>>>>>>>>>>>>>> be a LIAR.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> // P does the opposite of whatever H decides
> >>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>>>> if (Halt_Status) // if H(P,P)
> >>>>>>>>>>>>>>>>>>>> reports that its input halts HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>> // P loops and never halts return;
> >>>>>>>>>>>>>>>>>>>> // else P halts }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> You are asserting that the simulation of P by H
> >>>>>>>>>>>>>>>>>>>> would eventually stop running on its own without
> >>>>>>>>>>>>>>>>>>>> being aborted by H?
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> No, THAT is the strawman.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> I am asserting that the CORRECT simulation of P
> >>>>>>>>>>>>>>>>>>> would eventually reach a final state,
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> *You changed the words again*
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> You are asserting that the simulation
> >>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>> would eventually stop running on its own without
> >>>>>>>>>>>>>>>>>> being aborted by H?
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> No, that's YOUR strawman.
> >>>>>>>>>>>>>>>> If you knew anything about logic you would understand
> >>>>>>>>>>>>>>>> that this is a premise: *Once one accepts the notion
> >>>>>>>>>>>>>>>> of a simulating halt decider*
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> One is not allowed to reject the premise. One is only
> >>>>>>>>>>>>>>>> allowed to verify that the conclusion follows from
> >>>>>>>>>>>>>>>> the premise.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> SHD can only refute halting problem proofs if it is a
> >>>>>>>>>>>>>>> pure function;
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Yes, it took me three full time months to convert H
> >>>>>>>>>>>>>> into a pure function. I merely apply the exact same
> >>>>>>>>>>>>>> infinite recursion criteria that is used to compute
> >>>>>>>>>>>>>> the halt status of:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> void Infinite_Recursion(u32 N)
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> Infinite_Recursion(N);
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Yet I apply this criteria immediately before recursive
> >>>>>>>>>>>>>> simulation actually occurs. When H recognizes that P is
> >>>>>>>>>>>>>> about to call H in recursive simulation H aborts its
> >>>>>>>>>>>>>> simulation of P before its first call to H is ever
> >>>>>>>>>>>>>> invoked.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If your H is a pure function and H(P,P) returns 0 then
> >>>>>>>>>>>>> H(P,P) called from P(P) would also return 0
> >>>>>>>>>>>>
> >>>>>>>>>>>> <sarcasm>
> >>>>>>>>>>>> Sure because everyone knows that a function that is never
> >>>>>>>>>>>> invoked must still return a value in the same way we must
> >>>>>>>>>>>> be able to start the engine of a car that has no engine.
> >>>>>>>>>>>> </sarcasm>
> >>>>>>>>>>>
> >>>>>>>>>>> H(P,P) called from P(P) is the FIRST invocation of H(P,P)
> >>>>>>>>>>> so is invoked, i.e. main() calling P(P) instead of H(P,P).
> >>>>>>>>>>>
> >>>>>>>>>>> Your H is not a halt decider as it gets the halting
> >>>>>>>>>>> decision wrong.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Turing computable functions are not allowed to compute the
> >>>>>>>>>> mapping of non-inputs or anything that cannot be encoded
> >>>>>>>>>> as a finite string. That you fail to understand this is
> >>>>>>>>>> not any rebuttal of what I have said.
> >>>>>>>>>
> >>>>>>>>> If H is a pure function and H(P,P) returns 0 then if P(P) is
> >>>>>>>>> called from main() P(P) will halt which means H got the
> >>>>>>>>> halting decision wrong meaning H is not a halt decider.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> You continue to fail to understand that Turing computable
> >>>>>>>> functions are not allowed to consider the behavior of
> >>>>>>>> non-inputs. That you fail to understand this is not any error
> >>>>>>>> on my part.
> >>>>>>>
> >>>>>>> English is ambiguous, lets try code instead:
> >>>>>>>
> >>>>>>> int main()
> >>>>>>> {
> >>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>> P(P);
> >>>>>>> Output("P(P) halted ergo H(P, P) should have returned
> >>>>>>> 1"); }
> >>>>>>>
> >>>>>>> Given the above it is obvious to all that H is not a halt
> >>>>>>> decider.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> The correct simulation of the input to H(P,P) by H is known to
> >>>>>> be the behavior that H must measure on the basis that the
> >>>>>> correct simulation of a machine description is known to
> >>>>>> provide the actual behavior of this machine description.
> >>>>>>
> >>>>>> What you are saying rejects the notion of a UTM.
> >>>>>
> >>>>> What I am saying is that programs are designed to be run rather
> >>>>> than just analyzed by a halt decider.
> >>>>>
> >>>>> P(P) halts does it not? i.e. the following PROGRAM halts:
> >>>>>
> >>>>> int main()
> >>>>> {
> >>>>> P(P);
> >>>>> }
> >>>>>
> >>>>> You claim that H is a pure function and that H(P,P) returns 0
> >>>>> ergo your H gets the halting decision wrong so is not a halt
> >>>>> decider.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> H1(P,P) specifies a different sequence of configurations than
> >>>> H(P,P) thus the value that H1 returns can vary from what H(P,P)
> >>>> returns.
> >>>>
> >>>> When one simply assumes that pathological self-reference has no
> >>>> effect on a sequence of configurations one is proven to be
> >>>> incorrect.
> >>>
> >>> P(P) is still calling H not this mysterious H1 you have just
> >>> invented. Your H gets the halting decision wrong so is not a halt
> >>> decider.
> >>>
> >>> /Flibble
> >>>
> >> H1(P,P) reports on the behavior of int main() { P(P); }
> >> H(P,P) is not allowed to report on the behavior of int main() {
> >> P(P); }
> >>
> >
> > Given:
> >
> > int main()
> > {
> > H(P,P);
> > }
> >
> > H(P,P) is NOT deciding on main() but on P(P) so why would there be a
> > mysterious H1 deciding on main()?
> >
>
> There is no mystery, H1 is an exact copy of H, yet does not have the
> pathological self-reference relationship with P. H1 is included in
> this project.
>
> Complete halt deciding system (Visual Studio Project)
> (a) x86utm operating system
> (b) x86 emulator adapted from libx86emu to compile under Windows
> (c) Several halt deciders and their sample inputs contained within
> Halt7.c https://liarparadox.org/2022_09_07.zip
int main()
{
Output("Input_Halts = ", H(P,P));
P(P);
Output("P(P) halted ergo H(P,P) should have returned 1");
}
Given the above it is obvious to all that H is not a halt decider.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-10-09 13:18 -0500 |
| Message-ID | <thv3a1$h9v6$9@dont-email.me> |
| In reply to | #58292 |
On 10/9/2022 1:12 PM, Mr Flibble wrote:
> On Sun, 9 Oct 2022 13:10:51 -0500
> olcott <none-ya@beez-waxes.com> wrote:
>
>> On 10/9/2022 1:07 PM, Mr Flibble wrote:
>>> On Sun, 9 Oct 2022 12:57:05 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 10/9/2022 12:51 PM, Mr Flibble wrote:
>>>>> On Sun, 9 Oct 2022 12:48:55 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 10/9/2022 12:30 PM, Mr Flibble wrote:
>>>>>>> On Sun, 9 Oct 2022 12:22:57 -0500
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 10/9/2022 12:18 PM, Mr Flibble wrote:
>>>>>>>>> On Sun, 9 Oct 2022 12:14:39 -0500
>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
>>>>>>>>>>> On Sun, 9 Oct 2022 12:00:46 -0500
>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> Once one accepts the notion of a simulating
>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider that continues to correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> simulate its input until it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> determines that the this simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running then the
>>>>>>>>>>>>>>>>>>>>>>>>>> conventional halting problem proofs are
>>>>>>>>>>>>>>>>>>>>>>>>>> refuted.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate
>>>>>>>>>>>>>>>>>>>>>>>>> until it CORRECT decides that the ACTUAL
>>>>>>>>>>>>>>>>>>>>>>>>> input will never halts, but stops when a
>>>>>>>>>>>>>>>>>>>>>>>>> DIFFERENT input is shown to not halt.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition
>>>>>>>>>>>>>>>>>>>>>>>> that is set up because it is easier to defeat
>>>>>>>>>>>>>>>>>>>>>>>> than an opponent's real argument.
>>>>>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception try again using the exact
>>>>>>>>>>>>>>>>>>>>>>>> words that I actually said.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Which isn't what I did, so you are just shown to
>>>>>>>>>>>>>>>>>>>>>>> be a LIAR.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> // P does the opposite of whatever H decides
>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // if H(P,P)
>>>>>>>>>>>>>>>>>>>>>> reports that its input halts HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>> // P loops and never halts return;
>>>>>>>>>>>>>>>>>>>>>> // else P halts }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are asserting that the simulation of P by H
>>>>>>>>>>>>>>>>>>>>>> would eventually stop running on its own without
>>>>>>>>>>>>>>>>>>>>>> being aborted by H?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, THAT is the strawman.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I am asserting that the CORRECT simulation of P
>>>>>>>>>>>>>>>>>>>>> would eventually reach a final state,
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *You changed the words again*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are asserting that the simulation
>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>> would eventually stop running on its own without
>>>>>>>>>>>>>>>>>>>> being aborted by H?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, that's YOUR strawman.
>>>>>>>>>>>>>>>>>> If you knew anything about logic you would understand
>>>>>>>>>>>>>>>>>> that this is a premise: *Once one accepts the notion
>>>>>>>>>>>>>>>>>> of a simulating halt decider*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> One is not allowed to reject the premise. One is only
>>>>>>>>>>>>>>>>>> allowed to verify that the conclusion follows from
>>>>>>>>>>>>>>>>>> the premise.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> SHD can only refute halting problem proofs if it is a
>>>>>>>>>>>>>>>>> pure function;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes, it took me three full time months to convert H
>>>>>>>>>>>>>>>> into a pure function. I merely apply the exact same
>>>>>>>>>>>>>>>> infinite recursion criteria that is used to compute
>>>>>>>>>>>>>>>> the halt status of:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void Infinite_Recursion(u32 N)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yet I apply this criteria immediately before recursive
>>>>>>>>>>>>>>>> simulation actually occurs. When H recognizes that P is
>>>>>>>>>>>>>>>> about to call H in recursive simulation H aborts its
>>>>>>>>>>>>>>>> simulation of P before its first call to H is ever
>>>>>>>>>>>>>>>> invoked.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If your H is a pure function and H(P,P) returns 0 then
>>>>>>>>>>>>>>> H(P,P) called from P(P) would also return 0
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> <sarcasm>
>>>>>>>>>>>>>> Sure because everyone knows that a function that is never
>>>>>>>>>>>>>> invoked must still return a value in the same way we must
>>>>>>>>>>>>>> be able to start the engine of a car that has no engine.
>>>>>>>>>>>>>> </sarcasm>
>>>>>>>>>>>>>
>>>>>>>>>>>>> H(P,P) called from P(P) is the FIRST invocation of H(P,P)
>>>>>>>>>>>>> so is invoked, i.e. main() calling P(P) instead of H(P,P).
>>>>>>>>>>>>>
>>>>>>>>>>>>> Your H is not a halt decider as it gets the halting
>>>>>>>>>>>>> decision wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Turing computable functions are not allowed to compute the
>>>>>>>>>>>> mapping of non-inputs or anything that cannot be encoded
>>>>>>>>>>>> as a finite string. That you fail to understand this is
>>>>>>>>>>>> not any rebuttal of what I have said.
>>>>>>>>>>>
>>>>>>>>>>> If H is a pure function and H(P,P) returns 0 then if P(P) is
>>>>>>>>>>> called from main() P(P) will halt which means H got the
>>>>>>>>>>> halting decision wrong meaning H is not a halt decider.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You continue to fail to understand that Turing computable
>>>>>>>>>> functions are not allowed to consider the behavior of
>>>>>>>>>> non-inputs. That you fail to understand this is not any error
>>>>>>>>>> on my part.
>>>>>>>>>
>>>>>>>>> English is ambiguous, lets try code instead:
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>> P(P);
>>>>>>>>> Output("P(P) halted ergo H(P, P) should have returned
>>>>>>>>> 1"); }
>>>>>>>>>
>>>>>>>>> Given the above it is obvious to all that H is not a halt
>>>>>>>>> decider.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> The correct simulation of the input to H(P,P) by H is known to
>>>>>>>> be the behavior that H must measure on the basis that the
>>>>>>>> correct simulation of a machine description is known to
>>>>>>>> provide the actual behavior of this machine description.
>>>>>>>>
>>>>>>>> What you are saying rejects the notion of a UTM.
>>>>>>>
>>>>>>> What I am saying is that programs are designed to be run rather
>>>>>>> than just analyzed by a halt decider.
>>>>>>>
>>>>>>> P(P) halts does it not? i.e. the following PROGRAM halts:
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> P(P);
>>>>>>> }
>>>>>>>
>>>>>>> You claim that H is a pure function and that H(P,P) returns 0
>>>>>>> ergo your H gets the halting decision wrong so is not a halt
>>>>>>> decider.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> H1(P,P) specifies a different sequence of configurations than
>>>>>> H(P,P) thus the value that H1 returns can vary from what H(P,P)
>>>>>> returns.
>>>>>>
>>>>>> When one simply assumes that pathological self-reference has no
>>>>>> effect on a sequence of configurations one is proven to be
>>>>>> incorrect.
>>>>>
>>>>> P(P) is still calling H not this mysterious H1 you have just
>>>>> invented. Your H gets the halting decision wrong so is not a halt
>>>>> decider.
>>>>>
>>>>> /Flibble
>>>>>
>>>> H1(P,P) reports on the behavior of int main() { P(P); }
>>>> H(P,P) is not allowed to report on the behavior of int main() {
>>>> P(P); }
>>>>
>>>
>>> Given:
>>>
>>> int main()
>>> {
>>> H(P,P);
>>> }
>>>
>>> H(P,P) is NOT deciding on main() but on P(P) so why would there be a
>>> mysterious H1 deciding on main()?
>>>
>>
>> There is no mystery, H1 is an exact copy of H, yet does not have the
>> pathological self-reference relationship with P. H1 is included in
>> this project.
>>
>> Complete halt deciding system (Visual Studio Project)
>> (a) x86utm operating system
>> (b) x86 emulator adapted from libx86emu to compile under Windows
>> (c) Several halt deciders and their sample inputs contained within
>> Halt7.c https://liarparadox.org/2022_09_07.zip
>
> int main()
> {
> Output("Input_Halts = ", H(P,P));
> P(P);
> Output("P(P) halted ergo H(P,P) should have returned 1");
> }
>
> Given the above it is obvious to all that H is not a halt decider.
>
> /Flibble
>
>
Not when one pays close attention, then one realizes that the behavior
that H(P,P) reports on is different behavior than H1(P,P) reports on.
H1(P,P) reports on the behavior of int main() { P(P); }.
Complete halt deciding system (Visual Studio Project)
(a) x86utm operating system
(b) x86 emulator adapted from libx86emu to compile under Windows
(c) Several halt deciders and their sample inputs contained within Halt7.c
https://liarparadox.org/2022_09_07.zip
Every rebuttal of my work in the last 12 months has always been based on
one provably false assumption or another.
--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-10-09 19:23 +0100 |
| Message-ID | <20221009192303.00007be7@reddwarf.jmc.corp> |
| In reply to | #58291 |
On Sun, 9 Oct 2022 13:10:51 -0500
olcott <none-ya@beez-waxes.com> wrote:
> On 10/9/2022 1:07 PM, Mr Flibble wrote:
> > On Sun, 9 Oct 2022 12:57:05 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 10/9/2022 12:51 PM, Mr Flibble wrote:
> >>> On Sun, 9 Oct 2022 12:48:55 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 10/9/2022 12:30 PM, Mr Flibble wrote:
> >>>>> On Sun, 9 Oct 2022 12:22:57 -0500
> >>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>
> >>>>>> On 10/9/2022 12:18 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 9 Oct 2022 12:14:39 -0500
> >>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>
> >>>>>>>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 9 Oct 2022 12:00:46 -0500
> >>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
> >>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
> >>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
> >>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> Once one accepts the notion of a simulating
> >>>>>>>>>>>>>>>>>>>>>>>> halt decider that continues to correctly
> >>>>>>>>>>>>>>>>>>>>>>>> simulate its input until it correctly
> >>>>>>>>>>>>>>>>>>>>>>>> determines that the this simulated input
> >>>>>>>>>>>>>>>>>>>>>>>> would never stop running then the
> >>>>>>>>>>>>>>>>>>>>>>>> conventional halting problem proofs are
> >>>>>>>>>>>>>>>>>>>>>>>> refuted.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate
> >>>>>>>>>>>>>>>>>>>>>>> until it CORRECT decides that the ACTUAL
> >>>>>>>>>>>>>>>>>>>>>>> input will never halts, but stops when a
> >>>>>>>>>>>>>>>>>>>>>>> DIFFERENT input is shown to not halt.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> *straw man*
> >>>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition
> >>>>>>>>>>>>>>>>>>>>>> that is set up because it is easier to defeat
> >>>>>>>>>>>>>>>>>>>>>> than an opponent's real argument.
> >>>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Strawman deception try again using the exact
> >>>>>>>>>>>>>>>>>>>>>> words that I actually said.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Which isn't what I did, so you are just shown to
> >>>>>>>>>>>>>>>>>>>>> be a LIAR.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> // P does the opposite of whatever H decides
> >>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>>>> if (Halt_Status) // if H(P,P)
> >>>>>>>>>>>>>>>>>>>> reports that its input halts HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>> // P loops and never halts return;
> >>>>>>>>>>>>>>>>>>>> // else P halts }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> You are asserting that the simulation of P by H
> >>>>>>>>>>>>>>>>>>>> would eventually stop running on its own without
> >>>>>>>>>>>>>>>>>>>> being aborted by H?
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> No, THAT is the strawman.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> I am asserting that the CORRECT simulation of P
> >>>>>>>>>>>>>>>>>>> would eventually reach a final state,
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> *You changed the words again*
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> You are asserting that the simulation
> >>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>> would eventually stop running on its own without
> >>>>>>>>>>>>>>>>>> being aborted by H?
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> No, that's YOUR strawman.
> >>>>>>>>>>>>>>>> If you knew anything about logic you would understand
> >>>>>>>>>>>>>>>> that this is a premise: *Once one accepts the notion
> >>>>>>>>>>>>>>>> of a simulating halt decider*
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> One is not allowed to reject the premise. One is only
> >>>>>>>>>>>>>>>> allowed to verify that the conclusion follows from
> >>>>>>>>>>>>>>>> the premise.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> SHD can only refute halting problem proofs if it is a
> >>>>>>>>>>>>>>> pure function;
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Yes, it took me three full time months to convert H
> >>>>>>>>>>>>>> into a pure function. I merely apply the exact same
> >>>>>>>>>>>>>> infinite recursion criteria that is used to compute
> >>>>>>>>>>>>>> the halt status of:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> void Infinite_Recursion(u32 N)
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> Infinite_Recursion(N);
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Yet I apply this criteria immediately before recursive
> >>>>>>>>>>>>>> simulation actually occurs. When H recognizes that P is
> >>>>>>>>>>>>>> about to call H in recursive simulation H aborts its
> >>>>>>>>>>>>>> simulation of P before its first call to H is ever
> >>>>>>>>>>>>>> invoked.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If your H is a pure function and H(P,P) returns 0 then
> >>>>>>>>>>>>> H(P,P) called from P(P) would also return 0
> >>>>>>>>>>>>
> >>>>>>>>>>>> <sarcasm>
> >>>>>>>>>>>> Sure because everyone knows that a function that is never
> >>>>>>>>>>>> invoked must still return a value in the same way we must
> >>>>>>>>>>>> be able to start the engine of a car that has no engine.
> >>>>>>>>>>>> </sarcasm>
> >>>>>>>>>>>
> >>>>>>>>>>> H(P,P) called from P(P) is the FIRST invocation of H(P,P)
> >>>>>>>>>>> so is invoked, i.e. main() calling P(P) instead of H(P,P).
> >>>>>>>>>>>
> >>>>>>>>>>> Your H is not a halt decider as it gets the halting
> >>>>>>>>>>> decision wrong.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Turing computable functions are not allowed to compute the
> >>>>>>>>>> mapping of non-inputs or anything that cannot be encoded
> >>>>>>>>>> as a finite string. That you fail to understand this is
> >>>>>>>>>> not any rebuttal of what I have said.
> >>>>>>>>>
> >>>>>>>>> If H is a pure function and H(P,P) returns 0 then if P(P) is
> >>>>>>>>> called from main() P(P) will halt which means H got the
> >>>>>>>>> halting decision wrong meaning H is not a halt decider.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> You continue to fail to understand that Turing computable
> >>>>>>>> functions are not allowed to consider the behavior of
> >>>>>>>> non-inputs. That you fail to understand this is not any error
> >>>>>>>> on my part.
> >>>>>>>
> >>>>>>> English is ambiguous, lets try code instead:
> >>>>>>>
> >>>>>>> int main()
> >>>>>>> {
> >>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>> P(P);
> >>>>>>> Output("P(P) halted ergo H(P, P) should have returned
> >>>>>>> 1"); }
> >>>>>>>
> >>>>>>> Given the above it is obvious to all that H is not a halt
> >>>>>>> decider.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> The correct simulation of the input to H(P,P) by H is known to
> >>>>>> be the behavior that H must measure on the basis that the
> >>>>>> correct simulation of a machine description is known to
> >>>>>> provide the actual behavior of this machine description.
> >>>>>>
> >>>>>> What you are saying rejects the notion of a UTM.
> >>>>>
> >>>>> What I am saying is that programs are designed to be run rather
> >>>>> than just analyzed by a halt decider.
> >>>>>
> >>>>> P(P) halts does it not? i.e. the following PROGRAM halts:
> >>>>>
> >>>>> int main()
> >>>>> {
> >>>>> P(P);
> >>>>> }
> >>>>>
> >>>>> You claim that H is a pure function and that H(P,P) returns 0
> >>>>> ergo your H gets the halting decision wrong so is not a halt
> >>>>> decider.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> H1(P,P) specifies a different sequence of configurations than
> >>>> H(P,P) thus the value that H1 returns can vary from what H(P,P)
> >>>> returns.
> >>>>
> >>>> When one simply assumes that pathological self-reference has no
> >>>> effect on a sequence of configurations one is proven to be
> >>>> incorrect.
> >>>
> >>> P(P) is still calling H not this mysterious H1 you have just
> >>> invented. Your H gets the halting decision wrong so is not a halt
> >>> decider.
> >>>
> >>> /Flibble
> >>>
> >> H1(P,P) reports on the behavior of int main() { P(P); }
> >> H(P,P) is not allowed to report on the behavior of int main() {
> >> P(P); }
> >>
> >
> > Given:
> >
> > int main()
> > {
> > H(P,P);
> > }
> >
> > H(P,P) is NOT deciding on main() but on P(P) so why would there be a
> > mysterious H1 deciding on main()?
> >
>
> There is no mystery, H1 is an exact copy of H, yet does not have the
> pathological self-reference relationship with P. H1 is included in
> this project.
>
> Complete halt deciding system (Visual Studio Project)
> (a) x86utm operating system
> (b) x86 emulator adapted from libx86emu to compile under Windows
> (c) Several halt deciders and their sample inputs contained within
> Halt7.c https://liarparadox.org/2022_09_07.zip
If H1 is an exact copy of H and H is a pure function then:
int main()
{
H1(P,P); // returns 1
H(P,P); // returns 0
}
This contradiction is proof that do do not have a working halt decider
and that you have not refuted the halting problem proofs.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-10-09 13:28 -0500 |
| Message-ID | <thv3ro$h9v6$10@dont-email.me> |
| In reply to | #58294 |
On 10/9/2022 1:23 PM, Mr Flibble wrote:
> On Sun, 9 Oct 2022 13:10:51 -0500
> olcott <none-ya@beez-waxes.com> wrote:
>
>> On 10/9/2022 1:07 PM, Mr Flibble wrote:
>>> On Sun, 9 Oct 2022 12:57:05 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 10/9/2022 12:51 PM, Mr Flibble wrote:
>>>>> On Sun, 9 Oct 2022 12:48:55 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 10/9/2022 12:30 PM, Mr Flibble wrote:
>>>>>>> On Sun, 9 Oct 2022 12:22:57 -0500
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 10/9/2022 12:18 PM, Mr Flibble wrote:
>>>>>>>>> On Sun, 9 Oct 2022 12:14:39 -0500
>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
>>>>>>>>>>> On Sun, 9 Oct 2022 12:00:46 -0500
>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> Once one accepts the notion of a simulating
>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider that continues to correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> simulate its input until it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> determines that the this simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running then the
>>>>>>>>>>>>>>>>>>>>>>>>>> conventional halting problem proofs are
>>>>>>>>>>>>>>>>>>>>>>>>>> refuted.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate
>>>>>>>>>>>>>>>>>>>>>>>>> until it CORRECT decides that the ACTUAL
>>>>>>>>>>>>>>>>>>>>>>>>> input will never halts, but stops when a
>>>>>>>>>>>>>>>>>>>>>>>>> DIFFERENT input is shown to not halt.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition
>>>>>>>>>>>>>>>>>>>>>>>> that is set up because it is easier to defeat
>>>>>>>>>>>>>>>>>>>>>>>> than an opponent's real argument.
>>>>>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception try again using the exact
>>>>>>>>>>>>>>>>>>>>>>>> words that I actually said.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Which isn't what I did, so you are just shown to
>>>>>>>>>>>>>>>>>>>>>>> be a LIAR.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> // P does the opposite of whatever H decides
>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // if H(P,P)
>>>>>>>>>>>>>>>>>>>>>> reports that its input halts HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>> // P loops and never halts return;
>>>>>>>>>>>>>>>>>>>>>> // else P halts }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are asserting that the simulation of P by H
>>>>>>>>>>>>>>>>>>>>>> would eventually stop running on its own without
>>>>>>>>>>>>>>>>>>>>>> being aborted by H?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, THAT is the strawman.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I am asserting that the CORRECT simulation of P
>>>>>>>>>>>>>>>>>>>>> would eventually reach a final state,
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *You changed the words again*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are asserting that the simulation
>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>> would eventually stop running on its own without
>>>>>>>>>>>>>>>>>>>> being aborted by H?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, that's YOUR strawman.
>>>>>>>>>>>>>>>>>> If you knew anything about logic you would understand
>>>>>>>>>>>>>>>>>> that this is a premise: *Once one accepts the notion
>>>>>>>>>>>>>>>>>> of a simulating halt decider*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> One is not allowed to reject the premise. One is only
>>>>>>>>>>>>>>>>>> allowed to verify that the conclusion follows from
>>>>>>>>>>>>>>>>>> the premise.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> SHD can only refute halting problem proofs if it is a
>>>>>>>>>>>>>>>>> pure function;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes, it took me three full time months to convert H
>>>>>>>>>>>>>>>> into a pure function. I merely apply the exact same
>>>>>>>>>>>>>>>> infinite recursion criteria that is used to compute
>>>>>>>>>>>>>>>> the halt status of:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void Infinite_Recursion(u32 N)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yet I apply this criteria immediately before recursive
>>>>>>>>>>>>>>>> simulation actually occurs. When H recognizes that P is
>>>>>>>>>>>>>>>> about to call H in recursive simulation H aborts its
>>>>>>>>>>>>>>>> simulation of P before its first call to H is ever
>>>>>>>>>>>>>>>> invoked.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If your H is a pure function and H(P,P) returns 0 then
>>>>>>>>>>>>>>> H(P,P) called from P(P) would also return 0
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> <sarcasm>
>>>>>>>>>>>>>> Sure because everyone knows that a function that is never
>>>>>>>>>>>>>> invoked must still return a value in the same way we must
>>>>>>>>>>>>>> be able to start the engine of a car that has no engine.
>>>>>>>>>>>>>> </sarcasm>
>>>>>>>>>>>>>
>>>>>>>>>>>>> H(P,P) called from P(P) is the FIRST invocation of H(P,P)
>>>>>>>>>>>>> so is invoked, i.e. main() calling P(P) instead of H(P,P).
>>>>>>>>>>>>>
>>>>>>>>>>>>> Your H is not a halt decider as it gets the halting
>>>>>>>>>>>>> decision wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Turing computable functions are not allowed to compute the
>>>>>>>>>>>> mapping of non-inputs or anything that cannot be encoded
>>>>>>>>>>>> as a finite string. That you fail to understand this is
>>>>>>>>>>>> not any rebuttal of what I have said.
>>>>>>>>>>>
>>>>>>>>>>> If H is a pure function and H(P,P) returns 0 then if P(P) is
>>>>>>>>>>> called from main() P(P) will halt which means H got the
>>>>>>>>>>> halting decision wrong meaning H is not a halt decider.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You continue to fail to understand that Turing computable
>>>>>>>>>> functions are not allowed to consider the behavior of
>>>>>>>>>> non-inputs. That you fail to understand this is not any error
>>>>>>>>>> on my part.
>>>>>>>>>
>>>>>>>>> English is ambiguous, lets try code instead:
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>> P(P);
>>>>>>>>> Output("P(P) halted ergo H(P, P) should have returned
>>>>>>>>> 1"); }
>>>>>>>>>
>>>>>>>>> Given the above it is obvious to all that H is not a halt
>>>>>>>>> decider.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> The correct simulation of the input to H(P,P) by H is known to
>>>>>>>> be the behavior that H must measure on the basis that the
>>>>>>>> correct simulation of a machine description is known to
>>>>>>>> provide the actual behavior of this machine description.
>>>>>>>>
>>>>>>>> What you are saying rejects the notion of a UTM.
>>>>>>>
>>>>>>> What I am saying is that programs are designed to be run rather
>>>>>>> than just analyzed by a halt decider.
>>>>>>>
>>>>>>> P(P) halts does it not? i.e. the following PROGRAM halts:
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> P(P);
>>>>>>> }
>>>>>>>
>>>>>>> You claim that H is a pure function and that H(P,P) returns 0
>>>>>>> ergo your H gets the halting decision wrong so is not a halt
>>>>>>> decider.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> H1(P,P) specifies a different sequence of configurations than
>>>>>> H(P,P) thus the value that H1 returns can vary from what H(P,P)
>>>>>> returns.
>>>>>>
>>>>>> When one simply assumes that pathological self-reference has no
>>>>>> effect on a sequence of configurations one is proven to be
>>>>>> incorrect.
>>>>>
>>>>> P(P) is still calling H not this mysterious H1 you have just
>>>>> invented. Your H gets the halting decision wrong so is not a halt
>>>>> decider.
>>>>>
>>>>> /Flibble
>>>>>
>>>> H1(P,P) reports on the behavior of int main() { P(P); }
>>>> H(P,P) is not allowed to report on the behavior of int main() {
>>>> P(P); }
>>>>
>>>
>>> Given:
>>>
>>> int main()
>>> {
>>> H(P,P);
>>> }
>>>
>>> H(P,P) is NOT deciding on main() but on P(P) so why would there be a
>>> mysterious H1 deciding on main()?
>>>
>>
>> There is no mystery, H1 is an exact copy of H, yet does not have the
>> pathological self-reference relationship with P. H1 is included in
>> this project.
>>
>> Complete halt deciding system (Visual Studio Project)
>> (a) x86utm operating system
>> (b) x86 emulator adapted from libx86emu to compile under Windows
>> (c) Several halt deciders and their sample inputs contained within
>> Halt7.c https://liarparadox.org/2022_09_07.zip
>
> If H1 is an exact copy of H and H is a pure function then:
>
> int main()
> {
> H1(P,P); // returns 1
> H(P,P); // returns 0
> }
>
> This contradiction is proof that do do not have a working halt decider
> and that you have not refuted the halting problem proofs.
>
> /Flibble
>
It can be easily verified that the correctly simulated behavior that H1
sees is different behavior than the correctly simulated behavior that H
sees because of the pathological self-reference relationship between H
and P.
A function must always return the same value for the same inputs.
Different functions can return different values for the same inputs.
Add(2,3) returns a different value than Multiply(2,3).
--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-10-09 19:31 +0100 |
| Message-ID | <20221009193129.00006a85@reddwarf.jmc.corp> |
| In reply to | #58295 |
On Sun, 9 Oct 2022 13:28:07 -0500
olcott <polcott2@gmail.com> wrote:
> On 10/9/2022 1:23 PM, Mr Flibble wrote:
> > On Sun, 9 Oct 2022 13:10:51 -0500
> > olcott <none-ya@beez-waxes.com> wrote:
> >
> >> On 10/9/2022 1:07 PM, Mr Flibble wrote:
> >>> On Sun, 9 Oct 2022 12:57:05 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 10/9/2022 12:51 PM, Mr Flibble wrote:
> >>>>> On Sun, 9 Oct 2022 12:48:55 -0500
> >>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>
> >>>>>> On 10/9/2022 12:30 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 9 Oct 2022 12:22:57 -0500
> >>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>
> >>>>>>>> On 10/9/2022 12:18 PM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 9 Oct 2022 12:14:39 -0500
> >>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
> >>>>>>>>>>> On Sun, 9 Oct 2022 12:00:46 -0500
> >>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
> >>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
> >>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
> >>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> Once one accepts the notion of a simulating
> >>>>>>>>>>>>>>>>>>>>>>>>>> halt decider that continues to correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulate its input until it correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>> determines that the this simulated input
> >>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running then the
> >>>>>>>>>>>>>>>>>>>>>>>>>> conventional halting problem proofs are
> >>>>>>>>>>>>>>>>>>>>>>>>>> refuted.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate
> >>>>>>>>>>>>>>>>>>>>>>>>> until it CORRECT decides that the ACTUAL
> >>>>>>>>>>>>>>>>>>>>>>>>> input will never halts, but stops when a
> >>>>>>>>>>>>>>>>>>>>>>>>> DIFFERENT input is shown to not halt.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> *straw man*
> >>>>>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition
> >>>>>>>>>>>>>>>>>>>>>>>> that is set up because it is easier to defeat
> >>>>>>>>>>>>>>>>>>>>>>>> than an opponent's real argument.
> >>>>>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Strawman deception try again using the exact
> >>>>>>>>>>>>>>>>>>>>>>>> words that I actually said.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> Which isn't what I did, so you are just shown
> >>>>>>>>>>>>>>>>>>>>>>> to be a LIAR.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> // P does the opposite of whatever H decides
> >>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // if H(P,P)
> >>>>>>>>>>>>>>>>>>>>>> reports that its input halts HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>> // P loops and never halts return;
> >>>>>>>>>>>>>>>>>>>>>> // else P halts }
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> You are asserting that the simulation of P by H
> >>>>>>>>>>>>>>>>>>>>>> would eventually stop running on its own
> >>>>>>>>>>>>>>>>>>>>>> without being aborted by H?
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> No, THAT is the strawman.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> I am asserting that the CORRECT simulation of P
> >>>>>>>>>>>>>>>>>>>>> would eventually reach a final state,
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> *You changed the words again*
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> You are asserting that the simulation
> >>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>> would eventually stop running on its own without
> >>>>>>>>>>>>>>>>>>>> being aborted by H?
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> No, that's YOUR strawman.
> >>>>>>>>>>>>>>>>>> If you knew anything about logic you would
> >>>>>>>>>>>>>>>>>> understand that this is a premise: *Once one
> >>>>>>>>>>>>>>>>>> accepts the notion of a simulating halt decider*
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> One is not allowed to reject the premise. One is
> >>>>>>>>>>>>>>>>>> only allowed to verify that the conclusion follows
> >>>>>>>>>>>>>>>>>> from the premise.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> SHD can only refute halting problem proofs if it is
> >>>>>>>>>>>>>>>>> a pure function;
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Yes, it took me three full time months to convert H
> >>>>>>>>>>>>>>>> into a pure function. I merely apply the exact same
> >>>>>>>>>>>>>>>> infinite recursion criteria that is used to compute
> >>>>>>>>>>>>>>>> the halt status of:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> void Infinite_Recursion(u32 N)
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> Infinite_Recursion(N);
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Yet I apply this criteria immediately before
> >>>>>>>>>>>>>>>> recursive simulation actually occurs. When H
> >>>>>>>>>>>>>>>> recognizes that P is about to call H in recursive
> >>>>>>>>>>>>>>>> simulation H aborts its simulation of P before its
> >>>>>>>>>>>>>>>> first call to H is ever invoked.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> If your H is a pure function and H(P,P) returns 0 then
> >>>>>>>>>>>>>>> H(P,P) called from P(P) would also return 0
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> <sarcasm>
> >>>>>>>>>>>>>> Sure because everyone knows that a function that is
> >>>>>>>>>>>>>> never invoked must still return a value in the same
> >>>>>>>>>>>>>> way we must be able to start the engine of a car that
> >>>>>>>>>>>>>> has no engine. </sarcasm>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> H(P,P) called from P(P) is the FIRST invocation of
> >>>>>>>>>>>>> H(P,P) so is invoked, i.e. main() calling P(P) instead
> >>>>>>>>>>>>> of H(P,P).
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Your H is not a halt decider as it gets the halting
> >>>>>>>>>>>>> decision wrong.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> Turing computable functions are not allowed to compute
> >>>>>>>>>>>> the mapping of non-inputs or anything that cannot be
> >>>>>>>>>>>> encoded as a finite string. That you fail to understand
> >>>>>>>>>>>> this is not any rebuttal of what I have said.
> >>>>>>>>>>>
> >>>>>>>>>>> If H is a pure function and H(P,P) returns 0 then if P(P)
> >>>>>>>>>>> is called from main() P(P) will halt which means H got the
> >>>>>>>>>>> halting decision wrong meaning H is not a halt decider.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> You continue to fail to understand that Turing computable
> >>>>>>>>>> functions are not allowed to consider the behavior of
> >>>>>>>>>> non-inputs. That you fail to understand this is not any
> >>>>>>>>>> error on my part.
> >>>>>>>>>
> >>>>>>>>> English is ambiguous, lets try code instead:
> >>>>>>>>>
> >>>>>>>>> int main()
> >>>>>>>>> {
> >>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>> P(P);
> >>>>>>>>> Output("P(P) halted ergo H(P, P) should have returned
> >>>>>>>>> 1"); }
> >>>>>>>>>
> >>>>>>>>> Given the above it is obvious to all that H is not a halt
> >>>>>>>>> decider.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> The correct simulation of the input to H(P,P) by H is known
> >>>>>>>> to be the behavior that H must measure on the basis that the
> >>>>>>>> correct simulation of a machine description is known to
> >>>>>>>> provide the actual behavior of this machine description.
> >>>>>>>>
> >>>>>>>> What you are saying rejects the notion of a UTM.
> >>>>>>>
> >>>>>>> What I am saying is that programs are designed to be run
> >>>>>>> rather than just analyzed by a halt decider.
> >>>>>>>
> >>>>>>> P(P) halts does it not? i.e. the following PROGRAM halts:
> >>>>>>>
> >>>>>>> int main()
> >>>>>>> {
> >>>>>>> P(P);
> >>>>>>> }
> >>>>>>>
> >>>>>>> You claim that H is a pure function and that H(P,P) returns 0
> >>>>>>> ergo your H gets the halting decision wrong so is not a halt
> >>>>>>> decider.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> H1(P,P) specifies a different sequence of configurations than
> >>>>>> H(P,P) thus the value that H1 returns can vary from what H(P,P)
> >>>>>> returns.
> >>>>>>
> >>>>>> When one simply assumes that pathological self-reference has no
> >>>>>> effect on a sequence of configurations one is proven to be
> >>>>>> incorrect.
> >>>>>
> >>>>> P(P) is still calling H not this mysterious H1 you have just
> >>>>> invented. Your H gets the halting decision wrong so is not a
> >>>>> halt decider.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>> H1(P,P) reports on the behavior of int main() { P(P); }
> >>>> H(P,P) is not allowed to report on the behavior of int main() {
> >>>> P(P); }
> >>>>
> >>>
> >>> Given:
> >>>
> >>> int main()
> >>> {
> >>> H(P,P);
> >>> }
> >>>
> >>> H(P,P) is NOT deciding on main() but on P(P) so why would there
> >>> be a mysterious H1 deciding on main()?
> >>>
> >>
> >> There is no mystery, H1 is an exact copy of H, yet does not have
> >> the pathological self-reference relationship with P. H1 is
> >> included in this project.
> >>
> >> Complete halt deciding system (Visual Studio Project)
> >> (a) x86utm operating system
> >> (b) x86 emulator adapted from libx86emu to compile under Windows
> >> (c) Several halt deciders and their sample inputs contained within
> >> Halt7.c https://liarparadox.org/2022_09_07.zip
> >
> > If H1 is an exact copy of H and H is a pure function then:
> >
> > int main()
> > {
> > H1(P,P); // returns 1
> > H(P,P); // returns 0
> > }
> >
> > This contradiction is proof that do do not have a working halt
> > decider and that you have not refuted the halting problem proofs.
> >
> > /Flibble
> >
>
> It can be easily verified that the correctly simulated behavior that
> H1 sees is different behavior than the correctly simulated behavior
> that H sees because of the pathological self-reference relationship
> between H and P.
>
> A function must always return the same value for the same inputs.
> Different functions can return different values for the same inputs.
> Add(2,3) returns a different value than Multiply(2,3).
If H1 is an exact copy of H and H is a pure function then H1 should
return the same result for the same input as H; it doesn't because you
don't have a working halt decider and haven't refuted the halting
problem proofs.
Only I have refuted the halting problem proofs with the Flibble
Signaling Halt Decider (TM).
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <none-ya@beez-waxes.com> |
|---|---|
| Date | 2022-10-09 13:40 -0500 |
| Message-ID | <thv4jp$1ef$1@gioia.aioe.org> |
| In reply to | #58296 |
On 10/9/2022 1:31 PM, Mr Flibble wrote:
> On Sun, 9 Oct 2022 13:28:07 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 10/9/2022 1:23 PM, Mr Flibble wrote:
>>> On Sun, 9 Oct 2022 13:10:51 -0500
>>> olcott <none-ya@beez-waxes.com> wrote:
>>>
>>>> On 10/9/2022 1:07 PM, Mr Flibble wrote:
>>>>> On Sun, 9 Oct 2022 12:57:05 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 10/9/2022 12:51 PM, Mr Flibble wrote:
>>>>>>> On Sun, 9 Oct 2022 12:48:55 -0500
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 10/9/2022 12:30 PM, Mr Flibble wrote:
>>>>>>>>> On Sun, 9 Oct 2022 12:22:57 -0500
>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 10/9/2022 12:18 PM, Mr Flibble wrote:
>>>>>>>>>>> On Sun, 9 Oct 2022 12:14:39 -0500
>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On Sun, 9 Oct 2022 12:00:46 -0500
>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
>>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
>>>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Once one accepts the notion of a simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider that continues to correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate its input until it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines that the this simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running then the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> conventional halting problem proofs are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> refuted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate
>>>>>>>>>>>>>>>>>>>>>>>>>>> until it CORRECT decides that the ACTUAL
>>>>>>>>>>>>>>>>>>>>>>>>>>> input will never halts, but stops when a
>>>>>>>>>>>>>>>>>>>>>>>>>>> DIFFERENT input is shown to not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition
>>>>>>>>>>>>>>>>>>>>>>>>>> that is set up because it is easier to defeat
>>>>>>>>>>>>>>>>>>>>>>>>>> than an opponent's real argument.
>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception try again using the exact
>>>>>>>>>>>>>>>>>>>>>>>>>> words that I actually said.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Which isn't what I did, so you are just shown
>>>>>>>>>>>>>>>>>>>>>>>>> to be a LIAR.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> // P does the opposite of whatever H decides
>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // if H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>> reports that its input halts HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>> // P loops and never halts return;
>>>>>>>>>>>>>>>>>>>>>>>> // else P halts }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You are asserting that the simulation of P by H
>>>>>>>>>>>>>>>>>>>>>>>> would eventually stop running on its own
>>>>>>>>>>>>>>>>>>>>>>>> without being aborted by H?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, THAT is the strawman.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I am asserting that the CORRECT simulation of P
>>>>>>>>>>>>>>>>>>>>>>> would eventually reach a final state,
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *You changed the words again*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are asserting that the simulation
>>>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>>>> would eventually stop running on its own without
>>>>>>>>>>>>>>>>>>>>>> being aborted by H?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, that's YOUR strawman.
>>>>>>>>>>>>>>>>>>>> If you knew anything about logic you would
>>>>>>>>>>>>>>>>>>>> understand that this is a premise: *Once one
>>>>>>>>>>>>>>>>>>>> accepts the notion of a simulating halt decider*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> One is not allowed to reject the premise. One is
>>>>>>>>>>>>>>>>>>>> only allowed to verify that the conclusion follows
>>>>>>>>>>>>>>>>>>>> from the premise.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> SHD can only refute halting problem proofs if it is
>>>>>>>>>>>>>>>>>>> a pure function;
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes, it took me three full time months to convert H
>>>>>>>>>>>>>>>>>> into a pure function. I merely apply the exact same
>>>>>>>>>>>>>>>>>> infinite recursion criteria that is used to compute
>>>>>>>>>>>>>>>>>> the halt status of:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void Infinite_Recursion(u32 N)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yet I apply this criteria immediately before
>>>>>>>>>>>>>>>>>> recursive simulation actually occurs. When H
>>>>>>>>>>>>>>>>>> recognizes that P is about to call H in recursive
>>>>>>>>>>>>>>>>>> simulation H aborts its simulation of P before its
>>>>>>>>>>>>>>>>>> first call to H is ever invoked.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If your H is a pure function and H(P,P) returns 0 then
>>>>>>>>>>>>>>>>> H(P,P) called from P(P) would also return 0
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> <sarcasm>
>>>>>>>>>>>>>>>> Sure because everyone knows that a function that is
>>>>>>>>>>>>>>>> never invoked must still return a value in the same
>>>>>>>>>>>>>>>> way we must be able to start the engine of a car that
>>>>>>>>>>>>>>>> has no engine. </sarcasm>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H(P,P) called from P(P) is the FIRST invocation of
>>>>>>>>>>>>>>> H(P,P) so is invoked, i.e. main() calling P(P) instead
>>>>>>>>>>>>>>> of H(P,P).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Your H is not a halt decider as it gets the halting
>>>>>>>>>>>>>>> decision wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Turing computable functions are not allowed to compute
>>>>>>>>>>>>>> the mapping of non-inputs or anything that cannot be
>>>>>>>>>>>>>> encoded as a finite string. That you fail to understand
>>>>>>>>>>>>>> this is not any rebuttal of what I have said.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If H is a pure function and H(P,P) returns 0 then if P(P)
>>>>>>>>>>>>> is called from main() P(P) will halt which means H got the
>>>>>>>>>>>>> halting decision wrong meaning H is not a halt decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You continue to fail to understand that Turing computable
>>>>>>>>>>>> functions are not allowed to consider the behavior of
>>>>>>>>>>>> non-inputs. That you fail to understand this is not any
>>>>>>>>>>>> error on my part.
>>>>>>>>>>>
>>>>>>>>>>> English is ambiguous, lets try code instead:
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>> P(P);
>>>>>>>>>>> Output("P(P) halted ergo H(P, P) should have returned
>>>>>>>>>>> 1"); }
>>>>>>>>>>>
>>>>>>>>>>> Given the above it is obvious to all that H is not a halt
>>>>>>>>>>> decider.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The correct simulation of the input to H(P,P) by H is known
>>>>>>>>>> to be the behavior that H must measure on the basis that the
>>>>>>>>>> correct simulation of a machine description is known to
>>>>>>>>>> provide the actual behavior of this machine description.
>>>>>>>>>>
>>>>>>>>>> What you are saying rejects the notion of a UTM.
>>>>>>>>>
>>>>>>>>> What I am saying is that programs are designed to be run
>>>>>>>>> rather than just analyzed by a halt decider.
>>>>>>>>>
>>>>>>>>> P(P) halts does it not? i.e. the following PROGRAM halts:
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> P(P);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> You claim that H is a pure function and that H(P,P) returns 0
>>>>>>>>> ergo your H gets the halting decision wrong so is not a halt
>>>>>>>>> decider.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> H1(P,P) specifies a different sequence of configurations than
>>>>>>>> H(P,P) thus the value that H1 returns can vary from what H(P,P)
>>>>>>>> returns.
>>>>>>>>
>>>>>>>> When one simply assumes that pathological self-reference has no
>>>>>>>> effect on a sequence of configurations one is proven to be
>>>>>>>> incorrect.
>>>>>>>
>>>>>>> P(P) is still calling H not this mysterious H1 you have just
>>>>>>> invented. Your H gets the halting decision wrong so is not a
>>>>>>> halt decider.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>> H1(P,P) reports on the behavior of int main() { P(P); }
>>>>>> H(P,P) is not allowed to report on the behavior of int main() {
>>>>>> P(P); }
>>>>>>
>>>>>
>>>>> Given:
>>>>>
>>>>> int main()
>>>>> {
>>>>> H(P,P);
>>>>> }
>>>>>
>>>>> H(P,P) is NOT deciding on main() but on P(P) so why would there
>>>>> be a mysterious H1 deciding on main()?
>>>>>
>>>>
>>>> There is no mystery, H1 is an exact copy of H, yet does not have
>>>> the pathological self-reference relationship with P. H1 is
>>>> included in this project.
>>>>
>>>> Complete halt deciding system (Visual Studio Project)
>>>> (a) x86utm operating system
>>>> (b) x86 emulator adapted from libx86emu to compile under Windows
>>>> (c) Several halt deciders and their sample inputs contained within
>>>> Halt7.c https://liarparadox.org/2022_09_07.zip
>>>
>>> If H1 is an exact copy of H and H is a pure function then:
>>>
>>> int main()
>>> {
>>> H1(P,P); // returns 1
>>> H(P,P); // returns 0
>>> }
>>>
>>> This contradiction is proof that do do not have a working halt
>>> decider and that you have not refuted the halting problem proofs.
>>>
>>> /Flibble
>>>
>>
>> It can be easily verified that the correctly simulated behavior that
>> H1 sees is different behavior than the correctly simulated behavior
>> that H sees because of the pathological self-reference relationship
>> between H and P.
>>
>> A function must always return the same value for the same inputs.
>> Different functions can return different values for the same inputs.
>> Add(2,3) returns a different value than Multiply(2,3).
>
> If H1 is an exact copy of H and H is a pure function then H1 should
> return the same result for the same input as H;
P calls H and P does not call H1 this changes the behavior of P relative
to H and H1. H recognizes that its correct simulation of P would never
stop running unless H aborts this simulation.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-10-09 19:44 +0100 |
| Message-ID | <20221009194440.00004480@reddwarf.jmc.corp> |
| In reply to | #58298 |
On Sun, 9 Oct 2022 13:40:56 -0500
olcott <none-ya@beez-waxes.com> wrote:
> On 10/9/2022 1:31 PM, Mr Flibble wrote:
> > On Sun, 9 Oct 2022 13:28:07 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 10/9/2022 1:23 PM, Mr Flibble wrote:
> >>> On Sun, 9 Oct 2022 13:10:51 -0500
> >>> olcott <none-ya@beez-waxes.com> wrote:
> >>>
> >>>> On 10/9/2022 1:07 PM, Mr Flibble wrote:
> >>>>> On Sun, 9 Oct 2022 12:57:05 -0500
> >>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>
> >>>>>> On 10/9/2022 12:51 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 9 Oct 2022 12:48:55 -0500
> >>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>
> >>>>>>>> On 10/9/2022 12:30 PM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 9 Oct 2022 12:22:57 -0500
> >>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 10/9/2022 12:18 PM, Mr Flibble wrote:
> >>>>>>>>>>> On Sun, 9 Oct 2022 12:14:39 -0500
> >>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Sun, 9 Oct 2022 12:00:46 -0500
> >>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
> >>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
> >>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
> >>>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Once one accepts the notion of a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider that continues
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> to correctly simulate its input until it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determines that the this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input would never stop running
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> then the conventional halting problem
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> proofs are refuted.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate
> >>>>>>>>>>>>>>>>>>>>>>>>>>> until it CORRECT decides that the ACTUAL
> >>>>>>>>>>>>>>>>>>>>>>>>>>> input will never halts, but stops when a
> >>>>>>>>>>>>>>>>>>>>>>>>>>> DIFFERENT input is shown to not halt.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> *straw man*
> >>>>>>>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition
> >>>>>>>>>>>>>>>>>>>>>>>>>> that is set up because it is easier to
> >>>>>>>>>>>>>>>>>>>>>>>>>> defeat than an opponent's real argument.
> >>>>>>>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception try again using the
> >>>>>>>>>>>>>>>>>>>>>>>>>> exact words that I actually said.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Which isn't what I did, so you are just
> >>>>>>>>>>>>>>>>>>>>>>>>> shown to be a LIAR.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> // P does the opposite of whatever H decides
> >>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // if H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>> reports that its input halts HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>> // P loops and never halts return;
> >>>>>>>>>>>>>>>>>>>>>>>> // else P halts }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P,
> >>>>>>>>>>>>>>>>>>>>>>>> P)); }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> You are asserting that the simulation of P
> >>>>>>>>>>>>>>>>>>>>>>>> by H would eventually stop running on its own
> >>>>>>>>>>>>>>>>>>>>>>>> without being aborted by H?
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> No, THAT is the strawman.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> I am asserting that the CORRECT simulation of
> >>>>>>>>>>>>>>>>>>>>>>> P would eventually reach a final state,
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> *You changed the words again*
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> You are asserting that the simulation
> >>>>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>>>> would eventually stop running on its own
> >>>>>>>>>>>>>>>>>>>>>> without being aborted by H?
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> No, that's YOUR strawman.
> >>>>>>>>>>>>>>>>>>>> If you knew anything about logic you would
> >>>>>>>>>>>>>>>>>>>> understand that this is a premise: *Once one
> >>>>>>>>>>>>>>>>>>>> accepts the notion of a simulating halt decider*
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> One is not allowed to reject the premise. One is
> >>>>>>>>>>>>>>>>>>>> only allowed to verify that the conclusion
> >>>>>>>>>>>>>>>>>>>> follows from the premise.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> SHD can only refute halting problem proofs if it
> >>>>>>>>>>>>>>>>>>> is a pure function;
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Yes, it took me three full time months to convert H
> >>>>>>>>>>>>>>>>>> into a pure function. I merely apply the exact same
> >>>>>>>>>>>>>>>>>> infinite recursion criteria that is used to compute
> >>>>>>>>>>>>>>>>>> the halt status of:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> void Infinite_Recursion(u32 N)
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> Infinite_Recursion(N);
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Yet I apply this criteria immediately before
> >>>>>>>>>>>>>>>>>> recursive simulation actually occurs. When H
> >>>>>>>>>>>>>>>>>> recognizes that P is about to call H in recursive
> >>>>>>>>>>>>>>>>>> simulation H aborts its simulation of P before its
> >>>>>>>>>>>>>>>>>> first call to H is ever invoked.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> If your H is a pure function and H(P,P) returns 0
> >>>>>>>>>>>>>>>>> then H(P,P) called from P(P) would also return 0
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> <sarcasm>
> >>>>>>>>>>>>>>>> Sure because everyone knows that a function that is
> >>>>>>>>>>>>>>>> never invoked must still return a value in the same
> >>>>>>>>>>>>>>>> way we must be able to start the engine of a car that
> >>>>>>>>>>>>>>>> has no engine. </sarcasm>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> H(P,P) called from P(P) is the FIRST invocation of
> >>>>>>>>>>>>>>> H(P,P) so is invoked, i.e. main() calling P(P) instead
> >>>>>>>>>>>>>>> of H(P,P).
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Your H is not a halt decider as it gets the halting
> >>>>>>>>>>>>>>> decision wrong.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Turing computable functions are not allowed to compute
> >>>>>>>>>>>>>> the mapping of non-inputs or anything that cannot be
> >>>>>>>>>>>>>> encoded as a finite string. That you fail to understand
> >>>>>>>>>>>>>> this is not any rebuttal of what I have said.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If H is a pure function and H(P,P) returns 0 then if
> >>>>>>>>>>>>> P(P) is called from main() P(P) will halt which means H
> >>>>>>>>>>>>> got the halting decision wrong meaning H is not a halt
> >>>>>>>>>>>>> decider.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> You continue to fail to understand that Turing computable
> >>>>>>>>>>>> functions are not allowed to consider the behavior of
> >>>>>>>>>>>> non-inputs. That you fail to understand this is not any
> >>>>>>>>>>>> error on my part.
> >>>>>>>>>>>
> >>>>>>>>>>> English is ambiguous, lets try code instead:
> >>>>>>>>>>>
> >>>>>>>>>>> int main()
> >>>>>>>>>>> {
> >>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>> P(P);
> >>>>>>>>>>> Output("P(P) halted ergo H(P, P) should have
> >>>>>>>>>>> returned 1"); }
> >>>>>>>>>>>
> >>>>>>>>>>> Given the above it is obvious to all that H is not a halt
> >>>>>>>>>>> decider.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> The correct simulation of the input to H(P,P) by H is known
> >>>>>>>>>> to be the behavior that H must measure on the basis that
> >>>>>>>>>> the correct simulation of a machine description is known to
> >>>>>>>>>> provide the actual behavior of this machine description.
> >>>>>>>>>>
> >>>>>>>>>> What you are saying rejects the notion of a UTM.
> >>>>>>>>>
> >>>>>>>>> What I am saying is that programs are designed to be run
> >>>>>>>>> rather than just analyzed by a halt decider.
> >>>>>>>>>
> >>>>>>>>> P(P) halts does it not? i.e. the following PROGRAM halts:
> >>>>>>>>>
> >>>>>>>>> int main()
> >>>>>>>>> {
> >>>>>>>>> P(P);
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> You claim that H is a pure function and that H(P,P) returns
> >>>>>>>>> 0 ergo your H gets the halting decision wrong so is not a
> >>>>>>>>> halt decider.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> H1(P,P) specifies a different sequence of configurations than
> >>>>>>>> H(P,P) thus the value that H1 returns can vary from what
> >>>>>>>> H(P,P) returns.
> >>>>>>>>
> >>>>>>>> When one simply assumes that pathological self-reference has
> >>>>>>>> no effect on a sequence of configurations one is proven to be
> >>>>>>>> incorrect.
> >>>>>>>
> >>>>>>> P(P) is still calling H not this mysterious H1 you have just
> >>>>>>> invented. Your H gets the halting decision wrong so is not a
> >>>>>>> halt decider.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>> H1(P,P) reports on the behavior of int main() { P(P); }
> >>>>>> H(P,P) is not allowed to report on the behavior of int main() {
> >>>>>> P(P); }
> >>>>>>
> >>>>>
> >>>>> Given:
> >>>>>
> >>>>> int main()
> >>>>> {
> >>>>> H(P,P);
> >>>>> }
> >>>>>
> >>>>> H(P,P) is NOT deciding on main() but on P(P) so why would there
> >>>>> be a mysterious H1 deciding on main()?
> >>>>>
> >>>>
> >>>> There is no mystery, H1 is an exact copy of H, yet does not have
> >>>> the pathological self-reference relationship with P. H1 is
> >>>> included in this project.
> >>>>
> >>>> Complete halt deciding system (Visual Studio Project)
> >>>> (a) x86utm operating system
> >>>> (b) x86 emulator adapted from libx86emu to compile under Windows
> >>>> (c) Several halt deciders and their sample inputs contained
> >>>> within Halt7.c https://liarparadox.org/2022_09_07.zip
> >>>
> >>> If H1 is an exact copy of H and H is a pure function then:
> >>>
> >>> int main()
> >>> {
> >>> H1(P,P); // returns 1
> >>> H(P,P); // returns 0
> >>> }
> >>>
> >>> This contradiction is proof that do do not have a working halt
> >>> decider and that you have not refuted the halting problem proofs.
> >>>
> >>> /Flibble
> >>>
> >>
> >> It can be easily verified that the correctly simulated behavior
> >> that H1 sees is different behavior than the correctly simulated
> >> behavior that H sees because of the pathological self-reference
> >> relationship between H and P.
> >>
> >> A function must always return the same value for the same inputs.
> >> Different functions can return different values for the same
> >> inputs. Add(2,3) returns a different value than Multiply(2,3).
> >
> > If H1 is an exact copy of H and H is a pure function then H1 should
> > return the same result for the same input as H;
>
> P calls H and P does not call H1 this changes the behavior of P
> relative to H and H1. H recognizes that its correct simulation of P
> would never stop running unless H aborts this simulation.
A pure function ALWAYS returns the SAME result for the SAME arguments so
an EXACT COPY of such a pure function should behave the SAME as what it
is a copy of.
https://en.wikipedia.org/wiki/Pure_function
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-10-09 14:03 -0500 |
| Message-ID | <thv5uo$h9v6$12@dont-email.me> |
| In reply to | #58299 |
On 10/9/2022 1:44 PM, Mr Flibble wrote:
> On Sun, 9 Oct 2022 13:40:56 -0500
> olcott <none-ya@beez-waxes.com> wrote:
>
>> On 10/9/2022 1:31 PM, Mr Flibble wrote:
>>> On Sun, 9 Oct 2022 13:28:07 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 10/9/2022 1:23 PM, Mr Flibble wrote:
>>>>> On Sun, 9 Oct 2022 13:10:51 -0500
>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>
>>>>>> On 10/9/2022 1:07 PM, Mr Flibble wrote:
>>>>>>> On Sun, 9 Oct 2022 12:57:05 -0500
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 10/9/2022 12:51 PM, Mr Flibble wrote:
>>>>>>>>> On Sun, 9 Oct 2022 12:48:55 -0500
>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 10/9/2022 12:30 PM, Mr Flibble wrote:
>>>>>>>>>>> On Sun, 9 Oct 2022 12:22:57 -0500
>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 10/9/2022 12:18 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On Sun, 9 Oct 2022 12:14:39 -0500
>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 12:00:46 -0500
>>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
>>>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
>>>>>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Once one accepts the notion of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider that continues
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to correctly simulate its input until it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determines that the this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input would never stop running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then the conventional halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proofs are refuted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Except that your decider DOESN'T simulate
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> until it CORRECT decides that the ACTUAL
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input will never halts, but stops when a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DIFFERENT input is shown to not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is set up because it is easier to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> defeat than an opponent's real argument.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception try again using the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> exact words that I actually said.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Which isn't what I did, so you are just
>>>>>>>>>>>>>>>>>>>>>>>>>>> shown to be a LIAR.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> // P does the opposite of whatever H decides
>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // if H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>> reports that its input halts HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>> // P loops and never halts return;
>>>>>>>>>>>>>>>>>>>>>>>>>> // else P halts }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P,
>>>>>>>>>>>>>>>>>>>>>>>>>> P)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You are asserting that the simulation of P
>>>>>>>>>>>>>>>>>>>>>>>>>> by H would eventually stop running on its own
>>>>>>>>>>>>>>>>>>>>>>>>>> without being aborted by H?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> No, THAT is the strawman.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I am asserting that the CORRECT simulation of
>>>>>>>>>>>>>>>>>>>>>>>>> P would eventually reach a final state,
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *You changed the words again*
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You are asserting that the simulation
>>>>>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>>>>>> of P by H
>>>>>>>>>>>>>>>>>>>>>>>> would eventually stop running on its own
>>>>>>>>>>>>>>>>>>>>>>>> without being aborted by H?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, that's YOUR strawman.
>>>>>>>>>>>>>>>>>>>>>> If you knew anything about logic you would
>>>>>>>>>>>>>>>>>>>>>> understand that this is a premise: *Once one
>>>>>>>>>>>>>>>>>>>>>> accepts the notion of a simulating halt decider*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> One is not allowed to reject the premise. One is
>>>>>>>>>>>>>>>>>>>>>> only allowed to verify that the conclusion
>>>>>>>>>>>>>>>>>>>>>> follows from the premise.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> SHD can only refute halting problem proofs if it
>>>>>>>>>>>>>>>>>>>>> is a pure function;
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Yes, it took me three full time months to convert H
>>>>>>>>>>>>>>>>>>>> into a pure function. I merely apply the exact same
>>>>>>>>>>>>>>>>>>>> infinite recursion criteria that is used to compute
>>>>>>>>>>>>>>>>>>>> the halt status of:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(u32 N)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Yet I apply this criteria immediately before
>>>>>>>>>>>>>>>>>>>> recursive simulation actually occurs. When H
>>>>>>>>>>>>>>>>>>>> recognizes that P is about to call H in recursive
>>>>>>>>>>>>>>>>>>>> simulation H aborts its simulation of P before its
>>>>>>>>>>>>>>>>>>>> first call to H is ever invoked.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If your H is a pure function and H(P,P) returns 0
>>>>>>>>>>>>>>>>>>> then H(P,P) called from P(P) would also return 0
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> <sarcasm>
>>>>>>>>>>>>>>>>>> Sure because everyone knows that a function that is
>>>>>>>>>>>>>>>>>> never invoked must still return a value in the same
>>>>>>>>>>>>>>>>>> way we must be able to start the engine of a car that
>>>>>>>>>>>>>>>>>> has no engine. </sarcasm>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H(P,P) called from P(P) is the FIRST invocation of
>>>>>>>>>>>>>>>>> H(P,P) so is invoked, i.e. main() calling P(P) instead
>>>>>>>>>>>>>>>>> of H(P,P).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Your H is not a halt decider as it gets the halting
>>>>>>>>>>>>>>>>> decision wrong.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Turing computable functions are not allowed to compute
>>>>>>>>>>>>>>>> the mapping of non-inputs or anything that cannot be
>>>>>>>>>>>>>>>> encoded as a finite string. That you fail to understand
>>>>>>>>>>>>>>>> this is not any rebuttal of what I have said.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If H is a pure function and H(P,P) returns 0 then if
>>>>>>>>>>>>>>> P(P) is called from main() P(P) will halt which means H
>>>>>>>>>>>>>>> got the halting decision wrong meaning H is not a halt
>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You continue to fail to understand that Turing computable
>>>>>>>>>>>>>> functions are not allowed to consider the behavior of
>>>>>>>>>>>>>> non-inputs. That you fail to understand this is not any
>>>>>>>>>>>>>> error on my part.
>>>>>>>>>>>>>
>>>>>>>>>>>>> English is ambiguous, lets try code instead:
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>> P(P);
>>>>>>>>>>>>> Output("P(P) halted ergo H(P, P) should have
>>>>>>>>>>>>> returned 1"); }
>>>>>>>>>>>>>
>>>>>>>>>>>>> Given the above it is obvious to all that H is not a halt
>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The correct simulation of the input to H(P,P) by H is known
>>>>>>>>>>>> to be the behavior that H must measure on the basis that
>>>>>>>>>>>> the correct simulation of a machine description is known to
>>>>>>>>>>>> provide the actual behavior of this machine description.
>>>>>>>>>>>>
>>>>>>>>>>>> What you are saying rejects the notion of a UTM.
>>>>>>>>>>>
>>>>>>>>>>> What I am saying is that programs are designed to be run
>>>>>>>>>>> rather than just analyzed by a halt decider.
>>>>>>>>>>>
>>>>>>>>>>> P(P) halts does it not? i.e. the following PROGRAM halts:
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>> P(P);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> You claim that H is a pure function and that H(P,P) returns
>>>>>>>>>>> 0 ergo your H gets the halting decision wrong so is not a
>>>>>>>>>>> halt decider.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> H1(P,P) specifies a different sequence of configurations than
>>>>>>>>>> H(P,P) thus the value that H1 returns can vary from what
>>>>>>>>>> H(P,P) returns.
>>>>>>>>>>
>>>>>>>>>> When one simply assumes that pathological self-reference has
>>>>>>>>>> no effect on a sequence of configurations one is proven to be
>>>>>>>>>> incorrect.
>>>>>>>>>
>>>>>>>>> P(P) is still calling H not this mysterious H1 you have just
>>>>>>>>> invented. Your H gets the halting decision wrong so is not a
>>>>>>>>> halt decider.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>> H1(P,P) reports on the behavior of int main() { P(P); }
>>>>>>>> H(P,P) is not allowed to report on the behavior of int main() {
>>>>>>>> P(P); }
>>>>>>>>
>>>>>>>
>>>>>>> Given:
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> H(P,P);
>>>>>>> }
>>>>>>>
>>>>>>> H(P,P) is NOT deciding on main() but on P(P) so why would there
>>>>>>> be a mysterious H1 deciding on main()?
>>>>>>>
>>>>>>
>>>>>> There is no mystery, H1 is an exact copy of H, yet does not have
>>>>>> the pathological self-reference relationship with P. H1 is
>>>>>> included in this project.
>>>>>>
>>>>>> Complete halt deciding system (Visual Studio Project)
>>>>>> (a) x86utm operating system
>>>>>> (b) x86 emulator adapted from libx86emu to compile under Windows
>>>>>> (c) Several halt deciders and their sample inputs contained
>>>>>> within Halt7.c https://liarparadox.org/2022_09_07.zip
>>>>>
>>>>> If H1 is an exact copy of H and H is a pure function then:
>>>>>
>>>>> int main()
>>>>> {
>>>>> H1(P,P); // returns 1
>>>>> H(P,P); // returns 0
>>>>> }
>>>>>
>>>>> This contradiction is proof that do do not have a working halt
>>>>> decider and that you have not refuted the halting problem proofs.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> It can be easily verified that the correctly simulated behavior
>>>> that H1 sees is different behavior than the correctly simulated
>>>> behavior that H sees because of the pathological self-reference
>>>> relationship between H and P.
>>>>
>>>> A function must always return the same value for the same inputs.
>>>> Different functions can return different values for the same
>>>> inputs. Add(2,3) returns a different value than Multiply(2,3).
>>>
>>> If H1 is an exact copy of H and H is a pure function then H1 should
>>> return the same result for the same input as H;
>>
>> P calls H and P does not call H1 this changes the behavior of P
>> relative to H and H1. H recognizes that its correct simulation of P
>> would never stop running unless H aborts this simulation.
>
> A pure function ALWAYS returns the SAME result for the SAME arguments so
> an EXACT COPY of such a pure function should behave the SAME as what it
> is a copy of.
P only calls H and does not call H1.
Assuming that a pathological self-reference relationship has no effect
on the resulting sequence of configurations seems ridiculously stupid
when it can be easily empirically verified that it does have this effect.
>
> https://en.wikipedia.org/wiki/Pure_function
>
> /Flibble
>
--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-10-09 20:06 +0100 |
| Message-ID | <20221009200652.0000792d@reddwarf.jmc.corp> |
| In reply to | #58303 |
On Sun, 9 Oct 2022 14:03:50 -0500
olcott <polcott2@gmail.com> wrote:
> On 10/9/2022 1:44 PM, Mr Flibble wrote:
> > On Sun, 9 Oct 2022 13:40:56 -0500
> > olcott <none-ya@beez-waxes.com> wrote:
> >
> >> On 10/9/2022 1:31 PM, Mr Flibble wrote:
> >>> On Sun, 9 Oct 2022 13:28:07 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 10/9/2022 1:23 PM, Mr Flibble wrote:
> >>>>> On Sun, 9 Oct 2022 13:10:51 -0500
> >>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>
> >>>>>> On 10/9/2022 1:07 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 9 Oct 2022 12:57:05 -0500
> >>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>
> >>>>>>>> On 10/9/2022 12:51 PM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 9 Oct 2022 12:48:55 -0500
> >>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 10/9/2022 12:30 PM, Mr Flibble wrote:
> >>>>>>>>>>> On Sun, 9 Oct 2022 12:22:57 -0500
> >>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 10/9/2022 12:18 PM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Sun, 9 Oct 2022 12:14:39 -0500
> >>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 10/9/2022 12:10 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Sun, 9 Oct 2022 12:00:46 -0500
> >>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 10/9/2022 11:49 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 11:46:10 -0500
> >>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On 10/9/2022 11:39 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 10:48:51 -0500
> >>>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> On 10/9/2022 10:40 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>> On Sun, 9 Oct 2022 09:32:54 -0500
> >>>>>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> On 10/9/2022 6:25 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 11:31 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 10:00 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Once one accepts the notion of a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider that continues
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to correctly simulate its input until
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it correctly determines that the this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input would never stop
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running then the conventional halting
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proofs are refuted.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Except that your decider DOESN'T
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate until it CORRECT decides that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the ACTUAL input will never halts, but
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> stops when a DIFFERENT input is shown
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> to not halt.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *straw man*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> proposition that is set up because it is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> easier to defeat than an opponent's real
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> argument.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception try again using the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> exact words that I actually said.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Which isn't what I did, so you are just
> >>>>>>>>>>>>>>>>>>>>>>>>>>> shown to be a LIAR.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> // P does the opposite of whatever H
> >>>>>>>>>>>>>>>>>>>>>>>>>> decides void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status) // if
> >>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) reports that its input halts HERE:
> >>>>>>>>>>>>>>>>>>>>>>>>>> goto HERE; // P loops and never halts
> >>>>>>>>>>>>>>>>>>>>>>>>>> return; // else P halts }
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P,
> >>>>>>>>>>>>>>>>>>>>>>>>>> P)); }
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> You are asserting that the simulation of P
> >>>>>>>>>>>>>>>>>>>>>>>>>> by H would eventually stop running on its
> >>>>>>>>>>>>>>>>>>>>>>>>>> own without being aborted by H?
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> No, THAT is the strawman.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> I am asserting that the CORRECT simulation
> >>>>>>>>>>>>>>>>>>>>>>>>> of P would eventually reach a final state,
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> *You changed the words again*
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> You are asserting that the simulation
> >>>>>>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>>>>>> of P by H
> >>>>>>>>>>>>>>>>>>>>>>>> would eventually stop running on its own
> >>>>>>>>>>>>>>>>>>>>>>>> without being aborted by H?
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> No, that's YOUR strawman.
> >>>>>>>>>>>>>>>>>>>>>> If you knew anything about logic you would
> >>>>>>>>>>>>>>>>>>>>>> understand that this is a premise: *Once one
> >>>>>>>>>>>>>>>>>>>>>> accepts the notion of a simulating halt
> >>>>>>>>>>>>>>>>>>>>>> decider*
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> One is not allowed to reject the premise. One
> >>>>>>>>>>>>>>>>>>>>>> is only allowed to verify that the conclusion
> >>>>>>>>>>>>>>>>>>>>>> follows from the premise.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> SHD can only refute halting problem proofs if it
> >>>>>>>>>>>>>>>>>>>>> is a pure function;
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Yes, it took me three full time months to
> >>>>>>>>>>>>>>>>>>>> convert H into a pure function. I merely apply
> >>>>>>>>>>>>>>>>>>>> the exact same infinite recursion criteria that
> >>>>>>>>>>>>>>>>>>>> is used to compute the halt status of:
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(u32 N)
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> Infinite_Recursion(N);
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Yet I apply this criteria immediately before
> >>>>>>>>>>>>>>>>>>>> recursive simulation actually occurs. When H
> >>>>>>>>>>>>>>>>>>>> recognizes that P is about to call H in recursive
> >>>>>>>>>>>>>>>>>>>> simulation H aborts its simulation of P before
> >>>>>>>>>>>>>>>>>>>> its first call to H is ever invoked.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> If your H is a pure function and H(P,P) returns 0
> >>>>>>>>>>>>>>>>>>> then H(P,P) called from P(P) would also return 0
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> <sarcasm>
> >>>>>>>>>>>>>>>>>> Sure because everyone knows that a function that is
> >>>>>>>>>>>>>>>>>> never invoked must still return a value in the same
> >>>>>>>>>>>>>>>>>> way we must be able to start the engine of a car
> >>>>>>>>>>>>>>>>>> that has no engine. </sarcasm>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> H(P,P) called from P(P) is the FIRST invocation of
> >>>>>>>>>>>>>>>>> H(P,P) so is invoked, i.e. main() calling P(P)
> >>>>>>>>>>>>>>>>> instead of H(P,P).
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Your H is not a halt decider as it gets the halting
> >>>>>>>>>>>>>>>>> decision wrong.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Turing computable functions are not allowed to
> >>>>>>>>>>>>>>>> compute the mapping of non-inputs or anything that
> >>>>>>>>>>>>>>>> cannot be encoded as a finite string. That you fail
> >>>>>>>>>>>>>>>> to understand this is not any rebuttal of what I
> >>>>>>>>>>>>>>>> have said.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> If H is a pure function and H(P,P) returns 0 then if
> >>>>>>>>>>>>>>> P(P) is called from main() P(P) will halt which means
> >>>>>>>>>>>>>>> H got the halting decision wrong meaning H is not a
> >>>>>>>>>>>>>>> halt decider.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> You continue to fail to understand that Turing
> >>>>>>>>>>>>>> computable functions are not allowed to consider the
> >>>>>>>>>>>>>> behavior of non-inputs. That you fail to understand
> >>>>>>>>>>>>>> this is not any error on my part.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> English is ambiguous, lets try code instead:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> int main()
> >>>>>>>>>>>>> {
> >>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>> P(P);
> >>>>>>>>>>>>> Output("P(P) halted ergo H(P, P) should have
> >>>>>>>>>>>>> returned 1"); }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Given the above it is obvious to all that H is not a
> >>>>>>>>>>>>> halt decider.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> The correct simulation of the input to H(P,P) by H is
> >>>>>>>>>>>> known to be the behavior that H must measure on the
> >>>>>>>>>>>> basis that the correct simulation of a machine
> >>>>>>>>>>>> description is known to provide the actual behavior of
> >>>>>>>>>>>> this machine description.
> >>>>>>>>>>>>
> >>>>>>>>>>>> What you are saying rejects the notion of a UTM.
> >>>>>>>>>>>
> >>>>>>>>>>> What I am saying is that programs are designed to be run
> >>>>>>>>>>> rather than just analyzed by a halt decider.
> >>>>>>>>>>>
> >>>>>>>>>>> P(P) halts does it not? i.e. the following PROGRAM halts:
> >>>>>>>>>>>
> >>>>>>>>>>> int main()
> >>>>>>>>>>> {
> >>>>>>>>>>> P(P);
> >>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>> You claim that H is a pure function and that H(P,P)
> >>>>>>>>>>> returns 0 ergo your H gets the halting decision wrong so
> >>>>>>>>>>> is not a halt decider.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> H1(P,P) specifies a different sequence of configurations
> >>>>>>>>>> than H(P,P) thus the value that H1 returns can vary from
> >>>>>>>>>> what H(P,P) returns.
> >>>>>>>>>>
> >>>>>>>>>> When one simply assumes that pathological self-reference
> >>>>>>>>>> has no effect on a sequence of configurations one is
> >>>>>>>>>> proven to be incorrect.
> >>>>>>>>>
> >>>>>>>>> P(P) is still calling H not this mysterious H1 you have just
> >>>>>>>>> invented. Your H gets the halting decision wrong so is not a
> >>>>>>>>> halt decider.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>> H1(P,P) reports on the behavior of int main() { P(P); }
> >>>>>>>> H(P,P) is not allowed to report on the behavior of int
> >>>>>>>> main() { P(P); }
> >>>>>>>>
> >>>>>>>
> >>>>>>> Given:
> >>>>>>>
> >>>>>>> int main()
> >>>>>>> {
> >>>>>>> H(P,P);
> >>>>>>> }
> >>>>>>>
> >>>>>>> H(P,P) is NOT deciding on main() but on P(P) so why would
> >>>>>>> there be a mysterious H1 deciding on main()?
> >>>>>>>
> >>>>>>
> >>>>>> There is no mystery, H1 is an exact copy of H, yet does not
> >>>>>> have the pathological self-reference relationship with P. H1 is
> >>>>>> included in this project.
> >>>>>>
> >>>>>> Complete halt deciding system (Visual Studio Project)
> >>>>>> (a) x86utm operating system
> >>>>>> (b) x86 emulator adapted from libx86emu to compile under
> >>>>>> Windows (c) Several halt deciders and their sample inputs
> >>>>>> contained within Halt7.c
> >>>>>> https://liarparadox.org/2022_09_07.zip
> >>>>>
> >>>>> If H1 is an exact copy of H and H is a pure function then:
> >>>>>
> >>>>> int main()
> >>>>> {
> >>>>> H1(P,P); // returns 1
> >>>>> H(P,P); // returns 0
> >>>>> }
> >>>>>
> >>>>> This contradiction is proof that do do not have a working halt
> >>>>> decider and that you have not refuted the halting problem
> >>>>> proofs.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> It can be easily verified that the correctly simulated behavior
> >>>> that H1 sees is different behavior than the correctly simulated
> >>>> behavior that H sees because of the pathological self-reference
> >>>> relationship between H and P.
> >>>>
> >>>> A function must always return the same value for the same inputs.
> >>>> Different functions can return different values for the same
> >>>> inputs. Add(2,3) returns a different value than Multiply(2,3).
> >>>
> >>> If H1 is an exact copy of H and H is a pure function then H1
> >>> should return the same result for the same input as H;
> >>
> >> P calls H and P does not call H1 this changes the behavior of P
> >> relative to H and H1. H recognizes that its correct simulation of P
> >> would never stop running unless H aborts this simulation.
> >
> > A pure function ALWAYS returns the SAME result for the SAME
> > arguments so an EXACT COPY of such a pure function should behave
> > the SAME as what it is a copy of.
>
> P only calls H and does not call H1.
If H1 is an exact copy of H and H is a pure function then it doesn't
matter if P calls H or H1, the result should be the same. I suspect
you are lying/mistaken about either H being a pure function of H1 being
an exact copy of H.
>
> Assuming that a pathological self-reference relationship has no
> effect on the resulting sequence of configurations seems ridiculously
> stupid when it can be easily empirically verified that it does have
> this effect.
I suggest you read https://en.wikipedia.org/wiki/Pure_function
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2022-10-09 14:39 -0400 |
| Message-ID | <izE0L.759146$BKL8.375728@fx15.iad> |
| In reply to | #58271 |
On 10/9/22 10:32 AM, olcott wrote:
> On 10/9/2022 6:25 AM, Richard Damon wrote:
>> On 10/8/22 11:31 PM, olcott wrote:
>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
>>>> On 10/8/22 10:00 PM, olcott wrote:
>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 10/8/22 9:22 PM, olcott wrote:
>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
>>>>>>>>> Once one accepts the notion of a simulating halt decider that
>>>>>>>>> continues to correctly simulate its input until it correctly
>>>>>>>>> determines that the this simulated input would never stop
>>>>>>>>> running then the conventional halting problem proofs are refuted.
>>>>>>>>
>>>>>>>> Except that your decider DOESN'T simulate until it CORRECT
>>>>>>>> decides that the ACTUAL input will never halts, but stops when a
>>>>>>>> DIFFERENT input is shown to not halt.
>>>>>>>>
>>>>>>>
>>>>>>> *straw man*
>>>>>>> An intentionally misrepresented proposition that is set up
>>>>>>> because it is easier to defeat than an opponent's real argument.
>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>
>>>>>>> Strawman deception try again using the exact words that I
>>>>>>> actually said.
>>>>>>>
>>>>>>
>>>>>> Which isn't what I did, so you are just shown to be a LIAR.
>>>>>
>>>>> // P does the opposite of whatever H decides
>>>>> void P(ptr x)
>>>>> {
>>>>> int Halt_Status = H(x, x);
>>>>> if (Halt_Status) // if H(P,P) reports that its input halts
>>>>> HERE: goto HERE; // P loops and never halts
>>>>> return; // else P halts
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> Output("Input_Halts = ", H(P, P));
>>>>> }
>>>>>
>>>>> You are asserting that the simulation of P by H would eventually
>>>>> stop running on its own without being aborted by H?
>>>>>
>>>>
>>>> No, THAT is the strawman.
>>>>
>>>> I am asserting that the CORRECT simulation of P would eventually
>>>> reach a final state,
>>>
>>> *You changed the words again*
>>>
>>> You are asserting that the simulation
>>> of P by H
>>> of P by H
>>> of P by H
>>> of P by H
>>> of P by H
>>> would eventually stop running on its own without being aborted by H?
>>>
>>>
>>
>> No, that's YOUR strawman.
> If you knew anything about logic you would understand that this is a
> premise: *Once one accepts the notion of a simulating halt decider*
>
> One is not allowed to reject the premise. One is only allowed to verify
> that the conclusion follows from the premise.
>
Yes, it is *A* proposistion, just not the one you are claiming to be
solving, the "Halting Problem".
Since that is a WELL DEFINED term, its proposition doesn't change just
because you want to look at a subclass of the machines it talks about.
Thus, your statement IS BY DEFINITION a "Strawman"
Thus, by your own words above, you don't get the "reject" the OFFICAL
definition of a halt decider, one that answers about the behavior of the
independent execution of the machine its input represents.
Until you admit that your concept of a "Simulating Halt Decider" isn't
actually a type of actual Halt Decider, everything you say based on your
"altered" criteria is just a Strawman lie.
FAIL.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-10-09 13:51 -0500 |
| Message-ID | <thv56s$h9v6$11@dont-email.me> |
| In reply to | #58297 |
On 10/9/2022 1:39 PM, Richard Damon wrote:
> On 10/9/22 10:32 AM, olcott wrote:
>> On 10/9/2022 6:25 AM, Richard Damon wrote:
>>> On 10/8/22 11:31 PM, olcott wrote:
>>>> On 10/8/2022 9:44 PM, Richard Damon wrote:
>>>>> On 10/8/22 10:00 PM, olcott wrote:
>>>>>> On 10/8/2022 8:43 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 10/8/22 9:22 PM, olcott wrote:
>>>>>>>> On 10/8/2022 7:49 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 10/8/22 8:18 PM, olcott wrote:
>>>>>>>>>> Once one accepts the notion of a simulating halt decider that
>>>>>>>>>> continues to correctly simulate its input until it correctly
>>>>>>>>>> determines that the this simulated input would never stop
>>>>>>>>>> running then the conventional halting problem proofs are refuted.
>>>>>>>>>
>>>>>>>>> Except that your decider DOESN'T simulate until it CORRECT
>>>>>>>>> decides that the ACTUAL input will never halts, but stops when
>>>>>>>>> a DIFFERENT input is shown to not halt.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *straw man*
>>>>>>>> An intentionally misrepresented proposition that is set up
>>>>>>>> because it is easier to defeat than an opponent's real argument.
>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>
>>>>>>>> Strawman deception try again using the exact words that I
>>>>>>>> actually said.
>>>>>>>>
>>>>>>>
>>>>>>> Which isn't what I did, so you are just shown to be a LIAR.
>>>>>>
>>>>>> // P does the opposite of whatever H decides
>>>>>> void P(ptr x)
>>>>>> {
>>>>>> int Halt_Status = H(x, x);
>>>>>> if (Halt_Status) // if H(P,P) reports that its input halts
>>>>>> HERE: goto HERE; // P loops and never halts
>>>>>> return; // else P halts
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>> }
>>>>>>
>>>>>> You are asserting that the simulation of P by H would eventually
>>>>>> stop running on its own without being aborted by H?
>>>>>>
>>>>>
>>>>> No, THAT is the strawman.
>>>>>
>>>>> I am asserting that the CORRECT simulation of P would eventually
>>>>> reach a final state,
>>>>
>>>> *You changed the words again*
>>>>
>>>> You are asserting that the simulation
>>>> of P by H
>>>> of P by H
>>>> of P by H
>>>> of P by H
>>>> of P by H
>>>> would eventually stop running on its own without being aborted by H?
>>>>
>>>>
>>>
>>> No, that's YOUR strawman.
>> If you knew anything about logic you would understand that this is a
>> premise: *Once one accepts the notion of a simulating halt decider*
>>
>> One is not allowed to reject the premise. One is only allowed to
>> verify that the conclusion follows from the premise.
>>
>
> Yes, it is *A* proposistion, just not the one you are claiming to be
> solving, the "Halting Problem".
>
*No it is not merely a proposition it is a syllogism*
(1) A simulating halt decider H correctly simulates its input P
(2) until H correctly determines that the this simulated input P would
never stop running unless aborted.
∴ H can abort this simulation of P and report that this correctly
simulated P specifies a not halting sequence of configurations.
--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
Page 2 of 4 — ← Prev page 1 [2] 3 4 Next page →
Back to top | Article view | comp.theory
csiph-web