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


Groups > comp.theory > #26137 > unrolled thread

Halting test example

Started byJeff Barnett <jbb@notatt.com>
First post2020-11-27 16:44 -0700
Last post2020-12-05 00:41 -0700
Articles 10 on this page of 70 — 10 participants

Back to article view | Back to comp.theory


Contents

  Halting test example Jeff Barnett <jbb@notatt.com> - 2020-11-27 16:44 -0700
    Re: Halting test example Jeff Barnett <jbb@notatt.com> - 2020-12-03 11:00 -0700
      Re: Halting test example [ Correct refutation of Peter Linz proof ] olcott <NoOne@NoWhere.com> - 2020-12-03 12:18 -0600
        Re: Halting test example [ Correct refutation of Peter Linz proof ] Jeff Barnett <jbb@notatt.com> - 2020-12-03 12:18 -0700
          Re: Halting test example [ Correct refutation of Peter Linz proof ] olcott <NoOne@NoWhere.com> - 2020-12-03 13:23 -0600
            Re: Halting test example [ Correct refutation of Peter Linz proof ] Jeff Barnett <jbb@notatt.com> - 2020-12-03 12:44 -0700
              Re: Halting test example [ Correct refutation of Peter Linz proof ] olcott <NoOne@NoWhere.com> - 2020-12-03 13:55 -0600
            Re: Halting test example [ Correct refutation of Peter Linz proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-03 20:21 +0000
              Re: Halting test example [ Correct refutation of Peter Linz proof ] olcott <NoOne@NoWhere.com> - 2020-12-03 14:48 -0600
                Re: Halting test example [ Correct refutation of Peter Linz proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-03 22:58 +0000
                  Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-03 17:26 -0600
                    Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Jeff Barnett <jbb@notatt.com> - 2020-12-03 17:21 -0700
                      Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-03 18:31 -0600
                        Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Jeff Barnett <jbb@notatt.com> - 2020-12-03 18:13 -0700
                          Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-03 19:20 -0600
                    Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-04 00:26 +0000
                      Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-03 18:40 -0600
                        Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-04 01:17 +0000
                          Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-03 19:39 -0600
                            Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Daniel Pehoushek <pehoushek1@gmail.com> - 2020-12-03 18:20 -0800
                              Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Jeff Barnett <jbb@notatt.com> - 2020-12-03 21:23 -0700
                                Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-12-04 19:49 -0800
                            Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-04 19:31 +0000
                              Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-04 13:49 -0600
                                Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-04 21:19 +0000
                                  Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-04 15:43 -0600
                                Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Richard Damon <Richard@Damon-Family.org> - 2020-12-04 17:18 -0500
                                  Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-04 17:07 -0600
                                    Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Richard Damon <Richard@Damon-Family.org> - 2020-12-04 18:31 -0500
                                      Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-04 18:05 -0600
                                        Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Richard Damon <Richard@Damon-Family.org> - 2020-12-04 19:43 -0500
                                    Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-05 01:59 +0000
                                      Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-04 20:38 -0600
                                        Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-05 03:55 +0000
                                          Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-04 22:13 -0600
                                            Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-12-04 20:47 -0800
                                              Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-04 22:55 -0600
                                                Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-12-04 23:26 -0800
                                                  Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-05 09:54 -0600
                                                    Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-05 16:36 +0000
                                                      Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-05 11:04 -0600
                                                    Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Andy Walker <anw@cuboid.co.uk> - 2020-12-05 16:57 +0000
                                                      Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-05 11:16 -0600
                                                        Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Andy Walker <anw@cuboid.co.uk> - 2020-12-05 17:38 +0000
                                                          Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-05 11:46 -0600
                                            Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-05 11:50 +0000
                                              Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Andy Walker <anw@cuboid.co.uk> - 2020-12-05 13:41 +0000
                                                Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-05 10:42 -0600
                                              Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-12-05 05:58 -0800
                                                Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-05 10:55 -0600
                                                  Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-05 17:08 +0000
                                                    Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-05 11:24 -0600
                                              Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-05 10:35 -0600
                                                Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-05 23:36 +0000
                                                  Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-05 17:59 -0600
                                                    Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-06 02:00 +0000
                                                      Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-05 20:17 -0600
                                                        Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-06 06:06 +0000
                              Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-12-05 01:13 +0000
                                Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-04 19:58 -0600
                                  Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-12-06 01:30 +0000
                                    Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) olcott <NoOne@NoWhere.com> - 2020-12-05 19:37 -0600
                                      Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz) Richard Damon <Richard@Damon-Family.org> - 2020-12-05 21:06 -0500
        Re: Halting test example [ Correct refutation of Peter Linz proof ] Jeff Barnett <jbb@notatt.com> - 2020-12-03 17:29 -0700
    Re: Halting test example olcott <NoOne@NoWhere.com> - 2020-12-03 18:52 -0600
      Re: Halting test example Jeff Barnett <jbb@notatt.com> - 2020-12-03 21:09 -0700
        Re: Halting test example olcott <NoOne@NoWhere.com> - 2020-12-03 22:15 -0600
          Re: Halting test example Jeff Barnett <jbb@notatt.com> - 2020-12-04 10:13 -0700
            Re: Halting test example olcott <NoOne@NoWhere.com> - 2020-12-04 11:17 -0600
              Re: Halting test example Jeff Barnett <jbb@notatt.com> - 2020-12-05 00:41 -0700

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


