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 17 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 5 of 5 — ← Prev page 1 2 3 4 [5]


#26273 — Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-01 18:14 +0000
SubjectRe: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face)
Message-ID<20201201093303.286@kylheku.com>
In reply to#26268
On 2020-12-01, olcott <NoOne@NoWhere.com> wrote:
> void H_Hat(u32 P)

This program has issues.

> {
>    u32 Aborted = DebugTrace(P, P);

The assumption is that DebugTrace always terminates, in
one of two ways.  If it returns nonzero, it means that the termination
was forced by the simulator, otherwise zero means that P(P)
spontaneously halted.

The nonzero case can be a false positive, arising from
DebugTrace simply not having run P(P) long enough for it to
terminate.

The essence of the halting problem is that the decider runs into
situations in which it itself does not terminate and those are
the big problem.

You essentially are begging the question: you're *assuming* that your
halting decider will always terminate, and therefore arguing that the
proofs are wrong because your decider terminates.

>    if (Aborted)
>      HALT
>    else
>      HERE: goto HERE;
> }
>
>
> int main()
> {
>    DebugTrace((u32)H_Hat, (u32)H_Hat);
>    HALT;

Since DebugTrace always terminates, we always reach HALT.

Well, what is the meaning of that? This program is supposed to report
whether something halted or not; where is it doing that?

Why are we ignoring the return value of DebugTrace here?

It seems that we can substitute any arguments whatsoever in the
DebugTrace call and the program reports the same termination status; how
is that a decider?

The above are all serious flaws in your work.

[toc] | [prev] | [next] | [standalone]


#26275 — Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-01 12:37 -0600
SubjectRe: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face)
Message-ID<-9GdnSvNpfDnEFvCnZ2dnUU7-KnNnZ2d@giganews.com>
In reply to#26273
On 12/1/2020 12:14 PM, Kaz Kylheku wrote:
> On 2020-12-01, olcott <NoOne@NoWhere.com> wrote:
>> void H_Hat(u32 P)
> 
> This program has issues.
> 
>> {
>>     u32 Aborted = DebugTrace(P, P);
> 
> The assumption is that DebugTrace always terminates, in
> one of two ways.  If it returns nonzero, it means that the termination
> was forced by the simulator, otherwise zero means that P(P)
> spontaneously halted.
> 
> The nonzero case can be a false positive, arising from
> DebugTrace simply not having run P(P) long enough for it to
> terminate.
> 
> The essence of the halting problem is that the decider runs into
> situations in which it itself does not terminate and those are
> the big problem.
> 
> You essentially are begging the question: you're *assuming* that your
> halting decider will always terminate, and therefore arguing that the
> proofs are wrong because your decider terminates.
> 
>>     if (Aborted)
>>       HALT
>>     else
>>       HERE: goto HERE;
>> }
>>
>>
>> int main()
>> {
>>     DebugTrace((u32)H_Hat, (u32)H_Hat);
>>     HALT;
> 
> Since DebugTrace always terminates, we always reach HALT.
> 
> Well, what is the meaning of that? This program is supposed to report
> whether something halted or not; where is it doing that?
> 
> Why are we ignoring the return value of DebugTrace here?
> 
> It seems that we can substitute any arguments whatsoever in the
> DebugTrace call and the program reports the same termination status; how
> is that a decider?
> 
> The above are all serious flaws in your work.
> 

Currently the halt decider is implemented at the operating system level 
so that it correctly decides these non halting cases:

int main()
{

HERE: goto HERE;
   OutputString("Hello World!");
   HALT;
}

Output_Debug_Trace() [00010be8]  size(12)  capacity(65536)
[000005c4](01)  55                  push ebp
[000005c5](02)  8bec                mov ebp,esp
[000005c7](02)  ebfe                jmp 000005c7   	---- JMP [000005c7]
[000005c7](02)  ebfe                jmp 000005c7   	---- JMP [000005c7]
The PRIOR Instruction Specifies an Infinite Loop: Simulation Stopped:


HERE: goto HERE;
   H_Hat((u32)H_Hat);
   HALT;
}

Output_Debug_Trace() [00010bc4]  size(76)  capacity(65536)
[000005b4](01)  55                  push ebp
[000005b5](02)  8bec                mov ebp,esp
[000005b7](05)  6884050000          push 00000584
[000005bc](05)  e8c3ffffff          call 00000584   	----CALL [00000584]
[00000584](01)  55                  push ebp
[00000585](02)  8bec                mov ebp,esp
[00000587](01)  51                  push ecx
[00000588](03)  8b4508              mov eax,[ebp+08]
[0000058b](01)  50                  push eax
[0000058c](03)  8b4d08              mov ecx,[ebp+08]
[0000058f](01)  51                  push ecx
[00000590](05)  e8bffdffff          call 00000354   	----CALL [00000354]
[00000584](01)  55                  push ebp
[00000585](02)  8bec                mov ebp,esp
[00000587](01)  51                  push ecx
[00000588](03)  8b4508              mov eax,[ebp+08]
[0000058b](01)  50                  push eax
[0000058c](03)  8b4d08              mov ecx,[ebp+08]
[0000058f](01)  51                  push ecx
[00000590](05)  e8bffdffff          call 00000354   	----CALL [00000354]
The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:


