Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #23988 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2020-10-19 12:45 -0500 |
| Last post | 2020-11-27 21:51 -0500 |
| Articles | 20 on this page of 97 — 14 participants |
Back to article view | Back to comp.theory
The key aspects of x86utm are now finally complete (Refuting the HP proofs) olcott <NoOne@NoWhere.com> - 2020-10-19 12:45 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-19 20:04 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) olcott <NoOne@NoWhere.com> - 2020-10-19 14:15 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-19 21:34 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) olcott <NoOne@NoWhere.com> - 2020-10-19 15:50 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-19 22:09 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) olcott <NoOne@NoWhere.com> - 2020-10-19 16:28 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-19 23:13 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) olcott <NoOne@NoWhere.com> - 2020-10-19 17:54 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-20 00:41 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Richard Damon <Richard@Damon-Family.org> - 2020-10-19 21:15 -0400
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) olcott <NoOne@NoWhere.com> - 2020-10-19 20:18 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-20 02:38 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-10-20 04:35 -0700
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-20 13:27 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-20 11:31 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)[ KEY ] olcott <NoOne@NoWhere.com> - 2020-10-20 11:07 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Eli the Bearded <*@eli.users.panix.com> - 2020-10-19 21:04 +0000
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-19 22:46 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Eli the Bearded <*@eli.users.panix.com> - 2020-10-19 21:52 +0000
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-10-19 23:48 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) olcott <NoOne@NoWhere.com> - 2020-10-19 18:03 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Jeff Barnett <jbb@notatt.com> - 2020-10-19 21:26 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-19 14:54 -0700
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-19 14:57 -0700
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) R Kym Horsell <kym@kymhorsell.com> - 2020-10-19 22:17 +0000
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-19 16:25 -0700
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) R Kym Horsell <kym@kymhorsell.com> - 2020-10-19 23:29 +0000
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) David Kleinecke <dkleinecke@gmail.com> - 2020-10-19 18:19 -0700
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-19 18:26 -0700
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-19 16:34 -0700
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) R Kym Horsell <kym@kymhorsell.com> - 2020-10-20 00:08 +0000
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Richard Damon <Richard@Damon-Family.org> - 2020-10-19 21:12 -0400
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-10-21 20:23 -0700
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-19 20:39 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) olcott <NoOne@NoWhere.com> - 2020-10-19 14:54 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-19 21:49 +0100
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(39 days of review and no mistakes found) olcott <NoOne@NoWhere.com> - 2020-11-27 10:52 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(39 days of review and no mistakes found) Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-11-27 16:57 +0000
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) olcott <NoOne@NoWhere.com> - 2020-11-27 11:10 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-11-27 17:24 +0000
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) olcott <NoOne@NoWhere.com> - 2020-11-27 11:54 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) Richard Damon <Richard@Damon-Family.org> - 2020-11-27 13:24 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-27 19:08 +0000
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) olcott <NoOne@NoWhere.com> - 2020-11-27 13:34 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) olcott <NoOne@NoWhere.com> - 2020-11-27 14:04 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-27 21:04 +0000
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) olcott <NoOne@NoWhere.com> - 2020-11-27 15:24 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-28 03:29 +0000
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(keys to understanding) olcott <NoOne@NoWhere.com> - 2020-11-27 21:57 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(keys to understanding) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-30 01:42 +0000
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(keys to understanding) olcott <NoOne@NoWhere.com> - 2020-11-29 20:40 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(keys to understanding) Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-11-30 17:25 +0000
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(keys to understanding) olcott <NoOne@NoWhere.com> - 2020-11-30 11:55 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(keys to understanding) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-11-30 21:06 +0000
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-11-30 15:14 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-11-30 22:48 +0000
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-11-30 17:23 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-11-30 23:54 +0000
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-11-30 18:08 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-11-30 18:18 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-11-30 18:59 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-01 01:40 +0000
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-11-30 19:48 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-01 08:41 +0000
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-12-01 04:00 -0800
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-12-01 09:13 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-01 17:32 +0000
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-12-01 12:12 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-01 18:35 +0000
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-12-01 12:54 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-12-01 08:52 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-01 21:30 +0000
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-12-01 15:49 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-01 22:22 +0000
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-12-01 16:34 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-01 23:10 +0000
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) Richard Damon <Richard@Damon-Family.org> - 2020-12-01 21:51 -0500
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) Andy Walker <anw@cuboid.co.uk> - 2020-12-01 15:22 +0000
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-12-01 09:33 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-01 18:14 +0000
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-12-01 12:37 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-12-01 12:56 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-12-01 10:08 -0600
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-01 01:23 +0000
Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-11-30 19:30 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) Richard Damon <Richard@Damon-Family.org> - 2020-11-27 13:03 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) olcott <NoOne@NoWhere.com> - 2020-11-27 12:46 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) Richard Damon <Richard@Damon-Family.org> - 2020-11-27 16:28 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) olcott <NoOne@NoWhere.com> - 2020-11-27 15:40 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) olcott <NoOne@NoWhere.com> - 2020-11-27 15:52 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) Richard Damon <Richard@Damon-Family.org> - 2020-11-27 17:17 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) olcott <NoOne@NoWhere.com> - 2020-11-27 17:20 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) Richard Damon <Richard@Damon-Family.org> - 2020-11-27 21:27 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) Richard Damon <Richard@Damon-Family.org> - 2020-11-27 17:09 -0500
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) olcott <NoOne@NoWhere.com> - 2020-11-27 17:09 -0600
Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting ) Richard Damon <Richard@Damon-Family.org> - 2020-11-27 21:51 -0500
Page 1 of 5 [1] 2 3 4 5 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-19 12:45 -0500 |
| Subject | The key aspects of x86utm are now finally complete (Refuting the HP proofs) |
| Message-ID | <b7ydnfw7a_chTRDCnZ2dnUU7-SPNnZ2d@giganews.com> |
x86utm is a universal Turing Machine having the x86 language as machine description language. It can directly execute the COFF object file output of the Microsoft "C" compiler as long as the code does not invoke any external libraries. All global data must be initialized or it does not exist in the COFF object file. All relocatable refernces are patched to point to their file offsets. This was the most difficult aspect of the entire x86utm system: The operating system function DebugStep() can now invoke itself recursively to an arbitrary depth. It can DebugStep() itself DebugStep()ing itself... DebugStep()ing another function with an arbitrary hierarchy of DebugStep()ing in-between. The halt decider aborts the execution of its target function and reports not halting behavior as soon as it detects that its target function would not otherwise halt. Without a DebugStep() function its examination of the Target code wold be insufficiently granular. The code that correctly decides the conventional self-referential halting problem counter-examples can now finally be written. This code utterly depended upon the now finally completed DebugStep() operating system function. This code exploits a key undiscovered aspect that is common to all the conventional self-referential halting problem counter-examples. This key undiscovered aspect that makes all of the conventional self-referential halting problem counter-examples decidable cannot simply be dismissed out-of-hand without review when a fully operational program shows that it does correctly decide elements of the set of of conventional self-referential halting problem counter-examples. -- Copyright 2020 Pete Olcott
[toc] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-10-19 20:04 +0100 |
| Message-ID | <XqCdnTezsvS6fhDCnZ2dnUU78KnNnZ2d@brightview.co.uk> |
| In reply to | #23988 |
On 19/10/2020 18:45, olcott wrote:
> x86utm is a universal Turing Machine having the x86 language as machine
> description language. It can directly execute the COFF object file
> output of the Microsoft "C" compiler as long as the code does not invoke
> any external libraries. All global data must be initialized or it does
> not exist in the COFF object file. All relocatable refernces are patched
> to point to their file offsets.
>
> This was the most difficult aspect of the entire x86utm system:
> The operating system function DebugStep() can now invoke itself
> recursively to an arbitrary depth.
>
> It can DebugStep() itself DebugStep()ing itself...
> DebugStep()ing another function with an arbitrary hierarchy of
> DebugStep()ing in-between.
>
> The halt decider aborts the execution of its target function and reports
> not halting behavior as soon as it detects that its target function
> would not otherwise halt. Without a DebugStep() function its examination
> of the Target code wold be insufficiently granular.
>
> The code that correctly decides the conventional self-referential
> halting problem counter-examples can now finally be written. This code
> utterly depended upon the now finally completed DebugStep() operating
> system function.
>
> This code exploits a key undiscovered aspect that is common to all the
> conventional self-referential halting problem counter-examples.
And what is this key undiscovered aspect?
>
> This key undiscovered aspect that makes all of the conventional
> self-referential halting problem counter-examples decidable cannot
> simply be dismissed out-of-hand without review when a fully operational
> program shows that it does correctly decide elements of the set of of
> conventional self-referential halting problem counter-examples.
Well, nobody is going to give serious thought to your claim just based
on the output from some program you've written. At some point, you will
need to:
a) Explain exactly what this undiscovered aspect is, and how
it relates to the Linz HP proof.
b) Explain exactly which step is wrong in the Linz HP proof,
and why.
That is the main delivery people will look at, and fairly quickly make a
judgement on. After all, the HP proof is simple enough, that people
looking at your claim are going see quickly whether (a) and (b) warrant
any more detailed examination. If your explanation for (a) and (b) is
invalid for some reason, there's no need for poring over lengthy traces!
Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-19 14:15 -0500 |
| Message-ID | <zJWdnYnMCtYmeBDCnZ2dnUU7-dnNnZ2d@giganews.com> |
| In reply to | #23991 |
On 10/19/2020 2:04 PM, Mike Terry wrote: > On 19/10/2020 18:45, olcott wrote: >> x86utm is a universal Turing Machine having the x86 language as machine >> description language. It can directly execute the COFF object file >> output of the Microsoft "C" compiler as long as the code does not invoke >> any external libraries. All global data must be initialized or it does >> not exist in the COFF object file. All relocatable refernces are patched >> to point to their file offsets. >> >> This was the most difficult aspect of the entire x86utm system: >> The operating system function DebugStep() can now invoke itself >> recursively to an arbitrary depth. >> >> It can DebugStep() itself DebugStep()ing itself... >> DebugStep()ing another function with an arbitrary hierarchy of >> DebugStep()ing in-between. >> >> The halt decider aborts the execution of its target function and reports >> not halting behavior as soon as it detects that its target function >> would not otherwise halt. Without a DebugStep() function its examination >> of the Target code wold be insufficiently granular. >> >> The code that correctly decides the conventional self-referential >> halting problem counter-examples can now finally be written. This code >> utterly depended upon the now finally completed DebugStep() operating >> system function. >> >> This code exploits a key undiscovered aspect that is common to all the >> conventional self-referential halting problem counter-examples. > > And what is this key undiscovered aspect? > >> >> This key undiscovered aspect that makes all of the conventional >> self-referential halting problem counter-examples decidable cannot >> simply be dismissed out-of-hand without review when a fully operational >> program shows that it does correctly decide elements of the set of of >> conventional self-referential halting problem counter-examples. > > Well, nobody is going to give serious thought to your claim just based > on the output from some program you've written. At some point, you will > need to: > > a) Explain exactly what this undiscovered aspect is, and how > it relates to the Linz HP proof. > I have already done that to a very great extent and it continued to be utterly dismissed out-of-hand without any review what-so-ever. > b) Explain exactly which step is wrong in the Linz HP proof, > and why. > > That is the main delivery people will look at, and fairly quickly make a > judgement on. After all, the HP proof is simple enough, that people > looking at your claim are going see quickly whether (a) and (b) warrant > any more detailed examination. If your explanation for (a) and (b) is > invalid for some reason, there's no need for poring over lengthy traces! > > > Mike. Without a fully operational computer program that 100% totally implements the idea dishonest people will weasel out of acknowledging anything about it. It is like a smash a cream pie directly in someones face and they continue to insist that there is no such things as cream pies. -- Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-10-19 21:34 +0100 |
| Message-ID | <oLWdnZQ3yYHTZRDCnZ2dnUU78UnNnZ2d@brightview.co.uk> |
| In reply to | #23994 |
On 19/10/2020 20:15, olcott wrote: > On 10/19/2020 2:04 PM, Mike Terry wrote: >> On 19/10/2020 18:45, olcott wrote: >>> x86utm is a universal Turing Machine having the x86 language as machine >>> description language. It can directly execute the COFF object file >>> output of the Microsoft "C" compiler as long as the code does not invoke >>> any external libraries. All global data must be initialized or it does >>> not exist in the COFF object file. All relocatable refernces are patched >>> to point to their file offsets. >>> >>> This was the most difficult aspect of the entire x86utm system: >>> The operating system function DebugStep() can now invoke itself >>> recursively to an arbitrary depth. >>> >>> It can DebugStep() itself DebugStep()ing itself... >>> DebugStep()ing another function with an arbitrary hierarchy of >>> DebugStep()ing in-between. >>> >>> The halt decider aborts the execution of its target function and reports >>> not halting behavior as soon as it detects that its target function >>> would not otherwise halt. Without a DebugStep() function its examination >>> of the Target code wold be insufficiently granular. >>> >>> The code that correctly decides the conventional self-referential >>> halting problem counter-examples can now finally be written. This code >>> utterly depended upon the now finally completed DebugStep() operating >>> system function. >>> >>> This code exploits a key undiscovered aspect that is common to all the >>> conventional self-referential halting problem counter-examples. >> >> And what is this key undiscovered aspect? >> >>> >>> This key undiscovered aspect that makes all of the conventional >>> self-referential halting problem counter-examples decidable cannot >>> simply be dismissed out-of-hand without review when a fully operational >>> program shows that it does correctly decide elements of the set of of >>> conventional self-referential halting problem counter-examples. >> >> Well, nobody is going to give serious thought to your claim just based >> on the output from some program you've written. At some point, you >> will need to: >> >> a) Explain exactly what this undiscovered aspect is, and how >> it relates to the Linz HP proof. >> > > I have already done that to a very great extent and it continued to be > utterly dismissed out-of-hand without any review what-so-ever. To my recollection, you have carefully avoided giving /any/ details of what's in your partial decider, or its high level design, or e.g. what the claimed "incorrect assumptions" in my PO-HP-check-list questions from 2018 were, or anything really. When asked you refuse, saying it might give the game away and let someone else steal your glory! If I've missed some big reveal, perhaps you could provide a link to this? > >> b) Explain exactly which step is wrong in the Linz HP proof, >> and why. >> >> That is the main delivery people will look at, and fairly quickly make >> a judgement on. After all, the HP proof is simple enough, that people >> looking at your claim are going see quickly whether (a) and (b) >> warrant any more detailed examination. If your explanation for (a) >> and (b) is invalid for some reason, there's no need for poring over >> lengthy traces! >> >> >> Mike. > > Without a fully operational computer program that 100% totally > implements the idea dishonest people will weasel out of acknowledging > anything about it. It is like a smash a cream pie directly in someones > face and they continue to insist that there is no such things as cream > pies. The problem here is that you're not planning on delivering any cream pies! A proper "cream pie" would be an example *TM* (according to the *Linz* definition of a TM) H, correctly deciding the halting for (H^,H^) also in the Linz sense (i.e. with properly tape encoded TMs as they are actually used in the proof you are trying to refute). Every step you take away from this, like not producing an actual TM but instead moving to some different model of computing, or by introducing opaque "OS calls" for emulation, or not using a tape for input/output/workstatee etc., makes it harder for you to prove that what you finally deliver really is relevant to the original Linz TM-based proof. I think you should have stuck with your original goal of delivering an *actual TM* H, assuming that ever was your goal. Yeah, it would have been much more work for you to produce, but you pretty much totally side step the need for all the "weasely" claims about why it's relevant to proofs about actual TMs... Maybe there is a TM compiler available somewhere that can generate TMs from some higher level language, reducing the work you would have had to perform? Anyway, too late for that now I guess... Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-19 15:50 -0500 |
| Message-ID | <HMudncUlXIuKYRDCnZ2dnUU7-KPNnZ2d@giganews.com> |
| In reply to | #24002 |
On 10/19/2020 3:34 PM, Mike Terry wrote: > On 19/10/2020 20:15, olcott wrote: >> On 10/19/2020 2:04 PM, Mike Terry wrote: >>> On 19/10/2020 18:45, olcott wrote: >>>> x86utm is a universal Turing Machine having the x86 language as machine >>>> description language. It can directly execute the COFF object file >>>> output of the Microsoft "C" compiler as long as the code does not >>>> invoke >>>> any external libraries. All global data must be initialized or it does >>>> not exist in the COFF object file. All relocatable refernces are >>>> patched >>>> to point to their file offsets. >>>> >>>> This was the most difficult aspect of the entire x86utm system: >>>> The operating system function DebugStep() can now invoke itself >>>> recursively to an arbitrary depth. >>>> >>>> It can DebugStep() itself DebugStep()ing itself... >>>> DebugStep()ing another function with an arbitrary hierarchy of >>>> DebugStep()ing in-between. >>>> >>>> The halt decider aborts the execution of its target function and >>>> reports >>>> not halting behavior as soon as it detects that its target function >>>> would not otherwise halt. Without a DebugStep() function its >>>> examination >>>> of the Target code wold be insufficiently granular. >>>> >>>> The code that correctly decides the conventional self-referential >>>> halting problem counter-examples can now finally be written. This code >>>> utterly depended upon the now finally completed DebugStep() operating >>>> system function. >>>> >>>> This code exploits a key undiscovered aspect that is common to all the >>>> conventional self-referential halting problem counter-examples. >>> >>> And what is this key undiscovered aspect? >>> >>>> >>>> This key undiscovered aspect that makes all of the conventional >>>> self-referential halting problem counter-examples decidable cannot >>>> simply be dismissed out-of-hand without review when a fully operational >>>> program shows that it does correctly decide elements of the set of of >>>> conventional self-referential halting problem counter-examples. >>> >>> Well, nobody is going to give serious thought to your claim just based >>> on the output from some program you've written. At some point, you >>> will need to: >>> >>> a) Explain exactly what this undiscovered aspect is, and how >>> it relates to the Linz HP proof. >>> >> >> I have already done that to a very great extent and it continued to be >> utterly dismissed out-of-hand without any review what-so-ever. > > To my recollection, you have carefully avoided giving /any/ details of > what's in your partial decider, or its high level design, or e.g. what > the claimed "incorrect assumptions" in my PO-HP-check-list questions > from 2018 were, or anything really. When asked you refuse, saying it > might give the game away and let someone else steal your glory! > > If I've missed some big reveal, perhaps you could provide a link to this? > >> >>> b) Explain exactly which step is wrong in the Linz HP proof, >>> and why. >>> >>> That is the main delivery people will look at, and fairly quickly make >>> a judgement on. After all, the HP proof is simple enough, that people >>> looking at your claim are going see quickly whether (a) and (b) >>> warrant any more detailed examination. If your explanation for (a) >>> and (b) is invalid for some reason, there's no need for poring over >>> lengthy traces! >>> >>> >>> Mike. >> >> Without a fully operational computer program that 100% totally >> implements the idea dishonest people will weasel out of acknowledging >> anything about it. It is like a smash a cream pie directly in someones >> face and they continue to insist that there is no such things as cream >> pies. > > The problem here is that you're not planning on delivering any cream > pies! A proper "cream pie" would be an example *TM* (according to the > *Linz* definition of a TM) Sure all that I have to do is email everyone a piece of computer hardware that has literally infinite RAM. > H, correctly deciding the halting for (H^,H^) > also in the Linz sense (i.e. with properly tape encoded TMs as they are > actually used in the proof you are trying to refute). > > Every step you take away from this, like not producing an actual TM but > instead moving to some different model of computing, or by introducing > opaque "OS calls" for emulation, or not using a tape for > input/output/workstatee etc., makes it harder for you to prove that what > you finally deliver really is relevant to the original Linz TM-based proof. > > I think you should have stuck with your original goal of delivering an > *actual TM* H, assuming that ever was your goal. Yeah, it would have > been much more work for you to produce, but you pretty much totally side > step the need for all the "weasely" claims about why it's relevant to > proofs about actual TMs... Maybe there is a TM compiler available > somewhere that can generate TMs from some higher level language, > reducing the work you would have had to perform? Anyway, too late for > that now I guess... > > Mike. > -- Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-10-19 22:09 +0100 |
| Message-ID | <oNidnRtfAOvynRPCnZ2dnUU78WnNnZ2d@brightview.co.uk> |
| In reply to | #24005 |
On 19/10/2020 21:50, olcott wrote:
> On 10/19/2020 3:34 PM, Mike Terry wrote:
>> On 19/10/2020 20:15, olcott wrote:
[snip]
>>>
>>> Without a fully operational computer program that 100% totally
>>> implements the idea dishonest people will weasel out of acknowledging
>>> anything about it. It is like a smash a cream pie directly in someones
>>> face and they continue to insist that there is no such things as cream
>>> pies.
>>
>> The problem here is that you're not planning on delivering any cream
>> pies! A proper "cream pie" would be an example *TM* (according to the
>> *Linz* definition of a TM)
>
> Sure all that I have to do is email everyone a piece of computer
> hardware that has literally infinite RAM.
1. A TM is not a piece of computer hardware
2. A TM is a finite data structure.
(And TM descriptions as appearing in the Linz proof are finite.)
>
>> H, correctly deciding the halting for (H^,H^) also in the Linz sense
>> (i.e. with properly tape encoded TMs as they are actually used in the
>> proof you are trying to refute).
>>
>> Every step you take away from this, like not producing an actual TM
>> but instead moving to some different model of computing, or by
>> introducing opaque "OS calls" for emulation, or not using a tape for
>> input/output/workstatee etc., makes it harder for you to prove that
>> what you finally deliver really is relevant to the original Linz
>> TM-based proof.
>>
>> I think you should have stuck with your original goal of delivering an
>> *actual TM* H, assuming that ever was your goal. Yeah, it would have
>> been much more work for you to produce, but you pretty much totally
>> side step the need for all the "weasely" claims about why it's
>> relevant to proofs about actual TMs... Maybe there is a TM compiler
>> available somewhere that can generate TMs from some higher level
>> language, reducing the work you would have had to perform? Anyway,
>> too late for that now I guess...
>>
>> Mike.
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-19 16:28 -0500 |
| Message-ID | <2vmdnV_LQYxjmRPCnZ2dnUU7-dednZ2d@giganews.com> |
| In reply to | #24008 |
On 10/19/2020 4:09 PM, Mike Terry wrote: > On 19/10/2020 21:50, olcott wrote: >> On 10/19/2020 3:34 PM, Mike Terry wrote: >>> On 19/10/2020 20:15, olcott wrote: > [snip] >>>> >>>> Without a fully operational computer program that 100% totally >>>> implements the idea dishonest people will weasel out of acknowledging >>>> anything about it. It is like a smash a cream pie directly in someones >>>> face and they continue to insist that there is no such things as cream >>>> pies. >>> >>> The problem here is that you're not planning on delivering any cream >>> pies! A proper "cream pie" would be an example *TM* (according to the >>> *Linz* definition of a TM) >> >> Sure all that I have to do is email everyone a piece of computer >> hardware that has literally infinite RAM. > > 1. A TM is not a piece of computer hardware > 2. A TM is a finite data structure. > (And TM descriptions as appearing in the Linz proof are finite.) Then any machine that is equivalent to a machine that is equivalent to a TM will do. The x86 language is equivalent to the RASP architecture and the RASP architecture has proven to be UTM equivalent. >> >>> H, correctly deciding the halting for (H^,H^) also in the Linz sense >>> (i.e. with properly tape encoded TMs as they are actually used in the >>> proof you are trying to refute). >>> >>> Every step you take away from this, like not producing an actual TM >>> but instead moving to some different model of computing, or by >>> introducing opaque "OS calls" for emulation, or not using a tape for >>> input/output/workstatee etc., makes it harder for you to prove that >>> what you finally deliver really is relevant to the original Linz >>> TM-based proof. >>> >>> I think you should have stuck with your original goal of delivering an >>> *actual TM* H, assuming that ever was your goal. Yeah, it would have >>> been much more work for you to produce, but you pretty much totally >>> side step the need for all the "weasely" claims about why it's >>> relevant to proofs about actual TMs... Maybe there is a TM compiler >>> available somewhere that can generate TMs from some higher level >>> language, reducing the work you would have had to perform? Anyway, >>> too late for that now I guess... >>> >>> Mike. >>> >> >> -- Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-10-19 23:13 +0100 |
| Message-ID | <K_WdnZUxiogWkhPCnZ2dnUU78U_NnZ2d@brightview.co.uk> |
| In reply to | #24010 |
On 19/10/2020 22:28, olcott wrote: > On 10/19/2020 4:09 PM, Mike Terry wrote: >> On 19/10/2020 21:50, olcott wrote: >>> On 10/19/2020 3:34 PM, Mike Terry wrote: >>>> On 19/10/2020 20:15, olcott wrote: >> [snip] >>>>> >>>>> Without a fully operational computer program that 100% totally >>>>> implements the idea dishonest people will weasel out of acknowledging >>>>> anything about it. It is like a smash a cream pie directly in someones >>>>> face and they continue to insist that there is no such things as cream >>>>> pies. >>>> >>>> The problem here is that you're not planning on delivering any cream >>>> pies! A proper "cream pie" would be an example *TM* (according to the >>>> *Linz* definition of a TM) >>> >>> Sure all that I have to do is email everyone a piece of computer >>> hardware that has literally infinite RAM. >> >> 1. A TM is not a piece of computer hardware >> 2. A TM is a finite data structure. >> (And TM descriptions as appearing in the Linz proof are finite.) > > Then any machine that is equivalent to a machine that is equivalent to a > TM will do. The x86 language is equivalent to the RASP architecture and > the RASP architecture has proven to be UTM equivalent. > No, it is not that simple I'm afraid. The Linz argument is specifically talking about TMs. If you want to move the argument to some other "equivalent" model of computing, then you also need to reassess the Linz argument and translate the concepts involved (input tape, TM encodings, machine states, the definition of H^ in terms of H) to and from the new computing model. While there are proofs that work along these lines, I'm afraid you wouldn't even understand what you would need to do here. That's why below I refer to "weasel" claims on your part concerning "equivalence" - that's all they are, weasel claims to avoid really thinking about the issue. Just say some weasel words and repeat them a thousand times, so the problem goes away. Mike. >>> >>>> H, correctly deciding the halting for (H^,H^) also in the Linz sense >>>> (i.e. with properly tape encoded TMs as they are actually used in the >>>> proof you are trying to refute). >>>> >>>> Every step you take away from this, like not producing an actual TM >>>> but instead moving to some different model of computing, or by >>>> introducing opaque "OS calls" for emulation, or not using a tape for >>>> input/output/workstatee etc., makes it harder for you to prove that >>>> what you finally deliver really is relevant to the original Linz >>>> TM-based proof. >>>> >>>> I think you should have stuck with your original goal of delivering an >>>> *actual TM* H, assuming that ever was your goal. Yeah, it would have >>>> been much more work for you to produce, but you pretty much totally >>>> side step the need for all the "weasely" claims about why it's >>>> relevant to proofs about actual TMs... Maybe there is a TM compiler >>>> available somewhere that can generate TMs from some higher level >>>> language, reducing the work you would have had to perform? Anyway, >>>> too late for that now I guess... >>>> >>>> Mike. >>>> >>> >>> > >
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-19 17:54 -0500 |
| Message-ID | <0bednXBQQ6HchBPCnZ2dnUU7-enNnZ2d@giganews.com> |
| In reply to | #24015 |
On 10/19/2020 5:13 PM, Mike Terry wrote: > On 19/10/2020 22:28, olcott wrote: >> On 10/19/2020 4:09 PM, Mike Terry wrote: >>> On 19/10/2020 21:50, olcott wrote: >>>> On 10/19/2020 3:34 PM, Mike Terry wrote: >>>>> On 19/10/2020 20:15, olcott wrote: >>> [snip] >>>>>> >>>>>> Without a fully operational computer program that 100% totally >>>>>> implements the idea dishonest people will weasel out of acknowledging >>>>>> anything about it. It is like a smash a cream pie directly in >>>>>> someones >>>>>> face and they continue to insist that there is no such things as >>>>>> cream >>>>>> pies. >>>>> >>>>> The problem here is that you're not planning on delivering any cream >>>>> pies! A proper "cream pie" would be an example *TM* (according to the >>>>> *Linz* definition of a TM) >>>> >>>> Sure all that I have to do is email everyone a piece of computer >>>> hardware that has literally infinite RAM. >>> >>> 1. A TM is not a piece of computer hardware >>> 2. A TM is a finite data structure. >>> (And TM descriptions as appearing in the Linz proof are finite.) >> >> Then any machine that is equivalent to a machine that is equivalent to a >> TM will do. The x86 language is equivalent to the RASP architecture and >> the RASP architecture has proven to be UTM equivalent. >> > > No, it is not that simple I'm afraid. > > The Linz argument is specifically talking about TMs. If you want to > move the argument to some other "equivalent" model of computing, then > you also need to reassess the Linz argument and translate the concepts > involved (input tape, TM encodings, machine states, the definition of H^ > in terms of H) to and from the new computing model. I have taken care of all that. The key aspect that cannot be adequately explained without a fully operational example is the details of how H() and H_Hat() are executed in their own separate process as virtual machines such that they have complete control over their subordinate "program under test" processes. H() continues to DebugStep() though H_Hat() until H_Hat() terminates or H() decides that H_Hat() would not otherwise terminate. In this case H() would stop executing H_Hat() and report Not_Halting behavior. The reason that I not published my code yet it that it took me about 1500 hours to adapt a very well written x86 emulator to become a UTM operating system capable of executing other UTMs in DebugStep() mode. > While there are proofs that work along these lines, I'm afraid you > wouldn't even understand what you would need to do here. That's why > below I refer to "weasel" claims on your part concerning "equivalence" - > that's all they are, weasel claims to avoid really thinking about the > issue. Just say some weasel words and repeat them a thousand times, so > the problem goes away. > > Mike. > >>>> >>>>> H, correctly deciding the halting for (H^,H^) also in the Linz sense >>>>> (i.e. with properly tape encoded TMs as they are actually used in the >>>>> proof you are trying to refute). >>>>> >>>>> Every step you take away from this, like not producing an actual TM >>>>> but instead moving to some different model of computing, or by >>>>> introducing opaque "OS calls" for emulation, or not using a tape for >>>>> input/output/workstatee etc., makes it harder for you to prove that >>>>> what you finally deliver really is relevant to the original Linz >>>>> TM-based proof. >>>>> >>>>> I think you should have stuck with your original goal of delivering an >>>>> *actual TM* H, assuming that ever was your goal. Yeah, it would have >>>>> been much more work for you to produce, but you pretty much totally >>>>> side step the need for all the "weasely" claims about why it's >>>>> relevant to proofs about actual TMs... Maybe there is a TM compiler >>>>> available somewhere that can generate TMs from some higher level >>>>> language, reducing the work you would have had to perform? Anyway, >>>>> too late for that now I guess... >>>>> >>>>> Mike. >>>>> >>>> >>>> >> >> -- Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-10-20 00:41 +0100 |
| Message-ID | <87eelthjgu.fsf@bsb.me.uk> |
| In reply to | #24019 |
olcott <NoOne@NoWhere.com> writes: > ... The key aspect that cannot be > adequately explained without a fully operational example is the > details of how H() and H_Hat() are executed in their own separate > process as virtual machines such that they have complete control over > their subordinate "program under test" processes. > > H() continues to DebugStep() though H_Hat() until H_Hat() terminates > or H() decides that H_Hat() would not otherwise terminate. In this > case H() would stop executing H_Hat() and report Not_Halting behavior. What a surprise. I really thought you'd string it out a bit longer, and I never thought you'd be so clear about what you've done wrong. But all credit where it's due: you're honesty in this instance it admirable. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-10-19 21:15 -0400 |
| Message-ID | <xSqjH.365239$CM.119214@fx01.iad> |
| In reply to | #24019 |
On 10/19/20 6:54 PM, olcott wrote: > > H() continues to DebugStep() though H_Hat() until H_Hat() terminates or > H() decides that H_Hat() would not otherwise terminate. In this case H() > would stop executing H_Hat() and report Not_Halting behavior. And if H() is reporting Not_Halting, why didn't H_Hat halt, per its definition?
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-19 20:18 -0500 |
| Message-ID | <N-SdnZzKgsF9pxPCnZ2dnUU7-e2dnZ2d@giganews.com> |
| In reply to | #24028 |
On 10/19/2020 8:15 PM, Richard Damon wrote: > On 10/19/20 6:54 PM, olcott wrote: >> >> H() continues to DebugStep() though H_Hat() until H_Hat() terminates or >> H() decides that H_Hat() would not otherwise terminate. In this case H() >> would stop executing H_Hat() and report Not_Halting behavior. > > And if H() is reporting Not_Halting, why didn't H_Hat halt, per its > definition? > Answers to these questions will be provided by my fully operational software as soon as it is completed. -- Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-10-20 02:38 +0100 |
| Message-ID | <87zh4hfzi4.fsf@bsb.me.uk> |
| In reply to | #24028 |
Richard Damon <Richard@Damon-Family.org> writes: > On 10/19/20 6:54 PM, olcott wrote: >> >> H() continues to DebugStep() though H_Hat() until H_Hat() terminates or >> H() decides that H_Hat() would not otherwise terminate. In this case H() >> would stop executing H_Hat() and report Not_Halting behavior. > > And if H() is reporting Not_Halting, why didn't H_Hat halt, per its > definition? Stunning, that after two years of obfuscation, he has simply admitted that he's broken the H/H^ relationship. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2020-10-20 04:35 -0700 |
| Message-ID | <84c0dc80-0137-4f60-8f04-6c255fb4f915n@googlegroups.com> |
| In reply to | #24033 |
On Tuesday, 20 October 2020 at 02:38:22 UTC+1, Ben Bacarisse wrote: > Richard Damon <Ric...@Damon-Family.org> writes: > > > On 10/19/20 6:54 PM, olcott wrote: > >> > >> H() continues to DebugStep() though H_Hat() until H_Hat() terminates or > >> H() decides that H_Hat() would not otherwise terminate. In this case H() > >> would stop executing H_Hat() and report Not_Halting behavior. > > > > And if H() is reporting Not_Halting, why didn't H_Hat halt, per its > > definition? > > Stunning, that after two years of obfuscation, he has simply admitted > that he's broken the H/H^ relationship. > He has admitted no such thing. He's about to produce the rabbit. You're like the obnoxious smart kid at the back of the audience calling out the trick before it is done. Of course we adults know that there must a hole in the H_Hat which leads to the DebugStep, under which cowers the rabbit. But let him post his stuff, and see if anyone can spot what is wrong.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-10-20 13:27 +0100 |
| Message-ID | <87o8kxf5fe.fsf@bsb.me.uk> |
| In reply to | #24039 |
Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: > On Tuesday, 20 October 2020 at 02:38:22 UTC+1, Ben Bacarisse wrote: >> Richard Damon <Ric...@Damon-Family.org> writes: >> >> > On 10/19/20 6:54 PM, olcott wrote: >> >> >> >> H() continues to DebugStep() though H_Hat() until H_Hat() terminates or >> >> H() decides that H_Hat() would not otherwise terminate. In this case H() >> >> would stop executing H_Hat() and report Not_Halting behavior. >> > >> > And if H() is reporting Not_Halting, why didn't H_Hat halt, per its >> > definition? >> >> Stunning, that after two years of obfuscation, he has simply admitted >> that he's broken the H/H^ relationship. >> > He has admitted no such thing. It's right there -- the description of the computations involving H and H_Hat are given in that paragraph, and they are wrong. H_Hat is not doing what Linz defines it to do. > He's about to produce the rabbit. He's meant to be showing the empty hat to the audience, but the rabbit is right there, sitting at the bottom of it. > You're like the obnoxious smart kid at the back of the audience calling out > the trick before it is done. I'm the obnoxious one in this exchange for pointing to the rabbit sitting there for all to see? How is that spoiling the trick? (If you want to see what obnoxious Usenet posts really look like go look and see what PO has called me over the years.) PO had already spoiled the trick. He's walked back the original wondrous claim to this paltry affair. > Of course we adults know that there must a hole > in the H_Hat which leads to the DebugStep, under which cowers the rabbit. > > But let him post his stuff, and see if anyone can spot what is wrong. He's already told us. (Of course, PO is bad enough at technical writing that it is possible he has incorrectly described his own code, but let's take his word for it for now.) You seem to think there is some subtlety here -- some ingenious device that might be fun to unmask. That can only be because you've not been following the whole story. He is not performing some trick, he's just trying to bury a mistake. Two years ago, in the middle of a manic episode, possibly brought on by the trauma of his dog's death, he made the mistake of making a clear and simple claim. About three days later, he realised that he had to find some way to avoid ever having to post what he had said he had. If you had been following for those two years, you would have seen the multitude of excuses for not posting it, along with a parallel set of posts rowing back on what he claimed to have. He has finally settled on some ridiculous pile of x86 code, in the hope that everyone will forget the clear and unambiguous claim he made two years ago. Wouldn't you rather see the actual Turing machine pair, with H^ constructed exactly as in Linz's book, that he had fully encoded back in Dec 2018? Would that not be the better trick? If so, join me in asking for it, rather than eagerly awaiting the obviously erroneous pile of junk x86 code we might one day be permitted to see. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-10-20 11:31 +0100 |
| Message-ID | <joWdndKimNT5IRPCnZ2dnUU78e_NnZ2d@brightview.co.uk> |
| In reply to | #24019 |
On 19/10/2020 23:54, olcott wrote: > On 10/19/2020 5:13 PM, Mike Terry wrote: >> On 19/10/2020 22:28, olcott wrote: >>> On 10/19/2020 4:09 PM, Mike Terry wrote: >>>> On 19/10/2020 21:50, olcott wrote: >>>>> On 10/19/2020 3:34 PM, Mike Terry wrote: >>>>>> On 19/10/2020 20:15, olcott wrote: >>>> [snip] >>>>>>> >>>>>>> Without a fully operational computer program that 100% totally >>>>>>> implements the idea dishonest people will weasel out of >>>>>>> acknowledging >>>>>>> anything about it. It is like a smash a cream pie directly in >>>>>>> someones >>>>>>> face and they continue to insist that there is no such things as >>>>>>> cream >>>>>>> pies. >>>>>> >>>>>> The problem here is that you're not planning on delivering any cream >>>>>> pies! A proper "cream pie" would be an example *TM* (according to >>>>>> the >>>>>> *Linz* definition of a TM) >>>>> >>>>> Sure all that I have to do is email everyone a piece of computer >>>>> hardware that has literally infinite RAM. >>>> >>>> 1. A TM is not a piece of computer hardware >>>> 2. A TM is a finite data structure. >>>> (And TM descriptions as appearing in the Linz proof are finite.) >>> >>> Then any machine that is equivalent to a machine that is equivalent to a >>> TM will do. The x86 language is equivalent to the RASP architecture and >>> the RASP architecture has proven to be UTM equivalent. >>> >> >> No, it is not that simple I'm afraid. >> >> The Linz argument is specifically talking about TMs. If you want to >> move the argument to some other "equivalent" model of computing, then >> you also need to reassess the Linz argument and translate the concepts >> involved (input tape, TM encodings, machine states, the definition of >> H^ in terms of H) to and from the new computing model. > > I have taken care of all that. The key aspect that cannot be adequately > explained without a fully operational example is the details of how H() > and H_Hat() are executed in their own separate process as virtual > machines such that they have complete control over their subordinate > "program under test" processes. All that I've seen is your mutterings about "Turing equivalent calculations", which does not begin to "take care of" the issues. Perhaps you have more, which you're planning to publish in your 5 page paper I think you mentioned once. We'll wait and see, I guess. Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-20 11:07 -0500 |
| Subject | Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)[ KEY ] |
| Message-ID | <tbydnQCtRLHelhLCnZ2dnUU7-YPNnZ2d@giganews.com> |
| In reply to | #24038 |
On 10/20/2020 5:31 AM, Mike Terry wrote:
> On 19/10/2020 23:54, olcott wrote:
>> On 10/19/2020 5:13 PM, Mike Terry wrote:
>>> On 19/10/2020 22:28, olcott wrote:
>>>> On 10/19/2020 4:09 PM, Mike Terry wrote:
>>>>> On 19/10/2020 21:50, olcott wrote:
>>>>>> On 10/19/2020 3:34 PM, Mike Terry wrote:
>>>>>>> On 19/10/2020 20:15, olcott wrote:
>>>>> [snip]
>>>>>>>>
>>>>>>>> Without a fully operational computer program that 100% totally
>>>>>>>> implements the idea dishonest people will weasel out of
>>>>>>>> acknowledging
>>>>>>>> anything about it. It is like a smash a cream pie directly in
>>>>>>>> someones
>>>>>>>> face and they continue to insist that there is no such things as
>>>>>>>> cream
>>>>>>>> pies.
>>>>>>>
>>>>>>> The problem here is that you're not planning on delivering any cream
>>>>>>> pies! A proper "cream pie" would be an example *TM* (according to
>>>>>>> the
>>>>>>> *Linz* definition of a TM)
>>>>>>
>>>>>> Sure all that I have to do is email everyone a piece of computer
>>>>>> hardware that has literally infinite RAM.
>>>>>
>>>>> 1. A TM is not a piece of computer hardware
>>>>> 2. A TM is a finite data structure.
>>>>> (And TM descriptions as appearing in the Linz proof are finite.)
>>>>
>>>> Then any machine that is equivalent to a machine that is equivalent
>>>> to a
>>>> TM will do. The x86 language is equivalent to the RASP architecture and
>>>> the RASP architecture has proven to be UTM equivalent.
>>>>
>>>
>>> No, it is not that simple I'm afraid.
>>>
>>> The Linz argument is specifically talking about TMs. If you want to
>>> move the argument to some other "equivalent" model of computing, then
>>> you also need to reassess the Linz argument and translate the concepts
>>> involved (input tape, TM encodings, machine states, the definition of
>>> H^ in terms of H) to and from the new computing model.
>>
>> I have taken care of all that. The key aspect that cannot be adequately
>> explained without a fully operational example is the details of how H()
>> and H_Hat() are executed in their own separate process as virtual
>> machines such that they have complete control over their subordinate
>> "program under test" processes.
>
> All that I've seen is your mutterings about "Turing equivalent
> calculations", which does not begin to "take care of" the issues.
> Perhaps you have more, which you're planning to publish in your
> 5 page paper I think you mentioned once. We'll wait and see, I guess.
>
> Mike.
H() executes H_Hat() as if H() was a UTM.
H() and H_Hat() are separate processes having their own
{Memory, registers and stack}
To make things simple the halt deciding aspect of H() and H_Hat() is the
same function.
#define HALT __asm hlt
// N has address of H_Hat()
int H(u32 M, u32 N)
{
int Abort = DebugTrace(M, N);
if (Abort)
{
MOV_EAX_0
HALT
}
else
{
MOV_EAX_1
HALT
}
}
int main()
{
u32 M = (unsigned int)H_Hat;
H(M, M);
HALT;
}
--
Copyright 2020 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | Eli the Bearded <*@eli.users.panix.com> |
|---|---|
| Date | 2020-10-19 21:04 +0000 |
| Message-ID | <eli$2010191645@qaz.wtf> |
| In reply to | #24002 |
In comp.lang.c, Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote: > To my recollection, you have carefully avoided giving /any/ details of > what's in your partial decider, or its high level design, or e.g. what > the claimed "incorrect assumptions" in my PO-HP-check-list questions > from 2018 were, or anything really. When asked you refuse, saying it > might give the game away and let someone else steal your glory! This is informative, but a little less generalized than it should be: http://web.mst.edu/%7Elmhall/WhatToDoWhenTrisectorComes.pdf Elijah ------ the decades roll by but the problems remain basically the same
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-10-19 22:46 +0100 |
| Message-ID | <dImdnfSs7p27lBPCnZ2dnUU78UvNnZ2d@brightview.co.uk> |
| In reply to | #24007 |
On 19/10/2020 22:04, Eli the Bearded wrote: > In comp.lang.c, > Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote: >> To my recollection, you have carefully avoided giving /any/ details of >> what's in your partial decider, or its high level design, or e.g. what >> the claimed "incorrect assumptions" in my PO-HP-check-list questions >> from 2018 were, or anything really. When asked you refuse, saying it >> might give the game away and let someone else steal your glory! > > This is informative, but a little less generalized than it should be: > > http://web.mst.edu/%7Elmhall/WhatToDoWhenTrisectorComes.pdf > > Elijah > ------ > the decades roll by but the problems remain basically the same > Yes, that's a nice article which I've read before. He even mentions the fear of having their glory stolen, and consequent copy-righting common for trisectors. :) The final advice on what actually to do when the trisector comes seems a little naf to me though - and not applicable so much to these newsgroups. The joy of the article is in his descriptions of the individuals and his interactions with them over the years. Mike.
[toc] | [prev] | [next] | [standalone]
| From | Eli the Bearded <*@eli.users.panix.com> |
|---|---|
| Date | 2020-10-19 21:52 +0000 |
| Message-ID | <eli$2010191752@qaz.wtf> |
| In reply to | #24011 |
In comp.lang.c, Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote: > On 19/10/2020 22:04, Eli the Bearded wrote: >> This is informative, but a little less generalized than it should be: >> http://web.mst.edu/%7Elmhall/WhatToDoWhenTrisectorComes.pdf > Yes, that's a nice article which I've read before. He even mentions the > fear of having their glory stolen, and consequent copy-righting common > for trisectors. :) The final advice on what actually to do when the > trisector comes seems a little naf to me though - and not applicable so > much to these newsgroups. The joy of the article is in his descriptions > of the individuals and his interactions with them over the years. The final paragraph advice to be so harsh in criticism that they never come back seems like the only advice that might work. Or perhaps ignoring the cranks. Elijah ------ usually goes for "don't engage" or "mock"
[toc] | [prev] | [next] | [standalone]
Page 1 of 5 [1] 2 3 4 5 Next page →
Back to top | Article view | comp.theory
csiph-web