#26522 — Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-12-06 01:30 +0000
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<87im9fraas.fsf@bsb.me.uk>
In reply to#26454
olcott <NoOne@NoWhere.com> writes:

> On 12/4/2020 7:13 PM, Ben Bacarisse wrote:
<cut>
>> I would say that the pattern /is/ sufficient.  
>
> That looks like good news for the significance of my work.

Is being wrong about something that matters better than being wrong
about something incidental?

-- 
Ben.

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


#26523 — Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-05 19:37 -0600
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<tZCdnd_R6_JUqFHCnZ2dnUU7-UHNnZ2d@giganews.com>
In reply to#26522
On 12/5/2020 7:30 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 12/4/2020 7:13 PM, Ben Bacarisse wrote:
> <cut>
>>> I would say that the pattern /is/ sufficient.
>>
>> That looks like good news for the significance of my work.
> 
> Is being wrong about something that matters better than being wrong
> about something incidental?
> 

The only way that you can say that without flat out lying is to make 
sure that you keep ignoring this proof that I am correct.

You cannot possibly point to any logical error because there are no 
logical errors.

Actual debug trace of H() correctly deciding halting on H_Hat()

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


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


_H_Hat()
[000005e0](01)  55                  push ebp
[000005e1](02)  8bec                mov ebp,esp
[000005e3](01)  51                  push ecx
[000005e4](03)  8b4508              mov eax,[ebp+08]
[000005e7](01)  50                  push eax
[000005e8](03)  8b4d08              mov ecx,[ebp+08]
[000005eb](01)  51                  push ecx
[000005ec](05)  e87ffdffff          call 00000370
[000005f1](03)  83c408              add esp,+08
[000005f4](03)  8945fc              mov [ebp-04],eax
[000005f7](04)  837dfc00            cmp dword [ebp-04],+00
[000005fb](02)  7404                jz 00000601
[000005fd](02)  ebfe                jmp 000005fd
[000005ff](02)  eb01                jmp 00000602
[00000601](01)  f4                  hlt
[00000602](02)  8be5                mov esp,ebp
[00000604](01)  5d                  pop ebp
[00000605](01)  c3                  ret

_main()
[00000610](01)  55                  push ebp
[00000611](02)  8bec                mov ebp,esp
[00000613](05)  68e0050000          push 000005e0
[00000618](05)  68e0050000          push 000005e0
[0000061d](05)  e84efdffff          call 00000370
[00000622](03)  83c408              add esp,+08
[00000625](01)  f4                  hlt
[00000626](01)  5d                  pop ebp
[00000627](01)  c3                  ret


Output_Debug_Trace() Trace_List.size(20)
[00000610](01)   EMU_Level(0) 55                  push ebp
[00000611](02)   EMU_Level(0) 8bec                mov ebp,esp
[00000613](05)   EMU_Level(0) 68e0050000          push 000005e0
[00000618](05)   EMU_Level(0) 68e0050000          push 000005e0
[0000061d](05)   EMU_Level(0) e84efdffff          call 00000370 
----CALL [00000370]
[000005e0](01)   EMU_Level(1) 55                  push ebp
[000005e1](02)   EMU_Level(1) 8bec                mov ebp,esp
[000005e3](01)   EMU_Level(1) 51                  push ecx
[000005e4](03)   EMU_Level(1) 8b4508              mov eax,[ebp+08]
[000005e7](01)   EMU_Level(1) 50                  push eax
[000005e8](03)   EMU_Level(1) 8b4d08              mov ecx,[ebp+08]
[000005eb](01)   EMU_Level(1) 51                  push ecx
[000005ec](05)   EMU_Level(1) e87ffdffff          call 00000370 
----CALL [00000370]
[000005e0](01)   EMU_Level(2) 55                  push ebp
[000005e1](02)   EMU_Level(2) 8bec                mov ebp,esp
[000005e3](01)   EMU_Level(2) 51                  push ecx
[000005e4](03)   EMU_Level(2) 8b4508              mov eax,[ebp+08]
[000005e7](01)   EMU_Level(2) 50                  push eax
[000005e8](03)   EMU_Level(2) 8b4d08              mov ecx,[ebp+08]
[000005eb](01)   EMU_Level(2) 51                  push ecx
[000005ec](05)   EMU_Level(2) e87ffdffff          call 00000370 
----CALL [00000370]
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]