-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#26277 — Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-01 12:56 -0600
SubjectRe: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face)
Message-ID<4eednafjve54DFvCnZ2dnUU7-IGdnZ2d@giganews.com>
In reply to#26275
On 12/1/2020 12:37 PM, olcott wrote:
> On 12/1/2020 12:14 PM, Kaz Kylheku wrote:
>> On 2020-12-01, olcott <NoOne@NoWhere.com> wrote:
>>> void H_Hat(u32 P)
>>
>> This program has issues.
>>
>>> {
>>>     u32 Aborted = DebugTrace(P, P);
>>
>> The assumption is that DebugTrace always terminates, in
>> one of two ways.  If it returns nonzero, it means that the termination
>> was forced by the simulator, otherwise zero means that P(P)
>> spontaneously halted.
>>
>> The nonzero case can be a false positive, arising from
>> DebugTrace simply not having run P(P) long enough for it to
>> terminate.
>>
>> The essence of the halting problem is that the decider runs into
>> situations in which it itself does not terminate and those are
>> the big problem.
>>
>> You essentially are begging the question: you're *assuming* that your
>> halting decider will always terminate, and therefore arguing that the
>> proofs are wrong because your decider terminates.
>>
>>>     if (Aborted)
>>>       HALT
>>>     else
>>>       HERE: goto HERE;
>>> }
>>>
>>>
>>> int main()
>>> {
>>>     DebugTrace((u32)H_Hat, (u32)H_Hat);
>>>     HALT;
>>
>> Since DebugTrace always terminates, we always reach HALT.
>>
>> Well, what is the meaning of that? This program is supposed to report
>> whether something halted or not; where is it doing that?
>>
>> Why are we ignoring the return value of DebugTrace here?
>>
>> It seems that we can substitute any arguments whatsoever in the
>> DebugTrace call and the program reports the same termination status; how
>> is that a decider?
>>
>> The above are all serious flaws in your work.
>>
> 
> Currently the halt decider is implemented at the operating system level 
> so that it correctly decides these non halting cases:
> 
> int main()
> {
> 
> HERE: goto HERE;
>    OutputString("Hello World!");
>    HALT;
> }
> 
> Output_Debug_Trace() [00010be8]  size(12)  capacity(65536)
> [000005c4](01)  55                  push ebp
> [000005c5](02)  8bec                mov ebp,esp
> [000005c7](02)  ebfe                jmp 000005c7       ---- JMP [000005c7]
> [000005c7](02)  ebfe                jmp 000005c7       ---- JMP [000005c7]
> The PRIOR Instruction Specifies an Infinite Loop: Simulation Stopped:
> 
> 
> HERE: goto HERE;
>    H_Hat((u32)H_Hat);
>    HALT;
> }
> 

CORRECTION

int main()
{
   H_Hat((u32)H_Hat);
   HALT;
}

> Output_Debug_Trace() [00010bc4]  size(76)  capacity(65536)
> [000005b4](01)  55                  push ebp
> [000005b5](02)  8bec                mov ebp,esp
> [000005b7](05)  6884050000          push 00000584
> [000005bc](05)  e8c3ffffff          call 00000584       ----CALL [00000584]
> [00000584](01)  55                  push ebp
> [00000585](02)  8bec                mov ebp,esp
> [00000587](01)  51                  push ecx
> [00000588](03)  8b4508              mov eax,[ebp+08]
> [0000058b](01)  50                  push eax
> [0000058c](03)  8b4d08              mov ecx,[ebp+08]
> [0000058f](01)  51                  push ecx
> [00000590](05)  e8bffdffff          call 00000354       ----CALL [00000354]
> [00000584](01)  55                  push ebp
> [00000585](02)  8bec                mov ebp,esp
> [00000587](01)  51                  push ecx
> [00000588](03)  8b4508              mov eax,[ebp+08]
> [0000058b](01)  50                  push eax
> [0000058c](03)  8b4d08              mov ecx,[ebp+08]
> [0000058f](01)  51                  push ecx
> [00000590](05)  e8bffdffff          call 00000354       ----CALL [00000354]
> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
> 
> 


-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#26269 — Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-01 10:08 -0600
SubjectRe: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face)
Message-ID<AvWdna1EjI3491vCnZ2dnUU7-WHNnZ2d@giganews.com>
In reply to#26250
On 11/30/2020 7:40 PM, Kaz Kylheku wrote:
> On 2020-12-01, olcott <NoOne@NoWhere.com> wrote:
>> int DebugTrace(u32 P, u32 I)
>> {
>>     ((int(*)(int))P)(I);
>>     return 1;
>> }
>>
>> void H_Hat(u32 P)
>> {
>>     u32 Aborted = DebugTrace(P, P);
>>     if (Aborted)
>>       HALT
>>     else
>>       HERE: goto HERE;
>> }
>>
>> int main()
>> {
>>     u32 P = (u32)H_Hat;
>>     DebugTrace(P, P);
>>     HALT;
>> }
>>
>>   From the above infinite recursion it is easy to see that when
>> DebugTrace(P, P) is replaced with a full x86 emulator that we still have
>> infinite recursion.
> 
> In that case we must detect the recursion and report that the program
> does not halt; we can't just let it go on. This means that we are
> looking for a specific pattern of execution which looks like runaway
> recursion.
> 
> Problem is, H_Hat can be this (among other possible structures in a
> similar vain):
> 
>   void H_Hat(u32 P)
>   {
>      Decoy_1003(P); // One of an infinite library of decoys
> 
>      u32 Aborted = DebugTrace(P, P);
>      if (Aborted)
>        HALT
>      else
>        HERE: goto HERE;
>   }
> 
> Some of the decoys terminate, and so the DebugTrace line is
> executed. Some do not terminate.
> 
> The manners in which the non-terminating ones fail to terminate is
> completely arbitrary; it doesn't necessarily look anything like the
> infinite recursion execution trace pattern.
> 
> Stepping through a program to decide its halting is completely
> wrongheaded. We cannot decide halting that way. If we actually
> execute a program P on input I, it either halts (whereupon halting
> is decided) or does not, in which case halting remains undecided.
> 
> To decide halting means to calculate, in a finite number of steps,
> whether any P on any I halts or does not halt.
> 
> Allowing P to execute, and monitoring it for specific non-termination
> patterns does not add up to a halting decider.
> 
> The problem is that as you execute P(I), looking for it to hit
> one of the specific non-terminating patterns, it might appear not
> to be hitting any of those patterns---and yet not terminating!
> 
> Your only choices are:
> 
> 1) step yet anoher instruction cycle and hope that one of the
> non-termination patterns (such as a specific instance of runaway
> recursion) appears, so you can conclude "does not terminate".
> 

The only way that you can maintain your false believe that I am 
incorrect is to make sure to not pay attention to the following complete 
execution trace of fully operational code.

void H_Hat(u32 P)
{
   u32 Aborted = DebugTrace(P, P);
   if (Aborted)
     HALT
   else
     HERE: goto HERE;
}


int main()
{
   DebugTrace((u32)H_Hat, (u32)H_Hat);
   HALT;
}


