Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.theory > #23988 > unrolled thread

The key aspects of x86utm are now finally complete (Refuting the HP proofs)

Started byolcott <NoOne@NoWhere.com>
First post2020-10-19 12:45 -0500
Last post2020-11-27 21:51 -0500
Articles 20 on this page of 97 — 14 participants

Back to article view | Back to comp.theory


Contents

  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 →


#23988 — The key aspects of x86utm are now finally complete (Refuting the HP proofs)

Fromolcott <NoOne@NoWhere.com>
Date2020-10-19 12:45 -0500
SubjectThe 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]


#23991

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-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]


#23994

Fromolcott <NoOne@NoWhere.com>
Date2020-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]


#24002

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-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]


#24005

Fromolcott <NoOne@NoWhere.com>
Date2020-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]


#24008

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-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]


#24010

Fromolcott <NoOne@NoWhere.com>
Date2020-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]


#24015

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-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]


#24019

Fromolcott <NoOne@NoWhere.com>
Date2020-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]


#24024

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-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]


#24028

FromRichard Damon <Richard@Damon-Family.org>
Date2020-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]


#24030

Fromolcott <NoOne@NoWhere.com>
Date2020-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]


#24033

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-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]


#24039

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2020-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]


#24040

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-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]


#24038

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-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]


#24042 — Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)[ KEY ]

Fromolcott <NoOne@NoWhere.com>
Date2020-10-20 11:07 -0500
SubjectRe: 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]


#24007

FromEli the Bearded <*@eli.users.panix.com>
Date2020-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]


#24011

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-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]


#24012

FromEli the Bearded <*@eli.users.panix.com>
Date2020-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