#26529 — Re: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)

FromRichard Damon <Richard@Damon-Family.org>
Date2020-12-05 21:06 -0500
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<L0XyH.62176$NL3.20387@fx12.iad>
In reply to#26523
On 12/5/20 8:37 PM, olcott wrote:
> On 12/5/2020 7:30 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 12/4/2020 7:13 PM, Ben Bacarisse wrote:
>> <cut>
>>>> I would say that the pattern /is/ sufficient.
>>>
>>> That looks like good news for the significance of my work.
>>
>> Is being wrong about something that matters better than being wrong
>> about something incidental?
>>
> 
> The only way that you can say that without flat out lying is to make
> sure that you keep ignoring this proof that I am correct.
> 
> You cannot possibly point to any logical error because there are no
> logical errors.

I can point out two errors in this

#1, the trace is incomplete, and is omiting a conditional that is part
of the computation of H_Hst, and thus qualifies to break the infinite
recursion, That conditional being part of the definiton of H occuring
somewhere in the trace between address 00000370 and 000005E0

#2, the recursion is found within the execution trace of H, within
H_Hat, so if that IS an infinite recursion, then this indicates that H
will not return its decision in Finite Time, and thus fail to meets its
requirements.


> 
> Actual debug trace of H() correctly deciding halting on H_Hat()
> 
> void H_Hat(u32 P)
> {
>   u32 Input_Halts = H(P, P);
>   if (Input_Halts)
>     HERE: goto HERE;
>   else
>     HALT
> }
> 
> 
> int main()
> {
>   H((u32)H_Hat, (u32)H_Hat);
>   HALT;
> }
> 
> 
> _H_Hat()
> [000005e0](01)  55                  push ebp
> [000005e1](02)  8bec                mov ebp,esp
> [000005e3](01)  51                  push ecx
> [000005e4](03)  8b4508              mov eax,[ebp+08]
> [000005e7](01)  50                  push eax
> [000005e8](03)  8b4d08              mov ecx,[ebp+08]
> [000005eb](01)  51                  push ecx
> [000005ec](05)  e87ffdffff          call 00000370
> [000005f1](03)  83c408              add esp,+08
> [000005f4](03)  8945fc              mov [ebp-04],eax
> [000005f7](04)  837dfc00            cmp dword [ebp-04],+00
> [000005fb](02)  7404                jz 00000601
> [000005fd](02)  ebfe                jmp 000005fd
> [000005ff](02)  eb01                jmp 00000602
> [00000601](01)  f4                  hlt
> [00000602](02)  8be5                mov esp,ebp
> [00000604](01)  5d                  pop ebp
> [00000605](01)  c3                  ret
> 
> _main()
> [00000610](01)  55                  push ebp
> [00000611](02)  8bec                mov ebp,esp
> [00000613](05)  68e0050000          push 000005e0
> [00000618](05)  68e0050000          push 000005e0
> [0000061d](05)  e84efdffff          call 00000370
> [00000622](03)  83c408              add esp,+08
> [00000625](01)  f4                  hlt
> [00000626](01)  5d                  pop ebp
> [00000627](01)  c3                  ret
> 
> 
> Output_Debug_Trace() Trace_List.size(20)
> [00000610](01)   EMU_Level(0) 55                  push ebp
> [00000611](02)   EMU_Level(0) 8bec                mov ebp,esp
> [00000613](05)   EMU_Level(0) 68e0050000          push 000005e0
> [00000618](05)   EMU_Level(0) 68e0050000          push 000005e0
> [0000061d](05)   EMU_Level(0) e84efdffff          call 00000370 ----CALL
> [00000370]
> [000005e0](01)   EMU_Level(1) 55                  push ebp
> [000005e1](02)   EMU_Level(1) 8bec                mov ebp,esp
> [000005e3](01)   EMU_Level(1) 51                  push ecx
> [000005e4](03)   EMU_Level(1) 8b4508              mov eax,[ebp+08]
> [000005e7](01)   EMU_Level(1) 50                  push eax
> [000005e8](03)   EMU_Level(1) 8b4d08              mov ecx,[ebp+08]
> [000005eb](01)   EMU_Level(1) 51                  push ecx
> [000005ec](05)   EMU_Level(1) e87ffdffff          call 00000370 ----CALL
> [00000370]
> [000005e0](01)   EMU_Level(2) 55                  push ebp
> [000005e1](02)   EMU_Level(2) 8bec                mov ebp,esp
> [000005e3](01)   EMU_Level(2) 51                  push ecx
> [000005e4](03)   EMU_Level(2) 8b4508              mov eax,[ebp+08]
> [000005e7](01)   EMU_Level(2) 50                  push eax
> [000005e8](03)   EMU_Level(2) 8b4d08              mov ecx,[ebp+08]
> [000005eb](01)   EMU_Level(2) 51                  push ecx
> [000005ec](05)   EMU_Level(2) e87ffdffff          call 00000370 ----CALL
> [00000370]
> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
> 
> 

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