_H_Hat()
[00000584](01)  55                  push ebp
[00000585](02)  8bec                mov ebp,esp
[00000587](01)  51                  push ecx
[00000588](03)  8b4508              mov eax,[ebp+08]
[0000058b](01)  50                  push eax
[0000058c](03)  8b4d08              mov ecx,[ebp+08]
[0000058f](01)  51                  push ecx
[00000590](05)  e8bffdffff          call 00000354
[00000595](03)  83c408              add esp,+08
[00000598](03)  8945fc              mov [ebp-04],eax
[0000059b](04)  837dfc00            cmp dword [ebp-04],+00
[0000059f](02)  7403                jz 000005a4
[000005a1](01)  f4                  hlt
[000005a2](02)  eb02                jmp 000005a6
[000005a4](02)  ebfe                jmp 000005a4
[000005a6](02)  8be5                mov esp,ebp
[000005a8](01)  5d                  pop ebp
[000005a9](01)  c3                  ret

_main()
[000005b4](01)  55                  push ebp
[000005b5](02)  8bec                mov ebp,esp
[000005b7](05)  6884050000          push 00000584
[000005bc](05)  6884050000          push 00000584
[000005c1](05)  e88efdffff          call 00000354
[000005c6](03)  83c408              add esp,+08
[000005c9](01)  f4                  hlt
[000005ca](01)  5d                  pop ebp
[000005cb](01)  c3                  ret


Output_Debug_Trace() [00010bd3]  size(80)  capacity(65536)
[000005b4](01)  55                  push ebp
[000005b5](02)  8bec                mov ebp,esp
[000005b7](05)  6884050000          push 00000584
[000005bc](05)  6884050000          push 00000584
[000005c1](05)  e88efdffff          call 00000354       ----CALL [00000354]
[00000584](01)  55                  push ebp
[00000585](02)  8bec                mov ebp,esp
[00000587](01)  51                  push ecx
[00000588](03)  8b4508              mov eax,[ebp+08]
[0000058b](01)  50                  push eax
[0000058c](03)  8b4d08              mov ecx,[ebp+08]
[0000058f](01)  51                  push ecx
[00000590](05)  e8bffdffff          call 00000354       ----CALL [00000354]
[00000584](01)  55                  push ebp
[00000585](02)  8bec                mov ebp,esp
[00000587](01)  51                  push ecx
[00000588](03)  8b4508              mov eax,[ebp+08]
[0000058b](01)  50                  push eax
[0000058c](03)  8b4d08              mov ecx,[ebp+08]
[0000058f](01)  51                  push ecx
[00000590](05)  e8bffdffff          call 00000354       ----CALL [00000354]
The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:



-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#26246 — Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-01 01:23 +0000
SubjectRe: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face)
Message-ID<20201130165528.727@kylheku.com>
In reply to#26240
On 2020-11-30, olcott <NoOne@NoWhere.com> wrote:
> On 11/30/2020 4:48 PM, Kaz Kylheku wrote:
>> ["Followup-To:" header set to comp.theory.]
>> On 2020-11-30, olcott <NoOne@NoWhere.com> wrote:
>>> On 11/30/2020 3:06 PM, Kaz Kylheku wrote:
>>>> On 2020-11-30, olcott <NoOne@NoWhere.com> wrote:
>>>>>> You still haven't explained how your non-halting decider can decide if
>>>>>> an arbitrary program given arbitrary input halts.
>>>>>
>>>>> My goal is not to actually solve the halting problem because to do this
>>>>> I would have to write a computer program that is ALL-KNOWING.
>>>>
>>>> An imaginary "all knowing" entity is called an "oracle".
>>>>
>>>> You believe that calculating halting requires an "oracle" program;
>>>> yet you don't see that as an impediment against computability?
>>>>
>>>
>>> I already posted the complete execution trace of the details of how
>>> Halts decides halting on H_Hat()
>>>
>>> void H_Hat(u32 P)
>>> {
>>>     u32 Input_Halts = Halts(P, P);
>>>     if (!Input_Halts)
>>>       HALT
>>>     else
>>>       HERE: goto HERE;
>>> }
>>>
>>> When Halts() always simulates its input it is obvious that
>>> Halts((u32)H_Hat, (u32)H_Hat) specifies infinite recursion thus can be
>>> decided as non halting.
>> 
>> You're blind to the obvious issue that H_Hat isn't a single
>> function/program. It's a *class* of programs.
>> 
>
> Every element of this class (where Halts() bases its decision on 
> simulating its input) specifies infinite recursion.

Firstly, you don't yet understand what it means to decide halting.

You cannot "decide" whether a program P halts on input I simply
by running P(I).  This is because P(I) might not terminate.
Whenever P(I) does not terminate, the halting is not decided.

To decide halting means, /in a finite number of steps/ to decide whether
any P halts on any I.

You're missing he possibility that H_Hat above can include arbitrary
decoy code. For instance, like this, or in any number of other ways:

void H_Hat(u32 P)
{
    Decoy_Calculation(P); // may or may not terminate

    u32 Input_Halts = Halts(P, P);
    if (!Input_Halts)
      HALT
    else
      HERE: goto HERE;
}

If you execute this with a stepwise simulation, you will end up inside
the decoy. So then, you must decide whether that decoy terminates.
Well, assuming you even know you're inside a decoy. A decoy can look
like any innocent program. (Deciding whether the decoy part terminates:
note how that is an embedded instance of the halting problem!)

Now these programs can be generated such that sometimes the decoy does
not terminate, and sometimes it does. Whenever it doesn't terminate, the
runaway recursion part that Halt() is naively looking for is never
reached.

>> You're also forgeting that the Halts has to be *correct* on all inputs.
>> The author of Halts cannot be so obsessed with defeating H_Hat programs
>> that he overlooks correctness.
>
> So then if I correctly refute all the conventional proofs this does not 
> count until I actually solve the halting problem?

If someone were to refute the conventional proofs, it would count for
something. Namely, it would mean that computability reverts to being an
open problem. I.e. that halting may or may not be decidable: we have no
proof one way or the other, in spite of for decades having thought we
had some.

[toc] | [prev] | [next] | [standalone]


#26247 — Re: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-30 19:30 -0600
SubjectRe: The key aspects of x86utm are now finally complete (infinite recursion slaps them in the face)
Message-ID<pcmdnZn7zqICAVjCnZ2dnUU7-aOdnZ2d@giganews.com>
In reply to#26246
On 11/30/2020 7:23 PM, Kaz Kylheku wrote:
> On 2020-11-30, olcott <NoOne@NoWhere.com> wrote:
>> On 11/30/2020 4:48 PM, Kaz Kylheku wrote:
>>> ["Followup-To:" header set to comp.theory.]
>>> On 2020-11-30, olcott <NoOne@NoWhere.com> wrote:
>>>> On 11/30/2020 3:06 PM, Kaz Kylheku wrote:
>>>>> On 2020-11-30, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> You still haven't explained how your non-halting decider can decide if
>>>>>>> an arbitrary program given arbitrary input halts.
>>>>>>
>>>>>> My goal is not to actually solve the halting problem because to do this
>>>>>> I would have to write a computer program that is ALL-KNOWING.
>>>>>
>>>>> An imaginary "all knowing" entity is called an "oracle".
>>>>>
>>>>> You believe that calculating halting requires an "oracle" program;
>>>>> yet you don't see that as an impediment against computability?
>>>>>
>>>>
>>>> I already posted the complete execution trace of the details of how
>>>> Halts decides halting on H_Hat()
>>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>>      u32 Input_Halts = Halts(P, P);
>>>>      if (!Input_Halts)
>>>>        HALT
>>>>      else
>>>>        HERE: goto HERE;
>>>> }
>>>>
>>>> When Halts() always simulates its input it is obvious that
>>>> Halts((u32)H_Hat, (u32)H_Hat) specifies infinite recursion thus can be
>>>> decided as non halting.
>>>
>>> You're blind to the obvious issue that H_Hat isn't a single
>>> function/program. It's a *class* of programs.
>>>
>>
>> Every element of this class (where Halts() bases its decision on
>> simulating its input) specifies infinite recursion.
> 
> Firstly, you don't yet understand what it means to decide halting.
> 

This example proves that you are wrong !

int DebugTrace(u32 P, u32 I)
{
   ((int(*)(int))P)(I);
   return 1;
}

void H_Hat(u32 P)
{
   u32 Aborted = DebugTrace(P, P);
   if (Aborted)
     HALT
   else
     HERE: goto HERE;
}

int main()
{
   u32 P = (u32)H_Hat;
   DebugTrace(P, P);
   HALT;
}


I am stopping at your first mistake because you are not bothering to pay 
any attention what-so-ever to what I just said.

-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#26101 — Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-27 13:03 -0500
SubjectRe: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )
Message-ID<ecbwH.923$PP.154@fx07.iad>
In reply to#26096
On 11/27/20 12:10 PM, olcott wrote:
> On 11/27/2020 10:57 AM, Mr Flibble wrote:
>> On 27/11/2020 16:52, olcott wrote:
>>> On 10/19/2020 12:45 PM, 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.
>>>>
>>>> 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.
>>
>> You still haven't shown how non-halting behaviour is decided.
>>
>> Still nothing to see here.
>>
>> /Flibble
>>
> 
> I have explained how non-halting is decided in complete detail many
> times. It turns out that the complete detail is so simple that no-one
> accepted that it was complete until I proved that it is complete to
> Mike. Here is the proof.
> 
> The sequences of instructions from HERE to THERE and HERE to HERE are
> from actual execution traces. The x86 emulator screens out all dead code
> and only shows us the precise sequence of the code that is actually
> reached.
> 
> -HERE:  // current location
> -   Instructions that cannot possibly exit a loop
> -THERE: goto HERE;
> 
> To form a mathematical proof on the basis of the x86 language being
> construed as a formal language we only have to derive the complete list
> of every instruction that can possibly exit the above loop and if there
> are none of these between the labels HERE and THERE then we know that
> the loop is infinite.
> 
> The case for infinite recursion is similar.
> 
> -HERE: Call Function At Address X
> -   Instructions that cannot possibly exit recursion
> -HERE: Call Function At Address X
> 
> If there are no instructions that can possibly exit recursion between
> invocations of the same function from the same machine address, then
> recursion is infinite.
> 

Yes, infinite recursion with NO conditional is an infinite loop. When
those instruction are executed inside a virtual machine that contains
code that might decide to terminate that loop, then HAS a conditional in
the ACTUAL execution trace of the processor.

If a program calls the Halt Decider insider of itself, that conditional
inside the Halt Decider counts, as far as checking if that outer program
has infinite behavior. This comes out as part of the Halt Deciders
requirement to make its decision in finite time. It is impossible for a
(working) Halt Decider to create non-halting behavior in the code that
uses it (unless the outer program tries to call that Halt Decider an
infinite number of times in that outer program, but then that loop would
be detectable in that outer program).

[toc] | [prev] | [next] | [standalone]


#26108 — Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )

Fromolcott <NoOne@NoWhere.com>
Date2020-11-27 12:46 -0600
SubjectRe: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )
Message-ID<PsOdneY9RaQb1FzCnZ2dnUU7-cXNnZ2d@giganews.com>
In reply to#26101
On 11/27/2020 12:03 PM, Richard Damon wrote:
> On 11/27/20 12:10 PM, olcott wrote:
>> On 11/27/2020 10:57 AM, Mr Flibble wrote:
>>> On 27/11/2020 16:52, olcott wrote:
>>>> On 10/19/2020 12:45 PM, 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.
>>>>>
>>>>> 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.
>>>
>>> You still haven't shown how non-halting behaviour is decided.
>>>
>>> Still nothing to see here.
>>>
>>> /Flibble
>>>
>>
>> I have explained how non-halting is decided in complete detail many
>> times. It turns out that the complete detail is so simple that no-one
>> accepted that it was complete until I proved that it is complete to
>> Mike. Here is the proof.
>>
>> The sequences of instructions from HERE to THERE and HERE to HERE are
>> from actual execution traces. The x86 emulator screens out all dead code
>> and only shows us the precise sequence of the code that is actually
>> reached.
>>
>> -HERE:  // current location
>> -   Instructions that cannot possibly exit a loop
>> -THERE: goto HERE;
>>
>> To form a mathematical proof on the basis of the x86 language being
>> construed as a formal language we only have to derive the complete list
>> of every instruction that can possibly exit the above loop and if there
>> are none of these between the labels HERE and THERE then we know that
>> the loop is infinite.
>>
>> The case for infinite recursion is similar.
>>
>> -HERE: Call Function At Address X
>> -   Instructions that cannot possibly exit recursion
>> -HERE: Call Function At Address X
>>
>> If there are no instructions that can possibly exit recursion between
>> invocations of the same function from the same machine address, then
>> recursion is infinite.
>>
> 
> Yes, infinite recursion with NO conditional is an infinite loop. When
> those instruction are executed inside a virtual machine that contains
> code that might decide to terminate that loop, then HAS a conditional in
> the ACTUAL execution trace of the processor.