#26381 — Re: Halting test example [ Correct refutation of Peter Linz proof ]

FromJeff Barnett <jbb@notatt.com>
Date2020-12-03 17:29 -0700
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ]
Message-ID<rqbvtr$d4v$1@dont-email.me>
In reply to#26361
On 12/3/2020 11:18 AM, olcott wrote:
> On 12/3/2020 12:00 PM, Jeff Barnett wrote:
>> On 11/27/2020 4:44 PM, Jeff Barnett wrote:
>>> I will present an interesting example for a working a working halt 
>>> detector to display its worthiness of the title. The code will be 
>>> presented in pseudo Lisp and can be translated into your favorite 
>>> language, e.g., C, TM, or even your favorite real Lisp. I don't think 
>>> there will be many takers or comments so I'm probably wasting my time.
>>>
>>> The halt function value is boolean i.e., T or NIL, and has one 
>>> mandatory argument, a function, followed by zero or more arguments 
>>> that are for the function. Thus, the outline of the halt detector is
>>>
>>> (define haltp (function &rest arguments)
>>>     ;; Value is t if (apply function arguments) is a finite, halting
>>>     ;; computation, and nil if it isn't.
>>>     your implementation of halts that produces a proper t or nil 
>>> value in
>>>     a finite amount of time.)
>>>
>>> (define main ()
>>>    (if (haltp #checker)
>>>        (print "Conjecture crushed")
>>>        (print "Conjecture confirmed")))
>>>
>>> (define checker ()
>>>     ;; Loop through the positive integers looking for a counter example
>>>     ;; to the conjecture. If found, return nil. If conjecture is 
>>> true, we
>>>     ;; will loop forever. Is there a clever way to tell this will 
>>> happen?
>>>     (loop for n = 1 step 1
>>>           unless (haltp #check1 n)
>>>             return nil))
>>>
>>> (define check1 (n)
>>>     ;; N is an integer. We check the conjecture for n. If it's true, we
>>>     ;; return t.
>>>     (loop when (= n 1) Return t
>>>           do (if (evenp n) (setq n (/ n 2)) (setq n (+ (* 3 n) 1))))
>>>
>>> Question: What does main print? There can hardly be a simpler 
>>> computation where halting or not halting is not obvious. Yet Erdos 
>>> said approximately "Mathematics is not yet ripe enough for such 
>>> questions." Your fame is ensured if you can shed some light on this 
>>> example.
>>
>> I am so disappointed in PO. I'd hoped he would take on the challenge, 
>> succeed at it, publish his paper, retire from Usenet, and die a happy 
>> man. Perhaps I should have included a Lisp manual though I thought he 
>> knew the language. After all he used to barrage the Lisp forum with 
>> all of his wisdom.
> 
> Because of your reckless disregard for the truth** (you admitted to not 
> paying attention to the technical substance of what I have been saying) 
> you may not have noticed that I have provided a correct refutation of 
> the Peter Linz proof.
> 
> ** The standard required for legal action against libel.

Below I refute your silly nonsense and show you to be a freaking fool, 
but that's not news to anyone.

This reply is to call your attention to changing the subject line of 
this thread. Aren't you the crybaby (sorry to all babies for the 
comparison) that used to whine "It's my thread and you can't do that off 
topic stuff ... whaaa, whaaa, etc." Bad Usenet move. I guess you don't 
know how to use the reply button in your news reader or maybe you tried 
to code it up yourself? If any of that is try, we have yet another 
example that you can't program very well, not even enough to hold an 
entry level job for any length of time.
-- 
Jeff Barnett

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


#26384

Fromolcott <NoOne@NoWhere.com>
Date2020-12-03 18:52 -0600
Message-ID<fs6dndntF6TVFVTCnZ2dnUU7-T3NnZ2d@giganews.com>
In reply to#26137
On 11/27/2020 5:44 PM, Jeff Barnett wrote:
> I will present an interesting example for a working a working halt 
> detector to display its worthiness of the title. The code will be 
> presented in pseudo Lisp and can be translated into your favorite 
> language, e.g., C, TM, or even your favorite real Lisp. I don't think 
> there will be many takers or comments so I'm probably wasting my time.
> 
> The halt function value is boolean i.e., T or NIL, and has one mandatory 
> argument, a function, followed by zero or more arguments that are for 
> the function. Thus, the outline of the halt detector is
> 
> (define haltp (function &rest arguments)
>     ;; Value is t if (apply function arguments) is a finite, halting
>     ;; computation, and nil if it isn't.
>     your implementation of halts that produces a proper t or nil value in
>     a finite amount of time.)
> 
> (define main ()
>    (if (haltp #checker)
>        (print "Conjecture crushed")
>        (print "Conjecture confirmed")))
> 
> (define checker ()
>     ;; Loop through the positive integers looking for a counter example
>     ;; to the conjecture. If found, return nil. If conjecture is true, we
>     ;; will loop forever. Is there a clever way to tell this will happen?
>     (loop for n = 1 step 1
>           unless (haltp #check1 n)
>             return nil))
> 
> (define check1 (n)
>     ;; N is an integer. We check the conjecture for n. If it's true, we
>     ;; return t.
>     (loop when (= n 1) Return t
>           do (if (evenp n) (setq n (/ n 2)) (setq n (+ (* 3 n) 1))))
> 
> Question: What does main print? There can hardly be a simpler 
> computation where halting or not halting is not obvious. Yet Erdos said 
> approximately "Mathematics is not yet ripe enough for such questions." 
> Your fame is ensured if you can shed some light on this example.

This is the closest thing that you have ever provided that approximates 
a rebuttal so I will address it.

https://en.wikipedia.org/wiki/Goldbach%27s_conjecture
Halting only when a system has found a solution to an unsolved math 
problem sure seems like halting problem undecidability to some people.

I think the the issue is that currently unknown solutions to unsolved 
math problems are not directly equivalent to undecidability. As soon as 
the solution is known we have decidability.

-- 
Copyright 2020 Pete Olcott

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

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


#26407

FromJeff Barnett <jbb@notatt.com>
Date2020-12-03 21:09 -0700
Message-ID<rqccqq$e84$1@dont-email.me>
In reply to#26384
On 12/3/2020 5:52 PM, olcott wrote:
> On 11/27/2020 5:44 PM, Jeff Barnett wrote:
>> I will present an interesting example for a working a working halt 
>> detector to display its worthiness of the title. The code will be 
>> presented in pseudo Lisp and can be translated into your favorite 
>> language, e.g., C, TM, or even your favorite real Lisp. I don't think 
>> there will be many takers or comments so I'm probably wasting my time.
>>
>> The halt function value is boolean i.e., T or NIL, and has one 
>> mandatory argument, a function, followed by zero or more arguments 
>> that are for the function. Thus, the outline of the halt detector is
>>
>> (define haltp (function &rest arguments)
>>     ;; Value is t if (apply function arguments) is a finite, halting
>>     ;; computation, and nil if it isn't.
>>     your implementation of halts that produces a proper t or nil value in
>>     a finite amount of time.)
>>
>> (define main ()
>>    (if (haltp #checker)
>>        (print "Conjecture crushed")
>>        (print "Conjecture confirmed")))
>>
>> (define checker ()
>>     ;; Loop through the positive integers looking for a counter example
>>     ;; to the conjecture. If found, return nil. If conjecture is true, we
>>     ;; will loop forever. Is there a clever way to tell this will happen?
>>     (loop for n = 1 step 1
>>           unless (haltp #check1 n)
>>             return nil))
>>
>> (define check1 (n)
>>     ;; N is an integer. We check the conjecture for n. If it's true, we
>>     ;; return t.
>>     (loop when (= n 1) Return t
>>           do (if (evenp n) (setq n (/ n 2)) (setq n (+ (* 3 n) 1))))
>>
>> Question: What does main print? There can hardly be a simpler 
>> computation where halting or not halting is not obvious. Yet Erdos 
>> said approximately "Mathematics is not yet ripe enough for such 
>> questions." Your fame is ensured if you can shed some light on this 
>> example.
> 
> This is the closest thing that you have ever provided that approximates 
> a rebuttal so I will address it.
> 
> https://en.wikipedia.org/wiki/Goldbach%27s_conjecture
> Halting only when a system has found a solution to an unsolved math 
> problem sure seems like halting problem undecidability to some people.
> 
> I think the the issue is that currently unknown solutions to unsolved 
> math problems are not directly equivalent to undecidability. As soon as 
> the solution is known we have decidability.

Schmuck! This isn't the Goldbach conjecture. Maybe you know that. Likely 
not. That article says nothing interesting about the challenge issued to 
little old you. It's a very simple program - no recursion, no fancy 
structures, just plain ordinary stuff. I want to see a halt decider that 
works so I can see what MAIN prints. That and only that is your challenge.

I'm assuming you cannot and will die without either accepting or beating 
this challenge. Even if you latest poorly designed liquid code could 
find a hole in the Linz approach (it wont) you still wont be able to 
tell me what my example prints.
-- 
Jeff Barnett

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


#26408

Fromolcott <NoOne@NoWhere.com>
Date2020-12-03 22:15 -0600
Message-ID<pMWdnVp-YN1uKlTCnZ2dnUU7-QOdnZ2d@giganews.com>
In reply to#26407
On 12/3/2020 10:09 PM, Jeff Barnett wrote:
> On 12/3/2020 5:52 PM, olcott wrote:
>> On 11/27/2020 5:44 PM, Jeff Barnett wrote:
>>> I will present an interesting example for a working a working halt 
>>> detector to display its worthiness of the title. The code will be 
>>> presented in pseudo Lisp and can be translated into your favorite 
>>> language, e.g., C, TM, or even your favorite real Lisp. I don't think 
>>> there will be many takers or comments so I'm probably wasting my time.
>>>
>>> The halt function value is boolean i.e., T or NIL, and has one 
>>> mandatory argument, a function, followed by zero or more arguments 
>>> that are for the function. Thus, the outline of the halt detector is
>>>
>>> (define haltp (function &rest arguments)
>>>     ;; Value is t if (apply function arguments) is a finite, halting
>>>     ;; computation, and nil if it isn't.
>>>     your implementation of halts that produces a proper t or nil 
>>> value in
>>>     a finite amount of time.)
>>>
>>> (define main ()
>>>    (if (haltp #checker)
>>>        (print "Conjecture crushed")
>>>        (print "Conjecture confirmed")))
>>>
>>> (define checker ()
>>>     ;; Loop through the positive integers looking for a counter example
>>>     ;; to the conjecture. If found, return nil. If conjecture is 
>>> true, we
>>>     ;; will loop forever. Is there a clever way to tell this will 
>>> happen?
>>>     (loop for n = 1 step 1
>>>           unless (haltp #check1 n)
>>>             return nil))
>>>
>>> (define check1 (n)
>>>     ;; N is an integer. We check the conjecture for n. If it's true, we
>>>     ;; return t.
>>>     (loop when (= n 1) Return t
>>>           do (if (evenp n) (setq n (/ n 2)) (setq n (+ (* 3 n) 1))))
>>>
>>> Question: What does main print? There can hardly be a simpler 
>>> computation where halting or not halting is not obvious. Yet Erdos 
>>> said approximately "Mathematics is not yet ripe enough for such 
>>> questions." Your fame is ensured if you can shed some light on this 
>>> example.
>>
>> This is the closest thing that you have ever provided that 
>> approximates a rebuttal so I will address it.
>>
>> https://en.wikipedia.org/wiki/Goldbach%27s_conjecture
>> Halting only when a system has found a solution to an unsolved math 
>> problem sure seems like halting problem undecidability to some people.
>>
>> I think the the issue is that currently unknown solutions to unsolved 
>> math problems are not directly equivalent to undecidability. As soon 
>> as the solution is known we have decidability.
> 
> Schmuck! This isn't the Goldbach conjecture. Maybe you know that. Likely 
> not. That article says nothing interesting about the challenge issued to 
> little old you. It's a very simple program - no recursion, no fancy 
> structures, just plain ordinary stuff. I want to see a halt decider that 
> works so I can see what MAIN prints. That and only that is your challenge.
> 
> I'm assuming you cannot and will die without either accepting or beating 
> this challenge. Even if you latest poorly designed liquid code could 
> find a hole in the Linz approach (it wont) you still wont be able to 
> tell me what my example prints.

You understand that "challenges" such as this have nothing to do with 
halting undecidability don't you?

-- 
Copyright 2020 Pete Olcott

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

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


#26425

FromJeff Barnett <jbb@notatt.com>
Date2020-12-04 10:13 -0700
Message-ID<rqdqna$3c9$1@dont-email.me>
In reply to#26408
On 12/3/2020 9:15 PM, olcott wrote:
> On 12/3/2020 10:09 PM, Jeff Barnett wrote:
>> On 12/3/2020 5:52 PM, olcott wrote:
>>> On 11/27/2020 5:44 PM, Jeff Barnett wrote:
>>>> I will present an interesting example for a working a working halt 
>>>> detector to display its worthiness of the title. The code will be 
>>>> presented in pseudo Lisp and can be translated into your favorite 
>>>> language, e.g., C, TM, or even your favorite real Lisp. I don't 
>>>> think there will be many takers or comments so I'm probably wasting 
>>>> my time.
>>>>
>>>> The halt function value is boolean i.e., T or NIL, and has one 
>>>> mandatory argument, a function, followed by zero or more arguments 
>>>> that are for the function. Thus, the outline of the halt detector is
>>>>
>>>> (define haltp (function &rest arguments)
>>>>     ;; Value is t if (apply function arguments) is a finite, halting
>>>>     ;; computation, and nil if it isn't.
>>>>     your implementation of halts that produces a proper t or nil 
>>>> value in
>>>>     a finite amount of time.)
>>>>
>>>> (define main ()
>>>>    (if (haltp #checker)
>>>>        (print "Conjecture crushed")
>>>>        (print "Conjecture confirmed")))
>>>>
>>>> (define checker ()
>>>>     ;; Loop through the positive integers looking for a counter example
>>>>     ;; to the conjecture. If found, return nil. If conjecture is 
>>>> true, we
>>>>     ;; will loop forever. Is there a clever way to tell this will 
>>>> happen?
>>>>     (loop for n = 1 step 1
>>>>           unless (haltp #check1 n)
>>>>             return nil))
>>>>
>>>> (define check1 (n)
>>>>     ;; N is an integer. We check the conjecture for n. If it's true, we
>>>>     ;; return t.
>>>>     (loop when (= n 1) Return t
>>>>           do (if (evenp n) (setq n (/ n 2)) (setq n (+ (* 3 n) 1))))
>>>>
>>>> Question: What does main print? There can hardly be a simpler 
>>>> computation where halting or not halting is not obvious. Yet Erdos 
>>>> said approximately "Mathematics is not yet ripe enough for such 
>>>> questions." Your fame is ensured if you can shed some light on this 
>>>> example.
>>>
>>> This is the closest thing that you have ever provided that 
>>> approximates a rebuttal so I will address it.
>>>
>>> https://en.wikipedia.org/wiki/Goldbach%27s_conjecture
>>> Halting only when a system has found a solution to an unsolved math 
>>> problem sure seems like halting problem undecidability to some people.
>>>
>>> I think the the issue is that currently unknown solutions to unsolved 
>>> math problems are not directly equivalent to undecidability. As soon 
>>> as the solution is known we have decidability.
>>
>> Schmuck! This isn't the Goldbach conjecture. Maybe you know that. 
>> Likely not. That article says nothing interesting about the challenge 
>> issued to little old you. It's a very simple program - no recursion, 
>> no fancy structures, just plain ordinary stuff. I want to see a halt 
>> decider that works so I can see what MAIN prints. That and only that 
>> is your challenge.
>>
>> I'm assuming you cannot and will die without either accepting or 
>> beating this challenge. Even if you latest poorly designed liquid code 
>> could find a hole in the Linz approach (it wont) you still wont be 
>> able to tell me what my example prints.
> 
> You understand that "challenges" such as this have nothing to do with 
> halting undecidability don't you?

Why not? If you can solve halting, there are zillions of interesting 
problems with solutions that add to our knowledge. Since you have given 
up the ghost on a legitimate investigation, even its definition, you 
have no status to question research questions or questions of 
applicability. You have shown a complete lack of understanding, drive to 
know what's what, and honesty and intelligence.

You have first claimed to have a Linz counterexample, then a Linz buster 
but had neither - in TM form or any other. You've busted your ass back 
pedaling in a fairly dishonest and certainly unscientific manner. You 
haven't succeeded in your career and apparently you are going to flunk 
private life too.

You can redeem all your claims by taking the above challenge you know. 
Don't dismiss it, embrace it and your dreams will come true.
-- 
Jeff Barnett

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


#26427

Fromolcott <NoOne@NoWhere.com>
Date2020-12-04 11:17 -0600
Message-ID<SvGdnX6_hry48lfCnZ2dnUU7-N2dnZ2d@giganews.com>
In reply to#26425
On 12/4/2020 11:13 AM, Jeff Barnett wrote:
> On 12/3/2020 9:15 PM, olcott wrote:
>> On 12/3/2020 10:09 PM, Jeff Barnett wrote:
>>> On 12/3/2020 5:52 PM, olcott wrote:
>>>> On 11/27/2020 5:44 PM, Jeff Barnett wrote:
>>>>> I will present an interesting example for a working a working halt 
>>>>> detector to display its worthiness of the title. The code will be 
>>>>> presented in pseudo Lisp and can be translated into your favorite 
>>>>> language, e.g., C, TM, or even your favorite real Lisp. I don't 
>>>>> think there will be many takers or comments so I'm probably wasting 
>>>>> my time.
>>>>>
>>>>> The halt function value is boolean i.e., T or NIL, and has one 
>>>>> mandatory argument, a function, followed by zero or more arguments 
>>>>> that are for the function. Thus, the outline of the halt detector is
>>>>>
>>>>> (define haltp (function &rest arguments)
>>>>>     ;; Value is t if (apply function arguments) is a finite, halting
>>>>>     ;; computation, and nil if it isn't.
>>>>>     your implementation of halts that produces a proper t or nil 
>>>>> value in
>>>>>     a finite amount of time.)
>>>>>
>>>>> (define main ()
>>>>>    (if (haltp #checker)
>>>>>        (print "Conjecture crushed")
>>>>>        (print "Conjecture confirmed")))
>>>>>
>>>>> (define checker ()
>>>>>     ;; Loop through the positive integers looking for a counter 
>>>>> example
>>>>>     ;; to the conjecture. If found, return nil. If conjecture is 
>>>>> true, we
>>>>>     ;; will loop forever. Is there a clever way to tell this will 
>>>>> happen?
>>>>>     (loop for n = 1 step 1
>>>>>           unless (haltp #check1 n)
>>>>>             return nil))
>>>>>
>>>>> (define check1 (n)
>>>>>     ;; N is an integer. We check the conjecture for n. If it's 
>>>>> true, we
>>>>>     ;; return t.
>>>>>     (loop when (= n 1) Return t
>>>>>           do (if (evenp n) (setq n (/ n 2)) (setq n (+ (* 3 n) 1))))
>>>>>
>>>>> Question: What does main print? There can hardly be a simpler 
>>>>> computation where halting or not halting is not obvious. Yet Erdos 
>>>>> said approximately "Mathematics is not yet ripe enough for such 
>>>>> questions." Your fame is ensured if you can shed some light on this 
>>>>> example.
>>>>
>>>> This is the closest thing that you have ever provided that 
>>>> approximates a rebuttal so I will address it.
>>>>
>>>> https://en.wikipedia.org/wiki/Goldbach%27s_conjecture
>>>> Halting only when a system has found a solution to an unsolved math 
>>>> problem sure seems like halting problem undecidability to some people.
>>>>
>>>> I think the the issue is that currently unknown solutions to 
>>>> unsolved math problems are not directly equivalent to 
>>>> undecidability. As soon as the solution is known we have decidability.
>>>
>>> Schmuck! This isn't the Goldbach conjecture. Maybe you know that. 
>>> Likely not. That article says nothing interesting about the challenge 
>>> issued to little old you. It's a very simple program - no recursion, 
>>> no fancy structures, just plain ordinary stuff. I want to see a halt 
>>> decider that works so I can see what MAIN prints. That and only that 
>>> is your challenge.
>>>
>>> I'm assuming you cannot and will die without either accepting or 
>>> beating this challenge. Even if you latest poorly designed liquid 
>>> code could find a hole in the Linz approach (it wont) you still wont 
>>> be able to tell me what my example prints.
>>
>> You understand that "challenges" such as this have nothing to do with 
>> halting undecidability don't you?
> 
> Why not? If you can solve halting, there are zillions of interesting 
> problems with solutions that add to our knowledge. 

We could make another such program that only halts when it has a 
mathematical proof of the meaning of life.

-- 
Copyright 2020 Pete Olcott

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

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


#26472

FromJeff Barnett <jbb@notatt.com>
Date2020-12-05 00:41 -0700
Message-ID<rqfdj9$lej$1@dont-email.me>
In reply to#26427
On 12/4/2020 10:17 AM, olcott wrote:
> We could make another such program that only halts when it has a 
> mathematical proof of the meaning of life.

Call that program HL and form from it in the usual way, HL_HAT. Now we 
substitute PO for HL in the names and learn there is no possible meaning 
to the life of PO, a result long suspected by most of the panelist in 
this forum. So get a life; but note you will not find sufficient meaning 
by pursuing mathematical and logical subjects.
-- 
Jeff Barnett

[toc] | [prev] | [standalone]


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

Back to top | Article view | comp.theory


csiph-web