It looks like I have to tell you the same thing an average of 
twenty-five times before you ever hear it for the very first time:

HERE IT IS AGAIN:
Any input (TMD / DATA) that would never halt unless its simulator 
stopped simulating it expresses behavior that is not halting behavior.

Halts decides that H_Hat would never halt unless Halts stopped 
simulating H_Hat ∴ Halts(H_Hat, H_Hat) == false.



-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#26126 — Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-27 16:28 -0500
SubjectRe: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )
Message-ID<bcewH.45365$TV7.26972@fx08.iad>
In reply to#26108
On 11/27/20 1:46 PM, olcott wrote:
> On 11/27/2020 12:03 PM, Richard Damon wrote:

>>
>> Yes, infinite recursion with NO conditional is an infinite loop. When
>> those instruction are executed inside a virtual machine that contains
>> code that might decide to terminate that loop, then HAS a conditional in
>> the ACTUAL execution trace of the processor.
> 
> It looks like I have to tell you the same thing an average of
> twenty-five times before you ever hear it for the very first time:
> 
> HERE IT IS AGAIN:
> Any input (TMD / DATA) that would never halt unless its simulator
> stopped simulating it expresses behavior that is not halting behavior.
> 
> Halts decides that H_Hat would never halt unless Halts stopped
> simulating H_Hat ∴ Halts(H_Hat, H_Hat) == false.
> 

And you STILL refuse to look at the actual behavior.

Yes, any input (Turing Machine Description / Data) that would never halt
unless its simulator stopped simulating it expresses behavior that is
not halting.

The problem is that when we actually TEST this, we see that, in the case
of H_Hat it does halt.

Let us built the PROPER test on your machine.

First the basic setup to run the test.

void H_Hat(u32 P)
{
    u32 halting = Halts(P, P);
    if(halting)
    {
        while (1) ;
    }
    else
        HALT;
}

main()
{
    u32 P = (u32) H_Hat;
    Halts(P, P);
}

I think we both agree that the way you have defined this, the Halts in
main will return that H_Hat(H_Hat) does not halt.

Your Halts is defined as running its input just as a UTM until it
detects the non-halting behavior, and then it stops it, so the test of
the unless clause is to change this Halts call to be just a UTM. and if
halts was right, this will never stop. We can replace that UTM with just
the actual machine, so the testing version is just:

main()
{
    u32 P = (u32) H_Hat;
    H_Hat(H_Hat);
}

We can easily run this by hand, and see that the trace will be (and must
be):

in Main:
 1) Set P
 2) Call H_Hat(P)  // H_Hat(H_Hat)
in H_Hat:
 3) call Halts(P, P)  // Halts(H_Hat, H_Hat)
 4) Halts will do its stuff and then return 0 as it things H_Hat will
not halt.
 5) if(haliting)  resuts is false, go to else
 6) HALT

Thus we see that without Halts stopping H_Hat, thus Halts was wrong.

Another possible trace if Halts fails to meet the requirements of a Halt
Detector is for step 4 to just not end and return its results, and thus
prove itself not to be a valid Halt decider.

Now, you are going to rant and rave that we need to change Halts to
totally remove the halting decision from Halts for the test, but that is
NOT what the unless is saying.

First, if we look back to the original Turing Model, the Halts we are
changing is in the actual machine, and all the rest are on the tape, and
we need to ask the question about the same computation so we do NOT get
to change the tape, that MUST contain the 'working' Halts.

Second, if we look at the actual question that a Halting Decider needs
to answer is what the ACTUAL machine would do, and that is what we
actually did, and that clearly doesn't want the broken Halting Decider.

IF you really want to change the question being asked, just publically
announce that you ARE changing the question and accept that this means
any results do apply to the traditional halting problem or other
theories based on it.

[toc] | [prev] | [next] | [standalone]


#26128 — Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )

Fromolcott <NoOne@NoWhere.com>
Date2020-11-27 15:40 -0600
SubjectRe: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )
Message-ID<6vSdnaJBrcGv71zCnZ2dnUU7-SnNnZ2d@giganews.com>
In reply to#26126
On 11/27/2020 3:28 PM, Richard Damon wrote:
> On 11/27/20 1:46 PM, olcott wrote:
>> On 11/27/2020 12:03 PM, Richard Damon wrote:
> 
>>>
>>> Yes, infinite recursion with NO conditional is an infinite loop. When
>>> those instruction are executed inside a virtual machine that contains
>>> code that might decide to terminate that loop, then HAS a conditional in
>>> the ACTUAL execution trace of the processor.
>>
>> It looks like I have to tell you the same thing an average of
>> twenty-five times before you ever hear it for the very first time:
>>
>> HERE IT IS AGAIN:
>> Any input (TMD / DATA) that would never halt unless its simulator
>> stopped simulating it expresses behavior that is not halting behavior.
>>
>> Halts decides that H_Hat would never halt unless Halts stopped
>> simulating H_Hat ∴ Halts(H_Hat, H_Hat) == false.
>>
> 
> And you STILL refuse to look at the actual behavior.
> 
> Yes, any input (Turing Machine Description / Data) that would never halt
> unless its simulator stopped simulating it expresses behavior that is
> not halting.
> 
> The problem is that when we actually TEST this, we see that, in the case
> of H_Hat it does halt.
> 
ONLY BECAUSE ITS SIMULATOR STOPPED SIMULATING IT, thus leaving no chance 
what-so-ever for any correct rebuttal.

Why you persist in incorrect rebuttals I will never know, it sure seems 
quite foolish to me.

Perhaps you really do have attention deficit disorder and we have to go 
through this twenty more times before you get it.


-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#26129 — Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )

Fromolcott <NoOne@NoWhere.com>
Date2020-11-27 15:52 -0600
SubjectRe: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )
Message-ID<1JOdnQuvENeH6FzCnZ2dnUU7-cvNnZ2d@giganews.com>
In reply to#26128
On 11/27/2020 3:40 PM, olcott wrote:
> On 11/27/2020 3:28 PM, Richard Damon wrote:
>> On 11/27/20 1:46 PM, olcott wrote:
>>> On 11/27/2020 12:03 PM, Richard Damon wrote:
>>
>>>>
>>>> Yes, infinite recursion with NO conditional is an infinite loop. When
>>>> those instruction are executed inside a virtual machine that contains
>>>> code that might decide to terminate that loop, then HAS a 
>>>> conditional in
>>>> the ACTUAL execution trace of the processor.
>>>
>>> It looks like I have to tell you the same thing an average of
>>> twenty-five times before you ever hear it for the very first time:
>>>
>>> HERE IT IS AGAIN:
>>> Any input (TMD / DATA) that would never halt unless its simulator
>>> stopped simulating it expresses behavior that is not halting behavior.
>>>
>>> Halts decides that H_Hat would never halt unless Halts stopped
>>> simulating H_Hat ∴ Halts(H_Hat, H_Hat) == false.
>>>
>>
>> And you STILL refuse to look at the actual behavior.
>>
>> Yes, any input (Turing Machine Description / Data) that would never halt
>> unless its simulator stopped simulating it expresses behavior that is
>> not halting.
>>
>> The problem is that when we actually TEST this, we see that, in the case
>> of H_Hat it does halt.
>>
> ONLY BECAUSE ITS SIMULATOR STOPPED SIMULATING IT, thus leaving no chance 
> what-so-ever for any correct rebuttal.
> 
> Why you persist in incorrect rebuttals I will never know, it sure seems 
> quite foolish to me.
> 
> Perhaps you really do have attention deficit disorder and we have to go 
> through this twenty more times before you get it.

We are not asking:
Does Halts(H_Hat, H_Hat) halt?

We are asking:
Does this input (H_Hat, H_Hat) to Halts have to be aborted?


-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#26131 — Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-27 17:17 -0500
SubjectRe: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )
Message-ID<xVewH.9846$sB6.7859@fx34.iad>
In reply to#26129
On 11/27/20 4:52 PM, olcott wrote:
> On 11/27/2020 3:40 PM, olcott wrote:
>> On 11/27/2020 3:28 PM, Richard Damon wrote:
>>> On 11/27/20 1:46 PM, olcott wrote:
>>>> On 11/27/2020 12:03 PM, Richard Damon wrote:
>>>
>>>>>
>>>>> Yes, infinite recursion with NO conditional is an infinite loop. When
>>>>> those instruction are executed inside a virtual machine that contains
>>>>> code that might decide to terminate that loop, then HAS a
>>>>> conditional in
>>>>> the ACTUAL execution trace of the processor.
>>>>
>>>> It looks like I have to tell you the same thing an average of
>>>> twenty-five times before you ever hear it for the very first time:
>>>>
>>>> HERE IT IS AGAIN:
>>>> Any input (TMD / DATA) that would never halt unless its simulator
>>>> stopped simulating it expresses behavior that is not halting behavior.
>>>>
>>>> Halts decides that H_Hat would never halt unless Halts stopped
>>>> simulating H_Hat ∴ Halts(H_Hat, H_Hat) == false.
>>>>
>>>
>>> And you STILL refuse to look at the actual behavior.
>>>
>>> Yes, any input (Turing Machine Description / Data) that would never halt
>>> unless its simulator stopped simulating it expresses behavior that is
>>> not halting.
>>>
>>> The problem is that when we actually TEST this, we see that, in the case
>>> of H_Hat it does halt.
>>>
>> ONLY BECAUSE ITS SIMULATOR STOPPED SIMULATING IT, thus leaving no
>> chance what-so-ever for any correct rebuttal.
>>
>> Why you persist in incorrect rebuttals I will never know, it sure
>> seems quite foolish to me.
>>
>> Perhaps you really do have attention deficit disorder and we have to
>> go through this twenty more times before you get it.
> 
> We are not asking:
> Does Halts(H_Hat, H_Hat) halt?
> 
> We are asking:
> Does this input (H_Hat, H_Hat) to Halts have to be aborted?
> 

ARE YOU ADMITING TO NOT WORKING ON THE HALTING PROBLEM?

Note, the Halting problem is stated exactly as does the Actual Machine
Halt or not (it does not presume an emulation approach)

Also, my proof shows that it did not HAVE to be abort, if we remove the
aborting code from just the top level of decision, so that the problem
wa are asking about stay the same, we see that it DOES halt, and thus
Halts was wrong in it decision that it HAD to be aborted.

If someone says that I have to leave by 7:30 to get somewhere by 8:00,
but I am able to leave at 7:40 and get there, it shows that they were wrong.

In the same way, if the Halt Decider says that it had to abort the
program or it wouldn't stop, and I run that same program without the
halt decider and it does halt, that halt decider was wrong.

[toc] | [prev] | [next] | [standalone]


#26135 — Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )

Fromolcott <NoOne@NoWhere.com>
Date2020-11-27 17:20 -0600
SubjectRe: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )
Message-ID<jKKdnU4Cz7hcFFzCnZ2dnUU7-YmdnZ2d@giganews.com>
In reply to#26131
On 11/27/2020 4:17 PM, Richard Damon wrote:
> On 11/27/20 4:52 PM, olcott wrote:
>> On 11/27/2020 3:40 PM, olcott wrote:
>>> On 11/27/2020 3:28 PM, Richard Damon wrote:
>>>> On 11/27/20 1:46 PM, olcott wrote:
>>>>> On 11/27/2020 12:03 PM, Richard Damon wrote:
>>>>
>>>>>>
>>>>>> Yes, infinite recursion with NO conditional is an infinite loop. When
>>>>>> those instruction are executed inside a virtual machine that contains
>>>>>> code that might decide to terminate that loop, then HAS a
>>>>>> conditional in
>>>>>> the ACTUAL execution trace of the processor.
>>>>>
>>>>> It looks like I have to tell you the same thing an average of
>>>>> twenty-five times before you ever hear it for the very first time:
>>>>>
>>>>> HERE IT IS AGAIN:
>>>>> Any input (TMD / DATA) that would never halt unless its simulator
>>>>> stopped simulating it expresses behavior that is not halting behavior.
>>>>>
>>>>> Halts decides that H_Hat would never halt unless Halts stopped
>>>>> simulating H_Hat ∴ Halts(H_Hat, H_Hat) == false.
>>>>>
>>>>
>>>> And you STILL refuse to look at the actual behavior.
>>>>
>>>> Yes, any input (Turing Machine Description / Data) that would never halt
>>>> unless its simulator stopped simulating it expresses behavior that is
>>>> not halting.
>>>>
>>>> The problem is that when we actually TEST this, we see that, in the case
>>>> of H_Hat it does halt.
>>>>
>>> ONLY BECAUSE ITS SIMULATOR STOPPED SIMULATING IT, thus leaving no
>>> chance what-so-ever for any correct rebuttal.
>>>
>>> Why you persist in incorrect rebuttals I will never know, it sure
>>> seems quite foolish to me.
>>>
>>> Perhaps you really do have attention deficit disorder and we have to
>>> go through this twenty more times before you get it.
>>
>> We are not asking:
>> Does Halts(H_Hat, H_Hat) halt?
>>
>> We are asking:
>> Does this input (H_Hat, H_Hat) to Halts have to be aborted?
>>
> 
> ARE YOU ADMITING TO NOT WORKING ON THE HALTING PROBLEM?
> 
> Note, the Halting problem is stated exactly as does the Actual Machine
> Halt or not (it does not presume an emulation approach)
> 
> Also, my proof shows that it did not HAVE to be abort, 

And equally you could "prove" that cats are a kind of dog.

> if we remove the
> aborting code from just the top level of decision, so that the problem
> wa are asking about stay the same, we see that it DOES halt, and thus
> Halts was wrong in it decision that it HAD to be aborted.
> 
> If someone says that I have to leave by 7:30 to get somewhere by 8:00,
> but I am able to leave at 7:40 and get there, it shows that they were wrong.
> 
> In the same way, if the Halt Decider says that it had to abort the
> program or it wouldn't stop, and I run that same program without the
> halt decider and it does halt, that halt decider was wrong.
> 


-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#26139 — Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-27 21:27 -0500
SubjectRe: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )
Message-ID<kAiwH.147940$093.110876@fx05.iad>
In reply to#26135
On 11/27/20 6:20 PM, olcott wrote:
> On 11/27/2020 4:17 PM, Richard Damon wrote:
>> On 11/27/20 4:52 PM, olcott wrote:
>>>
>>> We are not asking:
>>> Does Halts(H_Hat, H_Hat) halt?
>>>
>>> We are asking:
>>> Does this input (H_Hat, H_Hat) to Halts have to be aborted?
>>>
>>
>> ARE YOU ADMITING TO NOT WORKING ON THE HALTING PROBLEM?
>>
>> Note, the Halting problem is stated exactly as does the Actual Machine
>> Halt or not (it does not presume an emulation approach)
>>
>> Also, my proof shows that it did not HAVE to be abort, 
> 
> And equally you could "prove" that cats are a kind of dog.

That shows how much logic you know.

If you are so sure my proof is unsound, please show me which statement
is false or does not follow.

I have given your arguement that level of dignity, even if you refuse to
look at them.

[toc] | [prev] | [next] | [standalone]


#26130 — Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-27 17:09 -0500
SubjectRe: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )
Message-ID<fOewH.33277$Uz.24853@fx46.iad>
In reply to#26128
On 11/27/20 4:40 PM, olcott wrote:
> On 11/27/2020 3:28 PM, Richard Damon wrote:
>> On 11/27/20 1:46 PM, olcott wrote:
>>> On 11/27/2020 12:03 PM, Richard Damon wrote:
>>
>>>>
>>>> Yes, infinite recursion with NO conditional is an infinite loop. When
>>>> those instruction are executed inside a virtual machine that contains
>>>> code that might decide to terminate that loop, then HAS a
>>>> conditional in
>>>> the ACTUAL execution trace of the processor.
>>>
>>> It looks like I have to tell you the same thing an average of
>>> twenty-five times before you ever hear it for the very first time:
>>>
>>> HERE IT IS AGAIN:
>>> Any input (TMD / DATA) that would never halt unless its simulator
>>> stopped simulating it expresses behavior that is not halting behavior.
>>>
>>> Halts decides that H_Hat would never halt unless Halts stopped
>>> simulating H_Hat ∴ Halts(H_Hat, H_Hat) == false.
>>>
>>
>> And you STILL refuse to look at the actual behavior.
>>
>> Yes, any input (Turing Machine Description / Data) that would never halt
>> unless its simulator stopped simulating it expresses behavior that is
>> not halting.
>>
>> The problem is that when we actually TEST this, we see that, in the case
>> of H_Hat it does halt.
>>
> ONLY BECAUSE ITS SIMULATOR STOPPED SIMULATING IT, thus leaving no chance
> what-so-ever for any correct rebuttal.
> 
> Why you persist in incorrect rebuttals I will never know, it sure seems
> quite foolish to me.
> 
> Perhaps you really do have attention deficit disorder and we have to go
> through this twenty more times before you get it.
> 
> 

I don't know why you continue to say I have, ADD, I suspect that you do
not really understand what that illness is. I do suspect you may have
some condition as you seem to refuse to actually at the actual evidence.
You seem to be stuck in some sort of false reality and unable to see the
truth

One thing to particularly note, you have totally snipped without any
comment the proof that you were wrong.

Yes, if you look at the execution trace of the program, the Halts
function does emulate a H_Hat/Halts recursion for a while and then
stops, but as the proof shows, that if that top level didn't do this
abort, it would have continued a bit and then stopped. Also, if Halts
did not stop the execution it would have failed to meet its
requirements. This shows that the technique it is using is flawed.
(Something you seem to have decide is impossible)

When we look at the full trace of the program, it is clear that an
answer of non-halting has to be wrong. (so is an answer of halting,
which is how Linz proves that such a decider can not exist).

[toc] | [prev] | [next] | [standalone]


#26133 — Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )

Fromolcott <NoOne@NoWhere.com>
Date2020-11-27 17:09 -0600
SubjectRe: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )
Message-ID<ocmdndSIT4-6GlzCnZ2dnUU7-L-dnZ2d@giganews.com>
In reply to#26130
On 11/27/2020 4:09 PM, Richard Damon wrote:
> On 11/27/20 4:40 PM, olcott wrote:
>> On 11/27/2020 3:28 PM, Richard Damon wrote:
>>> On 11/27/20 1:46 PM, olcott wrote:
>>>> On 11/27/2020 12:03 PM, Richard Damon wrote:
>>>
>>>>>
>>>>> Yes, infinite recursion with NO conditional is an infinite loop. When
>>>>> those instruction are executed inside a virtual machine that contains
>>>>> code that might decide to terminate that loop, then HAS a
>>>>> conditional in
>>>>> the ACTUAL execution trace of the processor.
>>>>
>>>> It looks like I have to tell you the same thing an average of
>>>> twenty-five times before you ever hear it for the very first time:
>>>>
>>>> HERE IT IS AGAIN:
>>>> Any input (TMD / DATA) that would never halt unless its simulator
>>>> stopped simulating it expresses behavior that is not halting behavior.
>>>>
>>>> Halts decides that H_Hat would never halt unless Halts stopped
>>>> simulating H_Hat ∴ Halts(H_Hat, H_Hat) == false.
>>>>
>>>
>>> And you STILL refuse to look at the actual behavior.
>>>
>>> Yes, any input (Turing Machine Description / Data) that would never halt
>>> unless its simulator stopped simulating it expresses behavior that is
>>> not halting.
>>>
>>> The problem is that when we actually TEST this, we see that, in the case
>>> of H_Hat it does halt.
>>>
>> ONLY BECAUSE ITS SIMULATOR STOPPED SIMULATING IT, thus leaving no chance
>> what-so-ever for any correct rebuttal.
>>
>> Why you persist in incorrect rebuttals I will never know, it sure seems
>> quite foolish to me.
>>
>> Perhaps you really do have attention deficit disorder and we have to go
>> through this twenty more times before you get it.
>>
>>
> 

Any input (TMD / DATA) that would never halt unless its simulator
stopped simulating it expresses behavior that is not halting behavior.

Thus proving beyond all possible doubt that Halts necessarily made a 
correct not halting decision when it decided to stop simulating H_Hat.

We are not asking:
Does Halts(H_Hat, H_Hat) halt?

We are asking:
Does this input (H_Hat, H_Hat) to Halts have to be aborted?



-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#26140 — Re: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-27 21:51 -0500
SubjectRe: The key aspects of x86utm are now finally complete (Refuting the HP proofs)(algorithm to decide not-halting )
Message-ID<gXiwH.68828$J92.40787@fx48.iad>
In reply to#26133
On 11/27/20 6:09 PM, olcott wrote:

> 
> Any input (TMD / DATA) that would never halt unless its simulator
> stopped simulating it expresses behavior that is not halting behavior.
> 
> Thus proving beyond all possible doubt that Halts necessarily made a
> correct not halting decision when it decided to stop simulating H_Hat.
> 
> We are not asking:
> Does Halts(H_Hat, H_Hat) halt?
> 
> We are asking:
> Does this input (H_Hat, H_Hat) to Halts have to be aborted?
> 
>

I will ask this question again:

Are you admitting that you are asking an essentially different question
than the classic halting problem, and thus admitting that your results
do not apply to it or related theories.

If so, just be a man and say it.

If not, remember, at least when talking about an existing theory or
field, you don't get to make the rule, you don't get to redefine thing,
you can add supplemental ideas not specifed in the system, but you are
stuck dealing with the existing system.

If you continue to claim applicability to the classic halting problem, I
will state that you last statement PROVES that you argument is UNSOUND
as you are starting from a false premise, and a basic rule of logic is
if you start with a false premise, you argument is inherently UNSOUND.

Your false premise is the definition of the halting problem, you are
trying to work from the wrong definition, therefore everything you
derive from that is UNSOUND.

The classical halting problem is ALWAYS about predicting the behavor of
the actual machine. Any other definition of the problem is ultimately
wrong. If you can show an alternate wording comes out identically, then
it can be used, but ONLY as long as it gives the exact same results.

Yes, the wording you use can be interpreted to be identical, but as I
have shown, then when you do the test, it ends up boiling down to the
test of the actual machine, not surprising if it really means the exact
same thing. The problem is that after using that wording, you seem to
then reinterpret some of the words to not be identical, and THAT
invalidate your whole arguement.

Fundamentally, when I hear what you are arguing, it really seems like
you really do want to try to come up with an alternate wording of the
halting problem. And as I have said many times before, THAT is ok, IF
you accept what that means, that with this alternate definition you
can't just assume that your new problem, the 'need to abort' problem, is
a full replacement for the halting problem and revolutionize the field.
It is a DIFFERENT problme with different claims and different
applicability.

To go this road gives you a lot of freedom, you can choose which rules
you want to keep, and which you wish to get rid of. You can change
whatever requirements you want. The cost of that freedom is that you are
now in uncharted lands, so you need to figure out what this problem
implies, what it is good for, and all that. This would really be a job
for someone with a real strong background in mathematical logic and
theories. From what I have seen so far, not sure you have it, but I am
willing to let you surprise me.

Probably the first real step is to really define what conditions
constitute 'abortable', You will need to figure how to handle the other
sort of problems that give halting problem solvers issues (like
uncomputable functions), and how you will handle them. You have things
like unbounded machines, that may never repeat a state, but go on
forever, or maybe only 10**10**100 cycles (or more). If you can clearly
define what sorts of problems you CAN solve, and what kinds you can't,
then you might be able to prove something. It just won't be the
classical halting problem.

[toc] | [prev] | [standalone]


Page 5 of 5 — ← Prev page 1 2 3 4 [5]

Back to top | Article view | comp.theory


csiph-web