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


Groups > comp.software-eng > #2051 > unrolled thread

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

Started byolcott <NoOne@NoWhere.com>
First post2020-12-03 12:18 -0600
Last post2020-12-03 17:29 -0700
Articles 20 on this page of 38 — 4 participants

Back to article view | Back to comp.software-eng

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.


Contents

  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 ] olcott <NoOne@NoWhere.com> - 2020-12-03 13:55 -0600
    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) 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) 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) olcott <NoOne@NoWhere.com> - 2020-12-05 11:16 -0600
                                  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) 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) olcott <NoOne@NoWhere.com> - 2020-12-05 10:42 -0600
                          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-04 19:58 -0600
                  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 ] Jeff Barnett <jbb@notatt.com> - 2020-12-03 17:29 -0700

Page 1 of 2  [1] 2  Next page →


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

Fromolcott <NoOne@NoWhere.com>
Date2020-12-03 12:18 -0600
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ]
Message-ID<EY6dndpQIuCbsVTCnZ2dnUU7-KXNnZ2d@giganews.com>
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.

-- 
Copyright 2020 Pete Olcott

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

[toc] | [next] | [standalone]


#2055

Fromolcott <NoOne@NoWhere.com>
Date2020-12-03 13:55 -0600
Message-ID<C5GdnS3XZdEr31TCnZ2dnUU7-K3NnZ2d@giganews.com>
In reply to#2051
On 12/3/2020 1:44 PM, Jeff Barnett wrote:
> On 12/3/2020 12:23 PM, olcott wrote:
>> On 12/3/2020 1:18 PM, Jeff Barnett wrote:
>>> 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 only things that you have refuted are that you are rational and 
>>> that you are still on your meds.
>>>
>>>> ** The standard required for legal action against libel.
>>>
>>> You could attempt a court case. I bet that would get more attention 
>>> (still not positive) than your Usenet performance. Remember, in the 
>>> USA as opposed to the British Isles, truth is a proper defense 
>>> against libel. Since your peers are convinced that your head's 
>>> function is akin to a marshmallow, the only award you may win is 
>>> "best sweet headcheese" at a state fair.
>>
>> The only one that bothered to provide an accurate review was Kaz, and 
>> he agreed that I did refute Linz.
> 
> Then publish, it's your time!! On the other hand, I'm not sure he said 
> that, I recall a hint of sarcasm in some of his replies. We have a 
> president who lives only for flattery true or otherwise. Are you now 
> emulating him?
> 
> PS Have you filed your libel suit yet?

It is very easily objectively verifiable that I am correct in less than 
five minutes by anyone having BSBS degree in computer science.

The only reason that any of my rebuttals ever stood is that no one 
(until Kaz) ever bothered to actually take those five minutes.


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

I spent about 3000 hours creating the x86utm operating system that 
executes x86 based virtual machines using a very excellent x86 emulator. 
It executes the COFF object file output of the Microsoft C compiler 
using x86 emulation.

x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
It is common knowledge that all x86 based programs are computationally 
equivalent to UTMs for every computation that does not require more 
memory than they have.

Here is H_Hat (computational equivalent to the Linz Ĥ) being correctly 
decided by DebugTrace() (computational equivalent to the Linz H).

http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf

Linz, Peter 1990. An Introduction to Formal Languages and Automata. 
Lexington/Toronto: D. C. Heath and Company.

The following is fully executable code and its complete execution trace 
is provided below.

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


int main()
{
   H((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]


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

Fromolcott <NoOne@NoWhere.com>
Date2020-12-03 17:26 -0600
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<oNCdnZQh6e-h6VTCnZ2dnUU7-aXNnZ2d@giganews.com>
In reply to#2051
On 12/3/2020 4:58 PM, Kaz Kylheku wrote:
> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>> On 12/3/2020 2:21 PM, Kaz Kylheku wrote:
>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>> The only one that bothered to provide an accurate review was Kaz, and he
>>>> agreed that I did refute Linz.
>>>
>>> That I certainly did not; I'm not familiar with all the details of the
>>> Linz argument.
>>>
>>
>> What you said was equivalent to agreement that I correctly refuted the
>> Linz proof.
> 
> If so, only coincidentall, not due to knowing specifics about the Linz
> proof. I did not drop that name at all in my posts.
> 
>> Here is the whole proof so that you can double check.
>> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
> 
> Right off the bat I see that this is just a chapter in a textbook.
> 
> I'm not an academic, but I strongly suspect that swinging a stick at
> textbooks won't get you very far in academics.
> 
> Lo and behold, Linz' chapter in fact contains the required caveats that
> I alluded to in my other posts. Did you miss this somehow?
> 
> Quote:
> 
>    "One may object to Definition 12.1, since we required that, to solve the
>    halting problem, H had to start and end in very specific configurations.
>                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>    It is, however, not hard to see that these somewhat arbitrarily chosen
>    conditions play only a  minor role in the argument, and that essentially
>    the same reasoning could be used with any other starting and ending
>    configurations."
> 
> You see? This is exactly the sort of thing I'm talking about.  The
> example configurations are only that: they show one simple possibility.
> 
> Linz knows that the specific configurations are suceptible to being
> detected by a simple trick.

It is important to keep in mind what Theorem 12.1 says. It does not 
preclude solving the halting problem for specific cases; often we can 
tell by an analysis of M and w whether or not the Turing machine will 
halt. What the theorem says is that this cannot always be done; there is 
no algorithm that can make a correct decision for all WM and w.

In other words programs like this can can be decided:
int Add(int X, int Y)
{
   return X + Y;
}


Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn

My solution applies to: every single instance that matches the above 
pattern thus not any "very specific configuration".

> His remarks add up to something very similar to what I'm saying about
> how H_Hat can be other configurations that have various decoy code.
> 

I think that the fact that I refuted ALL of the conventional pseudo-code 
representations of the undecidability of the halting problem and that 
the Linz Ĥ matches these patterns is sufficient evidence that my 
findings are of some consequence.

> Now, since Linz included these words to accompany his proof sketch, you
> cannot write an article which accuses Linz' of promulgating a false
> proof which is susceptible to an attack which targets the specific state
> machine structure in his diagram, such as by stepping the state
> transitions to detect the trivial qa <---> qb cycle.
> 
> Every reasonable reviewer will just point you to the above quoted
> paragraph where the author addresses the objection.

I think that you are misinterpreting those words. I don't think that he 
was saying that his Ĥ pattern (that matches all the pseudo-code 
examples) has a trivial solution. It turns out that the solution is 
relatively trivial yet it took me at least 12,000 hours over 16 years to 
find it. It is only trivial in retrospect.

> There may be other articles similar to Linz's which don't have these
> caveats; and you can go on a crusade to hunt them down and point out
> the omission. I don't see where that will get you.

The key thing is that I correctly refuted the entire Ĥ pattern.

Now that I finally have someone that will not flat out lie in their 
review of my work I am confident that my presentation is clear enough to 
be escalated to the next higher level of review.


-- 
Copyright 2020 Pete Olcott

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

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


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

FromJeff Barnett <jbb@notatt.com>
Date2020-12-03 17:21 -0700
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<rqbvdm$as4$1@dont-email.me>
In reply to#2057
On 12/3/2020 4:26 PM, olcott wrote:
> On 12/3/2020 4:58 PM, Kaz Kylheku wrote:
>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>> On 12/3/2020 2:21 PM, Kaz Kylheku wrote:
>>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>>> The only one that bothered to provide an accurate review was Kaz, 
>>>>> and he
>>>>> agreed that I did refute Linz.
>>>>
>>>> That I certainly did not; I'm not familiar with all the details of the
>>>> Linz argument.
>>>>
>>>
>>> What you said was equivalent to agreement that I correctly refuted the
>>> Linz proof.
>>
>> If so, only coincidentall, not due to knowing specifics about the Linz
>> proof. I did not drop that name at all in my posts.
>>
>>> Here is the whole proof so that you can double check.
>>> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>
>> Right off the bat I see that this is just a chapter in a textbook.
>>
>> I'm not an academic, but I strongly suspect that swinging a stick at
>> textbooks won't get you very far in academics.
>>
>> Lo and behold, Linz' chapter in fact contains the required caveats that
>> I alluded to in my other posts. Did you miss this somehow?
>>
>> Quote:
>>
>>    "One may object to Definition 12.1, since we required that, to 
>> solve the
>>    halting problem, H had to start and end in very specific 
>> configurations.
>>                                            
>> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>>    It is, however, not hard to see that these somewhat arbitrarily chosen
>>    conditions play only a  minor role in the argument, and that 
>> essentially
>>    the same reasoning could be used with any other starting and ending
>>    configurations."
>>
>> You see? This is exactly the sort of thing I'm talking about.  The
>> example configurations are only that: they show one simple possibility.
>>
>> Linz knows that the specific configurations are suceptible to being
>> detected by a simple trick.
> 
> It is important to keep in mind what Theorem 12.1 says. It does not 
> preclude solving the halting problem for specific cases; often we can 
> tell by an analysis of M and w whether or not the Turing machine will 
> halt. What the theorem says is that this cannot always be done; there is 
> no algorithm that can make a correct decision for all WM and w.
> 
> In other words programs like this can can be decided:
> int Add(int X, int Y)
> {
>    return X + Y;
> }
> 
> 
> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
> 
> My solution applies to: every single instance that matches the above 
> pattern thus not any "very specific configuration".
> 
>> His remarks add up to something very similar to what I'm saying about
>> how H_Hat can be other configurations that have various decoy code.
>>
> 
> I think that the fact that I refuted ALL of the conventional pseudo-code 
> representations of the undecidability of the halting problem and that 
> the Linz Ĥ matches these patterns is sufficient evidence that my 
> findings are of some consequence.
> 
>> Now, since Linz included these words to accompany his proof sketch, you
>> cannot write an article which accuses Linz' of promulgating a false
>> proof which is susceptible to an attack which targets the specific state
>> machine structure in his diagram, such as by stepping the state
>> transitions to detect the trivial qa <---> qb cycle.
>>
>> Every reasonable reviewer will just point you to the above quoted
>> paragraph where the author addresses the objection.
> 
> I think that you are misinterpreting those words. I don't think that he 
> was saying that his Ĥ pattern (that matches all the pseudo-code 
> examples) has a trivial solution. It turns out that the solution is 
> relatively trivial yet it took me at least 12,000 hours over 16 years to 
> find it. It is only trivial in retrospect.
> 
>> There may be other articles similar to Linz's which don't have these
>> caveats; and you can go on a crusade to hunt them down and point out
>> the omission. I don't see where that will get you.
> 
> The key thing is that I correctly refuted the entire Ĥ pattern.
> 
> Now that I finally have someone that will not flat out lie in their 
> review of my work I am confident that my presentation is clear enough to 
> be escalated to the next higher level of review.

I believe that every single reviewer says you got it wrong for Linz 
style counterexamples. since most of these folks are a whole lot smarter 
than you as well as more learning flexible, we see that you are the 
perpetual butt of Einstein's "Great spirits have always encountered 
violent opposition from mediocre minds." Yours is barley mediocre and 
not very honest.
-- 
Jeff Barnett

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-12-03 18:31 -0600
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<csSdnTch7ov7HlTCnZ2dnUU7-UvNnZ2d@giganews.com>
In reply to#2058
On 12/3/2020 6:21 PM, Jeff Barnett wrote:
> On 12/3/2020 4:26 PM, olcott wrote:
>> On 12/3/2020 4:58 PM, Kaz Kylheku wrote:
>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>> On 12/3/2020 2:21 PM, Kaz Kylheku wrote:
>>>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>>>> The only one that bothered to provide an accurate review was Kaz, 
>>>>>> and he
>>>>>> agreed that I did refute Linz.
>>>>>
>>>>> That I certainly did not; I'm not familiar with all the details of the
>>>>> Linz argument.
>>>>>
>>>>
>>>> What you said was equivalent to agreement that I correctly refuted the
>>>> Linz proof.
>>>
>>> If so, only coincidentall, not due to knowing specifics about the Linz
>>> proof. I did not drop that name at all in my posts.
>>>
>>>> Here is the whole proof so that you can double check.
>>>> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>>
>>> Right off the bat I see that this is just a chapter in a textbook.
>>>
>>> I'm not an academic, but I strongly suspect that swinging a stick at
>>> textbooks won't get you very far in academics.
>>>
>>> Lo and behold, Linz' chapter in fact contains the required caveats that
>>> I alluded to in my other posts. Did you miss this somehow?
>>>
>>> Quote:
>>>
>>>    "One may object to Definition 12.1, since we required that, to 
>>> solve the
>>>    halting problem, H had to start and end in very specific 
>>> configurations.
>>> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>>>    It is, however, not hard to see that these somewhat arbitrarily 
>>> chosen
>>>    conditions play only a  minor role in the argument, and that 
>>> essentially
>>>    the same reasoning could be used with any other starting and ending
>>>    configurations."
>>>
>>> You see? This is exactly the sort of thing I'm talking about.  The
>>> example configurations are only that: they show one simple possibility.
>>>
>>> Linz knows that the specific configurations are suceptible to being
>>> detected by a simple trick.
>>
>> It is important to keep in mind what Theorem 12.1 says. It does not 
>> preclude solving the halting problem for specific cases; often we can 
>> tell by an analysis of M and w whether or not the Turing machine will 
>> halt. What the theorem says is that this cannot always be done; there 
>> is no algorithm that can make a correct decision for all WM and w.
>>
>> In other words programs like this can can be decided:
>> int Add(int X, int Y)
>> {
>>    return X + Y;
>> }
>>
>>
>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>>
>> My solution applies to: every single instance that matches the above 
>> pattern thus not any "very specific configuration".
>>
>>> His remarks add up to something very similar to what I'm saying about
>>> how H_Hat can be other configurations that have various decoy code.
>>>
>>
>> I think that the fact that I refuted ALL of the conventional 
>> pseudo-code representations of the undecidability of the halting 
>> problem and that the Linz Ĥ matches these patterns is sufficient 
>> evidence that my findings are of some consequence.
>>
>>> Now, since Linz included these words to accompany his proof sketch, you
>>> cannot write an article which accuses Linz' of promulgating a false
>>> proof which is susceptible to an attack which targets the specific state
>>> machine structure in his diagram, such as by stepping the state
>>> transitions to detect the trivial qa <---> qb cycle.
>>>
>>> Every reasonable reviewer will just point you to the above quoted
>>> paragraph where the author addresses the objection.
>>
>> I think that you are misinterpreting those words. I don't think that 
>> he was saying that his Ĥ pattern (that matches all the pseudo-code 
>> examples) has a trivial solution. It turns out that the solution is 
>> relatively trivial yet it took me at least 12,000 hours over 16 years 
>> to find it. It is only trivial in retrospect.
>>
>>> There may be other articles similar to Linz's which don't have these
>>> caveats; and you can go on a crusade to hunt them down and point out
>>> the omission. I don't see where that will get you.
>>
>> The key thing is that I correctly refuted the entire Ĥ pattern.
>>
>> Now that I finally have someone that will not flat out lie in their 
>> review of my work I am confident that my presentation is clear enough 
>> to be escalated to the next higher level of review.
> 
> I believe that every single reviewer says you got it wrong for Linz 
> style counterexamples. 

One of these reviewers said that it was utterly dishonest of me to call 
two identical programs by the same name because these two identical 
programs are so different from each other.

Another one of these reviewers never could understand that infinite 
recursion never ever returns a result to its caller.

Bottom line is that no one could provide any reasoning showing as many 
as one single material error in any of my work.

Besides Kaz and to some degree Malcolm there were only two types of 
reviewers, those that did not understand what I am saying and those 
would use dishonest tactics for the purpose of disparagement.

> since most of these folks are a whole lot smarter 
> than you 

A guy that cannot possibly understand that infinite recursion never ever 
returns a result to its caller is certainly not a lot smarter than me.
He it probably the only one here that does not understand that.

> as well as more learning flexible, we see that you are the 
> perpetual butt of Einstein's "Great spirits have always encountered 
> violent opposition from mediocre minds." Yours is barley mediocre and 
> not very honest.


-- 
Copyright 2020 Pete Olcott

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

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


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

FromJeff Barnett <jbb@notatt.com>
Date2020-12-03 18:13 -0700
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<rqc2f6$osq$1@dont-email.me>
In reply to#2061
On 12/3/2020 5:31 PM, olcott wrote:
> On 12/3/2020 6:21 PM, Jeff Barnett wrote:
>> On 12/3/2020 4:26 PM, olcott wrote:
>>> On 12/3/2020 4:58 PM, Kaz Kylheku wrote:
>>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 12/3/2020 2:21 PM, Kaz Kylheku wrote:
>>>>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> The only one that bothered to provide an accurate review was Kaz, 
>>>>>>> and he
>>>>>>> agreed that I did refute Linz.
>>>>>>
>>>>>> That I certainly did not; I'm not familiar with all the details of 
>>>>>> the
>>>>>> Linz argument.
>>>>>>
>>>>>
>>>>> What you said was equivalent to agreement that I correctly refuted the
>>>>> Linz proof.
>>>>
>>>> If so, only coincidentall, not due to knowing specifics about the Linz
>>>> proof. I did not drop that name at all in my posts.
>>>>
>>>>> Here is the whole proof so that you can double check.
>>>>> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>>>
>>>> Right off the bat I see that this is just a chapter in a textbook.
>>>>
>>>> I'm not an academic, but I strongly suspect that swinging a stick at
>>>> textbooks won't get you very far in academics.
>>>>
>>>> Lo and behold, Linz' chapter in fact contains the required caveats that
>>>> I alluded to in my other posts. Did you miss this somehow?
>>>>
>>>> Quote:
>>>>
>>>>    "One may object to Definition 12.1, since we required that, to 
>>>> solve the
>>>>    halting problem, H had to start and end in very specific 
>>>> configurations.
>>>> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>>>>    It is, however, not hard to see that these somewhat arbitrarily 
>>>> chosen
>>>>    conditions play only a  minor role in the argument, and that 
>>>> essentially
>>>>    the same reasoning could be used with any other starting and ending
>>>>    configurations."
>>>>
>>>> You see? This is exactly the sort of thing I'm talking about.  The
>>>> example configurations are only that: they show one simple possibility.
>>>>
>>>> Linz knows that the specific configurations are suceptible to being
>>>> detected by a simple trick.
>>>
>>> It is important to keep in mind what Theorem 12.1 says. It does not 
>>> preclude solving the halting problem for specific cases; often we can 
>>> tell by an analysis of M and w whether or not the Turing machine will 
>>> halt. What the theorem says is that this cannot always be done; there 
>>> is no algorithm that can make a correct decision for all WM and w.
>>>
>>> In other words programs like this can can be decided:
>>> int Add(int X, int Y)
>>> {
>>>    return X + Y;
>>> }
>>>
>>>
>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>>>
>>> My solution applies to: every single instance that matches the above 
>>> pattern thus not any "very specific configuration".
>>>
>>>> His remarks add up to something very similar to what I'm saying about
>>>> how H_Hat can be other configurations that have various decoy code.
>>>>
>>>
>>> I think that the fact that I refuted ALL of the conventional 
>>> pseudo-code representations of the undecidability of the halting 
>>> problem and that the Linz Ĥ matches these patterns is sufficient 
>>> evidence that my findings are of some consequence.
>>>
>>>> Now, since Linz included these words to accompany his proof sketch, you
>>>> cannot write an article which accuses Linz' of promulgating a false
>>>> proof which is susceptible to an attack which targets the specific 
>>>> state
>>>> machine structure in his diagram, such as by stepping the state
>>>> transitions to detect the trivial qa <---> qb cycle.
>>>>
>>>> Every reasonable reviewer will just point you to the above quoted
>>>> paragraph where the author addresses the objection.
>>>
>>> I think that you are misinterpreting those words. I don't think that 
>>> he was saying that his Ĥ pattern (that matches all the pseudo-code 
>>> examples) has a trivial solution. It turns out that the solution is 
>>> relatively trivial yet it took me at least 12,000 hours over 16 years 
>>> to find it. It is only trivial in retrospect.
>>>
>>>> There may be other articles similar to Linz's which don't have these
>>>> caveats; and you can go on a crusade to hunt them down and point out
>>>> the omission. I don't see where that will get you.
>>>
>>> The key thing is that I correctly refuted the entire Ĥ pattern.
>>>
>>> Now that I finally have someone that will not flat out lie in their 
>>> review of my work I am confident that my presentation is clear enough 
>>> to be escalated to the next higher level of review.
>>
>> I believe that every single reviewer says you got it wrong for Linz 
>> style counterexamples. 
> 
> One of these reviewers said that it was utterly dishonest of me to call 
> two identical programs by the same name because these two identical 
> programs are so different from each other.
> 
> Another one of these reviewers never could understand that infinite 
> recursion never ever returns a result to its caller.
> 
> Bottom line is that no one could provide any reasoning showing as many 
> as one single material error in any of my work.
> 
> Besides Kaz and to some degree Malcolm there were only two types of 
> reviewers, those that did not understand what I am saying and those 
> would use dishonest tactics for the purpose of disparagement.
> 
>> since most of these folks are a whole lot smarter than you 
> 
> A guy that cannot possibly understand that infinite recursion never ever 
> returns a result to its caller is certainly not a lot smarter than me.
> He it probably the only one here that does not understand that.
> 
>> as well as more learning flexible, we see that you are the perpetual 
>> butt of Einstein's "Great spirits have always encountered violent 
>> opposition from mediocre minds." Yours is barley mediocre and not very 
>> honest.

All of your above comments just show that you can't yet read for 
comprehension. How do you make it out of grade school?
-- 
Jeff Barnett

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-12-03 19:20 -0600
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<8cqdnVBsFKJ7E1TCnZ2dnUU7-QfNnZ2d@giganews.com>
In reply to#2063
On 12/3/2020 7:13 PM, Jeff Barnett wrote:
> On 12/3/2020 5:31 PM, olcott wrote:
>> On 12/3/2020 6:21 PM, Jeff Barnett wrote:
>>> On 12/3/2020 4:26 PM, olcott wrote:
>>>> On 12/3/2020 4:58 PM, Kaz Kylheku wrote:
>>>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 12/3/2020 2:21 PM, Kaz Kylheku wrote:
>>>>>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> The only one that bothered to provide an accurate review was 
>>>>>>>> Kaz, and he
>>>>>>>> agreed that I did refute Linz.
>>>>>>>
>>>>>>> That I certainly did not; I'm not familiar with all the details 
>>>>>>> of the
>>>>>>> Linz argument.
>>>>>>>
>>>>>>
>>>>>> What you said was equivalent to agreement that I correctly refuted 
>>>>>> the
>>>>>> Linz proof.
>>>>>
>>>>> If so, only coincidentall, not due to knowing specifics about the Linz
>>>>> proof. I did not drop that name at all in my posts.
>>>>>
>>>>>> Here is the whole proof so that you can double check.
>>>>>> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>>>>
>>>>> Right off the bat I see that this is just a chapter in a textbook.
>>>>>
>>>>> I'm not an academic, but I strongly suspect that swinging a stick at
>>>>> textbooks won't get you very far in academics.
>>>>>
>>>>> Lo and behold, Linz' chapter in fact contains the required caveats 
>>>>> that
>>>>> I alluded to in my other posts. Did you miss this somehow?
>>>>>
>>>>> Quote:
>>>>>
>>>>>    "One may object to Definition 12.1, since we required that, to 
>>>>> solve the
>>>>>    halting problem, H had to start and end in very specific 
>>>>> configurations.
>>>>> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>>>>>    It is, however, not hard to see that these somewhat arbitrarily 
>>>>> chosen
>>>>>    conditions play only a  minor role in the argument, and that 
>>>>> essentially
>>>>>    the same reasoning could be used with any other starting and ending
>>>>>    configurations."
>>>>>
>>>>> You see? This is exactly the sort of thing I'm talking about.  The
>>>>> example configurations are only that: they show one simple 
>>>>> possibility.
>>>>>
>>>>> Linz knows that the specific configurations are suceptible to being
>>>>> detected by a simple trick.
>>>>
>>>> It is important to keep in mind what Theorem 12.1 says. It does not 
>>>> preclude solving the halting problem for specific cases; often we 
>>>> can tell by an analysis of M and w whether or not the Turing machine 
>>>> will halt. What the theorem says is that this cannot always be done; 
>>>> there is no algorithm that can make a correct decision for all WM 
>>>> and w.
>>>>
>>>> In other words programs like this can can be decided:
>>>> int Add(int X, int Y)
>>>> {
>>>>    return X + Y;
>>>> }
>>>>
>>>>
>>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
>>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>>>>
>>>> My solution applies to: every single instance that matches the above 
>>>> pattern thus not any "very specific configuration".
>>>>
>>>>> His remarks add up to something very similar to what I'm saying about
>>>>> how H_Hat can be other configurations that have various decoy code.
>>>>>
>>>>
>>>> I think that the fact that I refuted ALL of the conventional 
>>>> pseudo-code representations of the undecidability of the halting 
>>>> problem and that the Linz Ĥ matches these patterns is sufficient 
>>>> evidence that my findings are of some consequence.
>>>>
>>>>> Now, since Linz included these words to accompany his proof sketch, 
>>>>> you
>>>>> cannot write an article which accuses Linz' of promulgating a false
>>>>> proof which is susceptible to an attack which targets the specific 
>>>>> state
>>>>> machine structure in his diagram, such as by stepping the state
>>>>> transitions to detect the trivial qa <---> qb cycle.
>>>>>
>>>>> Every reasonable reviewer will just point you to the above quoted
>>>>> paragraph where the author addresses the objection.
>>>>
>>>> I think that you are misinterpreting those words. I don't think that 
>>>> he was saying that his Ĥ pattern (that matches all the pseudo-code 
>>>> examples) has a trivial solution. It turns out that the solution is 
>>>> relatively trivial yet it took me at least 12,000 hours over 16 
>>>> years to find it. It is only trivial in retrospect.
>>>>
>>>>> There may be other articles similar to Linz's which don't have these
>>>>> caveats; and you can go on a crusade to hunt them down and point out
>>>>> the omission. I don't see where that will get you.
>>>>
>>>> The key thing is that I correctly refuted the entire Ĥ pattern.
>>>>
>>>> Now that I finally have someone that will not flat out lie in their 
>>>> review of my work I am confident that my presentation is clear 
>>>> enough to be escalated to the next higher level of review.
>>>
>>> I believe that every single reviewer says you got it wrong for Linz 
>>> style counterexamples. 
>>
>> One of these reviewers said that it was utterly dishonest of me to 
>> call two identical programs by the same name because these two 
>> identical programs are so different from each other.
>>
>> Another one of these reviewers never could understand that infinite 
>> recursion never ever returns a result to its caller.
>>
>> Bottom line is that no one could provide any reasoning showing as many 
>> as one single material error in any of my work.
>>
>> Besides Kaz and to some degree Malcolm there were only two types of 
>> reviewers, those that did not understand what I am saying and those 
>> would use dishonest tactics for the purpose of disparagement.
>>
>>> since most of these folks are a whole lot smarter than you 
>>
>> A guy that cannot possibly understand that infinite recursion never 
>> ever returns a result to its caller is certainly not a lot smarter 
>> than me.
>> He it probably the only one here that does not understand that.
>>
>>> as well as more learning flexible, we see that you are the perpetual 
>>> butt of Einstein's "Great spirits have always encountered violent 
>>> opposition from mediocre minds." Yours is barley mediocre and not 
>>> very honest.
> 
> All of your above comments just show that you can't yet read for 
> comprehension. How do you make it out of grade school?

You are always very vague because you either know that I have not made 
any logical errors or this stuff is simply over your head.

-- 
Copyright 2020 Pete Olcott

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

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-04 00:26 +0000
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<20201203161127.817@kylheku.com>
In reply to#2057
["Followup-To:" header set to comp.theory.]
On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
> On 12/3/2020 4:58 PM, Kaz Kylheku wrote:
>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>> On 12/3/2020 2:21 PM, Kaz Kylheku wrote:
>>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>>> The only one that bothered to provide an accurate review was Kaz, and he
>>>>> agreed that I did refute Linz.
>>>>
>>>> That I certainly did not; I'm not familiar with all the details of the
>>>> Linz argument.
>>>>
>>>
>>> What you said was equivalent to agreement that I correctly refuted the
>>> Linz proof.
>> 
>> If so, only coincidentall, not due to knowing specifics about the Linz
>> proof. I did not drop that name at all in my posts.
>> 
>>> Here is the whole proof so that you can double check.
>>> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>> 
>> Right off the bat I see that this is just a chapter in a textbook.
>> 
>> I'm not an academic, but I strongly suspect that swinging a stick at
>> textbooks won't get you very far in academics.
>> 
>> Lo and behold, Linz' chapter in fact contains the required caveats that
>> I alluded to in my other posts. Did you miss this somehow?
>> 
>> Quote:
>> 
>>    "One may object to Definition 12.1, since we required that, to solve the
>>    halting problem, H had to start and end in very specific configurations.
>>                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>>    It is, however, not hard to see that these somewhat arbitrarily chosen
>>    conditions play only a  minor role in the argument, and that essentially
>>    the same reasoning could be used with any other starting and ending
>>    configurations."
>> 
>> You see? This is exactly the sort of thing I'm talking about.  The
>> example configurations are only that: they show one simple possibility.
>> 
>> Linz knows that the specific configurations are suceptible to being
>> detected by a simple trick.
>
> It is important to keep in mind what Theorem 12.1 says. It does not 
> preclude solving the halting problem for specific cases; often we can 

Well, ther is no "halting problem for specific cases". The halting
problem is that there is no universal halting decision procedure for
all cases.

We can have a decision procedure that handles just one case, and is
often wrong (or fails to halt) when given anything else.  That has
little to do with the halting problem.

> tell by an analysis of M and w whether or not the Turing machine will 
> halt. What the theorem says is that this cannot always be done; there is 
> no algorithm that can make a correct decision for all WM and w.
>
> In other words programs like this can can be decided:
> int Add(int X, int Y)
> {
>    return X + Y;
> }
>
>
> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>
> My solution applies to: every single instance that matches the above 
> pattern thus not any "very specific configuration".
>
>> His remarks add up to something very similar to what I'm saying about
>> how H_Hat can be other configurations that have various decoy code.
>> 
>
> I think that the fact that I refuted ALL of the conventional pseudo-code 
> representations of the undecidability of the halting problem and that 
> the Linz Ĥ matches these patterns is sufficient evidence that my 
> findings are of some consequence.
>
>> Now, since Linz included these words to accompany his proof sketch, you
>> cannot write an article which accuses Linz' of promulgating a false
>> proof which is susceptible to an attack which targets the specific state
>> machine structure in his diagram, such as by stepping the state
>> transitions to detect the trivial qa <---> qb cycle.
>> 
>> Every reasonable reviewer will just point you to the above quoted
>> paragraph where the author addresses the objection.
>
> I think that you are misinterpreting those words.

I doh't believe that I am, but I will also give you this: those words
are in fact hand-waving. The chapter is not a completely rigorous
treatment of halting. The idea is hinted at that we can generalize
things by adjusting the configuration in arbitrary ways in order to
defeat any proposed halting decider; but that is something that needs to
be proven. What if you cannot always do that? Still, Linz paragraph is
enough to get him off the hook; we can't accuse him of perpetrating the
idea that the one pattern for generating the defeating machine is all
that is required, QED.

> I don't think that he 
> was saying that his Ĥ pattern (that matches all the pseudo-code 
> examples) has a trivial solution. It turns out that the solution is 
> relatively trivial yet it took me at least 12,000 hours over 16 years to 
> find it. It is only trivial in retrospect.

OK, you're an unsung genius who spotted runaway recursion between
several functions (which call each other unconditionally before doing
anything else) and built a trap to catch it.

Suit yourself.

>> There may be other articles similar to Linz's which don't have these
>> caveats; and you can go on a crusade to hunt them down and point out
>> the omission. I don't see where that will get you.
>
> The key thing is that I correctly refuted the entire Ĥ pattern.

Yes, but Linz anticipates your objection to the fixed pattern.

He does so with a hand-waving argument, but he does so.

> Now that I finally have someone that will not flat out lie in their 
> review of my work I am confident that my presentation is clear enough to 
> be escalated to the next higher level of review.

Sure, go for it.

-- 
TXR Programming Language: http://nongnu.org/txr
Music DIY Mailing List:  http://www.kylheku.com/diy
ADA MP-1 Mailing List:   http://www.kylheku.com/mp1

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-12-03 18:40 -0600
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<pcqdnYJ5z_XpGFTCnZ2dnUU7-YHNnZ2d@giganews.com>
In reply to#2059
On 12/3/2020 6:26 PM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>> On 12/3/2020 4:58 PM, Kaz Kylheku wrote:
>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>> On 12/3/2020 2:21 PM, Kaz Kylheku wrote:
>>>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>>>> The only one that bothered to provide an accurate review was Kaz, and he
>>>>>> agreed that I did refute Linz.
>>>>>
>>>>> That I certainly did not; I'm not familiar with all the details of the
>>>>> Linz argument.
>>>>>
>>>>
>>>> What you said was equivalent to agreement that I correctly refuted the
>>>> Linz proof.
>>>
>>> If so, only coincidentall, not due to knowing specifics about the Linz
>>> proof. I did not drop that name at all in my posts.
>>>
>>>> Here is the whole proof so that you can double check.
>>>> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>>
>>> Right off the bat I see that this is just a chapter in a textbook.
>>>
>>> I'm not an academic, but I strongly suspect that swinging a stick at
>>> textbooks won't get you very far in academics.
>>>
>>> Lo and behold, Linz' chapter in fact contains the required caveats that
>>> I alluded to in my other posts. Did you miss this somehow?
>>>
>>> Quote:
>>>
>>>     "One may object to Definition 12.1, since we required that, to solve the
>>>     halting problem, H had to start and end in very specific configurations.
>>>                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>>>     It is, however, not hard to see that these somewhat arbitrarily chosen
>>>     conditions play only a  minor role in the argument, and that essentially
>>>     the same reasoning could be used with any other starting and ending
>>>     configurations."
>>>
>>> You see? This is exactly the sort of thing I'm talking about.  The
>>> example configurations are only that: they show one simple possibility.
>>>
>>> Linz knows that the specific configurations are suceptible to being
>>> detected by a simple trick.
>>
>> It is important to keep in mind what Theorem 12.1 says. It does not
>> preclude solving the halting problem for specific cases; often we can
> 
> Well, ther is no "halting problem for specific cases". The halting
> problem is that there is no universal halting decision procedure for
> all cases.

Although I agree that was a direct quote from Linz.

> We can have a decision procedure that handles just one case, and is
> often wrong (or fails to halt) when given anything else.  That has
> little to do with the halting problem.
> 
>> tell by an analysis of M and w whether or not the Turing machine will
>> halt. What the theorem says is that this cannot always be done; there is
>> no algorithm that can make a correct decision for all WM and w.
>>
>> In other words programs like this can can be decided:
>> int Add(int X, int Y)
>> {
>>     return X + Y;
>> }
>>
>>
>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>>
>> My solution applies to: every single instance that matches the above
>> pattern thus not any "very specific configuration".
>>
>>> His remarks add up to something very similar to what I'm saying about
>>> how H_Hat can be other configurations that have various decoy code.
>>>
>>
>> I think that the fact that I refuted ALL of the conventional pseudo-code
>> representations of the undecidability of the halting problem and that
>> the Linz Ĥ matches these patterns is sufficient evidence that my
>> findings are of some consequence.
>>
>>> Now, since Linz included these words to accompany his proof sketch, you
>>> cannot write an article which accuses Linz' of promulgating a false
>>> proof which is susceptible to an attack which targets the specific state
>>> machine structure in his diagram, such as by stepping the state
>>> transitions to detect the trivial qa <---> qb cycle.
>>>
>>> Every reasonable reviewer will just point you to the above quoted
>>> paragraph where the author addresses the objection.
>>
>> I think that you are misinterpreting those words.
> 
> I doh't believe that I am, but I will also give you this: those words
> are in fact hand-waving. The chapter is not a completely rigorous
> treatment of halting. The idea is hinted at that we can generalize
> things by adjusting the configuration in arbitrary ways in order to
> defeat any proposed halting decider; but that is something that needs to
> be proven. What if you cannot always do that? Still, Linz paragraph is
> enough to get him off the hook; we can't accuse him of perpetrating the
> idea that the one pattern for generating the defeating machine is all
> that is required, QED.
> 
>> I don't think that he
>> was saying that his Ĥ pattern (that matches all the pseudo-code
>> examples) has a trivial solution. It turns out that the solution is
>> relatively trivial yet it took me at least 12,000 hours over 16 years to
>> find it. It is only trivial in retrospect.
> 
> OK, you're an unsung genius who spotted runaway recursion between
> several functions (which call each other unconditionally before doing
> anything else) and built a trap to catch it.
> 
> Suit yourself.
> 
>>> There may be other articles similar to Linz's which don't have these
>>> caveats; and you can go on a crusade to hunt them down and point out
>>> the omission. I don't see where that will get you.
>>
>> The key thing is that I correctly refuted the entire Ĥ pattern.
> 
> Yes, but Linz anticipates your objection to the fixed pattern.

I do not accept that.
Every pseudo-code example is based on this same pattern.

> He does so with a hand-waving argument, but he does so.
> 
>> Now that I finally have someone that will not flat out lie in their
>> review of my work I am confident that my presentation is clear enough to
>> be escalated to the next higher level of review.
> 
> Sure, go for it.
> 

My threshold was to have one person totally understand what I am saying, 
it is really great that I found at least one person that both knows the 
material and is not a liar.

The same reasoning that I used in this proof equally applies to refuting 
the 1931 incompleteness theorem. It is based on the exact same 
paradoxical reasoning.

-- 
Copyright 2020 Pete Olcott

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

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-04 01:17 +0000
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<20201203170126.362@kylheku.com>
In reply to#2062
On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
> On 12/3/2020 6:26 PM, Kaz Kylheku wrote:
>> ["Followup-To:" header set to comp.theory.]
>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>> The key thing is that I correctly refuted the entire Ĥ pattern.
>> 
>> Yes, but Linz anticipates your objection to the fixed pattern.
>
> I do not accept that.

But he acknowledges the objection. He is granting that it's right,
with regard to that specific configuration given in the diagram!

Again:

Linz: "One may object to Definition 12.1, since we required that, to
solve the halting problem, H had to start and end in very specific
configurations."

Translation: one may legimately object to the use of a specific
configuration; one would be right to do so.

Linz: "It is, however, not hard to see that these somewhat arbitrarily
chosen conditions play only a  minor role in the argument, and that
essentially the same reasoning could be used with any other starting and
ending configurations."

Translation: but believing that the argument rests on just that
configuration is a strawman; an infinity of configurations of arbitrary
complexity is possible. The specific configuration is not to be mistaken
for the technique, which is more general.

Linz: "We have tied the problem to a specific definition for
the sake of the discussion, but this does not affect the conclusion.

Translation: I'm writing an accessible textbook here, in which
computability is a small chapter; give me a friggin' break.

> Every pseudo-code example is based on this same pattern.

But now you're not talking about Linz any more.  I don't see any
pseudo-code in this chapter, only bubble-and-arrow state diagrams,
so your remark cannot be about Linz.

You're making a statement about what other alleged authors are
doing in their own articles.

For any such article, whether it uses state diagrams or pseudo code, we
have to read that specific article and see if it leaves any holes
that it neglects to cover with hand-waving arguments, as Linz has
so assiduously done.

-- 
TXR Programming Language: http://nongnu.org/txr
Music DIY Mailing List:  http://www.kylheku.com/diy
ADA MP-1 Mailing List:   http://www.kylheku.com/mp1

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-12-03 19:39 -0600
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<-eWdnRvDTb33DlTCnZ2dnUU7-anNnZ2d@giganews.com>
In reply to#2064
On 12/3/2020 7:17 PM, Kaz Kylheku wrote:
> On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
>> On 12/3/2020 6:26 PM, Kaz Kylheku wrote:
>>> ["Followup-To:" header set to comp.theory.]
>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>> The key thing is that I correctly refuted the entire Ĥ pattern.
>>>
>>> Yes, but Linz anticipates your objection to the fixed pattern.
>>
>> I do not accept that.
> 
> But he acknowledges the objection. He is granting that it's right,
> with regard to that specific configuration given in the diagram!
> 
> Again:
> 
> Linz: "One may object to Definition 12.1, since we required that, to
> solve the halting problem, H had to start and end in very specific
> configurations."

I don't see this.
The specific configuration is that the halt decider begins executing at 
its beginning and ends with a yes or no answer. This is categorically 
every possibly correct configuration.

It only excludes things like the halt decider beginning to execute at 
its end and halting in a final state of H.maybe.

> Translation: one may legimately object to the use of a specific
> configuration; one would be right to do so.
> 
> Linz: "It is, however, not hard to see that these somewhat arbitrarily
> chosen conditions play only a  minor role in the argument, and that
> essentially the same reasoning could be used with any other starting and
> ending configurations."
> 
> Translation: but believing that the argument rests on just that
> configuration is a strawman; an infinity of configurations of arbitrary
> complexity is possible. The specific configuration is not to be mistaken
> for the technique, which is more general.

Yet complexity does not equate with undecidability. That solving a 
problem is difficult is not at all the same as impossible.

> Linz: "We have tied the problem to a specific definition for
> the sake of the discussion, but this does not affect the conclusion.
> 
> Translation: I'm writing an accessible textbook here, in which
> computability is a small chapter; give me a friggin' break.
> 
>> Every pseudo-code example is based on this same pattern.
> 
> But now you're not talking about Linz any more.  I don't see any
> pseudo-code in this chapter, only bubble-and-arrow state diagrams,
> so your remark cannot be about Linz.

It is the exact same pattern of defining an input that does the opposite 
whatever the halt decider decides. I am unaware of any other pattern of 
conventional halting problem undecidability proofs.

> You're making a statement about what other alleged authors are
> doing in their own articles.

Sipser uses this same basic approach.

> For any such article, whether it uses state diagrams or pseudo code, we
> have to read that specific article and see if it leaves any holes
> that it neglects to cover with hand-waving arguments, as Linz has
> so assiduously done.
> 


-- 
Copyright 2020 Pete Olcott

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

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-04 19:31 +0000
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<20201204111142.427@kylheku.com>
In reply to#2066
On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
> On 12/3/2020 7:17 PM, Kaz Kylheku wrote:
>> On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
>>> On 12/3/2020 6:26 PM, Kaz Kylheku wrote:
>>>> ["Followup-To:" header set to comp.theory.]
>>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>>> The key thing is that I correctly refuted the entire Ĥ pattern.
>>>>
>>>> Yes, but Linz anticipates your objection to the fixed pattern.
>>>
>>> I do not accept that.
>> 
>> But he acknowledges the objection. He is granting that it's right,
>> with regard to that specific configuration given in the diagram!
>> 
>> Again:
>> 
>> Linz: "One may object to Definition 12.1, since we required that, to
>> solve the halting problem, H had to start and end in very specific
>> configurations."
>
> I don't see this.
> The specific configuration is that the halt decider begins executing at 
> its beginning and ends with a yes or no answer. This is categorically 
> every possibly correct configuration.

By "configuration", I'm almost certain that Linz is referring to the
entire structure of his Figure 12.2, and not simply to its initial and
final states. He's not using the word "configuration" in the restricted
sense of "application configuration settings", which refer only to the
mutable state parts. It refers to the all parts and how they fit
together; the formation.

He's saying: "Don't mistake the shape of that example for the technique.
The example is not the technique.  The intended application of the
technique is the generation of an infinite variety of such structures."

In other words, Linz obviously knows well that a fixed pattern for
fooling a halting decider is not sufficient. He's dealing with that very
objection. (He may not be doing it rigrously and with a full treatment,
but he's fully covered himself against accusations of ignorance or
neglect.)

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-12-04 13:49 -0600
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<RbednaAy34BfD1fCnZ2dnUU7-UXNnZ2d@giganews.com>
In reply to#2076
On 12/4/2020 1:31 PM, Kaz Kylheku wrote:
> On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
>> On 12/3/2020 7:17 PM, Kaz Kylheku wrote:
>>> On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
>>>> On 12/3/2020 6:26 PM, Kaz Kylheku wrote:
>>>>> ["Followup-To:" header set to comp.theory.]
>>>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>>>> The key thing is that I correctly refuted the entire Ĥ pattern.
>>>>>
>>>>> Yes, but Linz anticipates your objection to the fixed pattern.
>>>>
>>>> I do not accept that.
>>>
>>> But he acknowledges the objection. He is granting that it's right,
>>> with regard to that specific configuration given in the diagram!
>>>
>>> Again:
>>>
>>> Linz: "One may object to Definition 12.1, since we required that, to
>>> solve the halting problem, H had to start and end in very specific
>>> configurations."
>>
>> I don't see this.
>> The specific configuration is that the halt decider begins executing at
>> its beginning and ends with a yes or no answer. This is categorically
>> every possibly correct configuration.
> 
> By "configuration", I'm almost certain that Linz is referring to the
> entire structure of his Figure 12.2, and not simply to its initial and
> final states. He's not using the word "configuration" in the restricted
> sense of "application configuration settings", which refer only to the
> mutable state parts. It refers to the all parts and how they fit
> together; the formation.
> 
> He's saying: "Don't mistake the shape of that example for the technique.
> The example is not the technique.  The intended application of the
> technique is the generation of an infinite variety of such structures."
> 
> In other words, Linz obviously knows well that a fixed pattern for
> fooling a halting decider is not sufficient. He's dealing with that very
> objection. (He may not be doing it rigrously and with a full treatment,
> but he's fully covered himself against accusations of ignorance or
> neglect.)
> 

The same pattern of doing the opposite of whatever the halt decider 
decides is the same pattern of the liar paradox (if it is true that 
makes it untrue) and the pattern of the 1931 incompleteness theorem if 
you can prove that a sentence asserting its own unprovability is 
provable is indeed unprovable then this contradicts its assertion making 
it untrue.

-- 
Copyright 2020 Pete Olcott

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

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-04 21:19 +0000
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<20201204130213.429@kylheku.com>
In reply to#2078
["Followup-To:" header set to comp.theory.]
On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
> On 12/4/2020 1:31 PM, Kaz Kylheku wrote:
>> On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
>>> On 12/3/2020 7:17 PM, Kaz Kylheku wrote:
>>>> On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 12/3/2020 6:26 PM, Kaz Kylheku wrote:
>>>>>> ["Followup-To:" header set to comp.theory.]
>>>>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> The key thing is that I correctly refuted the entire Ĥ pattern.
>>>>>>
>>>>>> Yes, but Linz anticipates your objection to the fixed pattern.
>>>>>
>>>>> I do not accept that.
>>>>
>>>> But he acknowledges the objection. He is granting that it's right,
>>>> with regard to that specific configuration given in the diagram!
>>>>
>>>> Again:
>>>>
>>>> Linz: "One may object to Definition 12.1, since we required that, to
>>>> solve the halting problem, H had to start and end in very specific
>>>> configurations."
>>>
>>> I don't see this.
>>> The specific configuration is that the halt decider begins executing at
>>> its beginning and ends with a yes or no answer. This is categorically
>>> every possibly correct configuration.
>> 
>> By "configuration", I'm almost certain that Linz is referring to the
>> entire structure of his Figure 12.2, and not simply to its initial and
>> final states. He's not using the word "configuration" in the restricted
>> sense of "application configuration settings", which refer only to the
>> mutable state parts. It refers to the all parts and how they fit
>> together; the formation.
>> 
>> He's saying: "Don't mistake the shape of that example for the technique.
>> The example is not the technique.  The intended application of the
>> technique is the generation of an infinite variety of such structures."
>> 
>> In other words, Linz obviously knows well that a fixed pattern for
>> fooling a halting decider is not sufficient. He's dealing with that very
>> objection. (He may not be doing it rigrously and with a full treatment,
>> but he's fully covered himself against accusations of ignorance or
>> neglect.)
>> 
>
> The same pattern of doing the opposite of whatever the halt decider 
> decides is the same pattern of the liar paradox (if it is true that 
> makes it untrue) and the pattern of the 1931 incompleteness theorem if 
> you can prove that a sentence asserting its own unprovability is 
> provable is indeed unprovable then this contradicts its assertion making 
> it untrue.

I don't see how this paragraph speaks to Linz, or your current program
of showing that a static patterns is inadequate for defeating all
proposed halting deciders (and thus for showing that halting is
undecidable).

(All the ideas you allude to can be embodied in an endless variety of
concrete patterns, but that's neither here nor here.)

-- 
TXR Programming Language: http://nongnu.org/txr
Music DIY Mailing List:  http://www.kylheku.com/diy
ADA MP-1 Mailing List:   http://www.kylheku.com/mp1

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-12-04 15:43 -0600
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<TZGdnRhVDt0GMFfCnZ2dnUU7-U3NnZ2d@giganews.com>
In reply to#2080
On 12/4/2020 3:19 PM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
>> On 12/4/2020 1:31 PM, Kaz Kylheku wrote:
>>> On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
>>>> On 12/3/2020 7:17 PM, Kaz Kylheku wrote:
>>>>> On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 12/3/2020 6:26 PM, Kaz Kylheku wrote:
>>>>>>> ["Followup-To:" header set to comp.theory.]
>>>>>>> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> The key thing is that I correctly refuted the entire Ĥ pattern.
>>>>>>>
>>>>>>> Yes, but Linz anticipates your objection to the fixed pattern.
>>>>>>
>>>>>> I do not accept that.
>>>>>
>>>>> But he acknowledges the objection. He is granting that it's right,
>>>>> with regard to that specific configuration given in the diagram!
>>>>>
>>>>> Again:
>>>>>
>>>>> Linz: "One may object to Definition 12.1, since we required that, to
>>>>> solve the halting problem, H had to start and end in very specific
>>>>> configurations."
>>>>
>>>> I don't see this.
>>>> The specific configuration is that the halt decider begins executing at
>>>> its beginning and ends with a yes or no answer. This is categorically
>>>> every possibly correct configuration.
>>>
>>> By "configuration", I'm almost certain that Linz is referring to the
>>> entire structure of his Figure 12.2, and not simply to its initial and
>>> final states. He's not using the word "configuration" in the restricted
>>> sense of "application configuration settings", which refer only to the
>>> mutable state parts. It refers to the all parts and how they fit
>>> together; the formation.
>>>
>>> He's saying: "Don't mistake the shape of that example for the technique.
>>> The example is not the technique.  The intended application of the
>>> technique is the generation of an infinite variety of such structures."
>>>
>>> In other words, Linz obviously knows well that a fixed pattern for
>>> fooling a halting decider is not sufficient. He's dealing with that very
>>> objection. (He may not be doing it rigrously and with a full treatment,
>>> but he's fully covered himself against accusations of ignorance or
>>> neglect.)
>>>
>>
>> The same pattern of doing the opposite of whatever the halt decider
>> decides is the same pattern of the liar paradox (if it is true that
>> makes it untrue) and the pattern of the 1931 incompleteness theorem if
>> you can prove that a sentence asserting its own unprovability is
>> provable is indeed unprovable then this contradicts its assertion making
>> it untrue.
> 
> I don't see how this paragraph speaks to Linz, or your current program
> of showing that a static patterns is inadequate for defeating all
> proposed halting deciders (and thus for showing that halting is
> undecidable).

(a) This sentence is not true.
(b) This sentence cannot be proven.
(c) This computation (prior to my solution)

void H_Hat(u32 P)
{
   u32 Input_Halted = Halts(P, P);
   if (!Input_Halted)
     HALT
   else
    HERE: goto HERE;
}

All have the same thing in common if they are true (if Halts returns 
true) that makes them false.


> (All the ideas you allude to can be embodied in an endless variety of
> concrete patterns, but that's neither here nor here.)
> 


-- 
Copyright 2020 Pete Olcott

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-12-04 20:38 -0600
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<hd6dnYblCoAKb1fCnZ2dnUU7-KnNnZ2d@giganews.com>
In reply to#2078
On 12/4/2020 7:59 PM, Kaz Kylheku wrote:
> On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
>> On 12/4/2020 4:18 PM, Richard Damon wrote:
>>> On 12/4/20 2:49 PM, olcott wrote:
>>>
>>>> The same pattern of doing the opposite of whatever the halt decider
>>>> decides is the same pattern of the liar paradox (if it is true that
>>>> makes it untrue) and the pattern of the 1931 incompleteness theorem if
>>>> you can prove that a sentence asserting its own unprovability is
>>>> provable is indeed unprovable then this contradicts its assertion making
>>>> it untrue.
>>>>
>>>
>>> Actually, Linz H^ is different than the Liar's Paradox.
>>>
>>> The statement: "This Statement is False"
>>>
>>> Can not be assigned a truth value, as it is logically contradictory,
>>
>> In this exact same way Halts cannot return a correct halting decision to
>> H_Hat, both {true, false} are incorrect return values to H_Hat.
> 
> - The Liar Paradox *does not* have a valid interpretation of its truth
>    value.
> 
>    That's a statement about reality.
> 
> - Halts *cannot* return a correct value, sure
> 
>    That's a statement about a fantasy: the wish to have it return a correct
>    value, which doesn't come true.
> 
>    Halts in fact *does* return a specific, and that value is wrong.
> 
>    There is no paradox.
> 

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:
Number of Instructions Executed(2777)

-- 
Copyright 2020 Pete Olcott

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

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-05 03:55 +0000
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<20201204195042.869@kylheku.com>
In reply to#2084
["Followup-To:" header set to comp.theory.]
On 2020-12-05, olcott <NoOne@NoWhere.com> wrote:
> On 12/4/2020 7:59 PM, Kaz Kylheku wrote:
>> On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
>>> On 12/4/2020 4:18 PM, Richard Damon wrote:
>>>> On 12/4/20 2:49 PM, olcott wrote:
>>>>
>>>>> The same pattern of doing the opposite of whatever the halt decider
>>>>> decides is the same pattern of the liar paradox (if it is true that
>>>>> makes it untrue) and the pattern of the 1931 incompleteness theorem if
>>>>> you can prove that a sentence asserting its own unprovability is
>>>>> provable is indeed unprovable then this contradicts its assertion making
>>>>> it untrue.
>>>>>
>>>>
>>>> Actually, Linz H^ is different than the Liar's Paradox.
>>>>
>>>> The statement: "This Statement is False"
>>>>
>>>> Can not be assigned a truth value, as it is logically contradictory,
>>>
>>> In this exact same way Halts cannot return a correct halting decision to
>>> H_Hat, both {true, false} are incorrect return values to H_Hat.
>> 
>> - The Liar Paradox *does not* have a valid interpretation of its truth
>>    value.
>> 
>>    That's a statement about reality.
>> 
>> - Halts *cannot* return a correct value, sure
>> 
>>    That's a statement about a fantasy: the wish to have it return a correct
>>    value, which doesn't come true.
>> 
>>    Halts in fact *does* return a specific, and that value is wrong.
>> 
>>    There is no paradox.
>> 
>
> 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;
> }
>
> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
> Number of Instructions Executed(2777)

Here, H_Hat has not terminated. Yet, H has not returned the correct
value to indicate this. The whole show simply stopped.

Therefore H did not decide anything.

H must terminate by returning normally with a return value that
is true or false.

You need a program like this:

  int main()
  {
     if (H((u32)H_Hat, (u32)H_Hat)) {
        puts("H_Hat(H_Hat) halts!");
     } else {
        puts("H_Hat(H_Hat) does not hal!");
     }

     return 0;
  }

This program must terminate, having printed either one of the two
messages. If it does so, then it is deemed to have successfully decided.

If it fails to terminate, then it has not decided.

If it crashes for any reason (division by zero, segmenation fault,
or "Instruction Specifies Infinite Recursion", then it has not decided.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-12-04 22:13 -0600
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<4rydnZ7uPrNplVbCnZ2dnUU7-aXNnZ2d@giganews.com>
In reply to#2086
On 12/4/2020 9:55 PM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2020-12-05, olcott <NoOne@NoWhere.com> wrote:
>> On 12/4/2020 7:59 PM, Kaz Kylheku wrote:
>>> On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
>>>> On 12/4/2020 4:18 PM, Richard Damon wrote:
>>>>> On 12/4/20 2:49 PM, olcott wrote:
>>>>>
>>>>>> The same pattern of doing the opposite of whatever the halt decider
>>>>>> decides is the same pattern of the liar paradox (if it is true that
>>>>>> makes it untrue) and the pattern of the 1931 incompleteness theorem if
>>>>>> you can prove that a sentence asserting its own unprovability is
>>>>>> provable is indeed unprovable then this contradicts its assertion making
>>>>>> it untrue.
>>>>>>
>>>>>
>>>>> Actually, Linz H^ is different than the Liar's Paradox.
>>>>>
>>>>> The statement: "This Statement is False"
>>>>>
>>>>> Can not be assigned a truth value, as it is logically contradictory,
>>>>
>>>> In this exact same way Halts cannot return a correct halting decision to
>>>> H_Hat, both {true, false} are incorrect return values to H_Hat.
>>>
>>> - The Liar Paradox *does not* have a valid interpretation of its truth
>>>     value.
>>>
>>>     That's a statement about reality.
>>>
>>> - Halts *cannot* return a correct value, sure
>>>
>>>     That's a statement about a fantasy: the wish to have it return a correct
>>>     value, which doesn't come true.
>>>
>>>     Halts in fact *does* return a specific, and that value is wrong.
>>>
>>>     There is no paradox.
>>>
>>
>> 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;
>> }
>>
>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>> Number of Instructions Executed(2777)
> 
> Here, H_Hat has not terminated. Yet, H has not returned the correct
> value to indicate this. The whole show simply stopped.
> 
> Therefore H did not decide anything.
> 
> H must terminate by returning normally with a return value that
> is true or false.
> 
> You need a program like this:
> 
>    int main()
>    {
>       if (H((u32)H_Hat, (u32)H_Hat)) {
>          puts("H_Hat(H_Hat) halts!");
>       } else {
>          puts("H_Hat(H_Hat) does not hal!");
>       }
> 
>       return 0;
>    }
> 
> This program must terminate, having printed either one of the two
> messages. If it does so, then it is deemed to have successfully decided.

I am working on this. This is actually just window dressing.
It is a little tricky unwinding recursion cleanly.

My execution trace already proved that Halts(H_Hat, H_Hat) is decidable.
I wonder if Ben will ever acknowledge that I did what I said that I would.

Basically I am just biding my time here until I complete the enhancement 
that you suggest. I have been working on this for a few days now. x86utm 
is a multi-tasking operating system and I captured the data that I need 
for the context switch to provide the above result. I haven't got this 
working yet.

-- 
Copyright 2020 Pete Olcott

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

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


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

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2020-12-04 20:47 -0800
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<rqf3dg$9n3$1@gioia.aioe.org>
In reply to#2087
On 12/4/2020 8:13 PM, olcott wrote:
> On 12/4/2020 9:55 PM, Kaz Kylheku wrote:
>> ["Followup-To:" header set to comp.theory.]
>> On 2020-12-05, olcott <NoOne@NoWhere.com> wrote:
>>> On 12/4/2020 7:59 PM, Kaz Kylheku wrote:
>>>> On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 12/4/2020 4:18 PM, Richard Damon wrote:
>>>>>> On 12/4/20 2:49 PM, olcott wrote:
>>>>>>
>>>>>>> The same pattern of doing the opposite of whatever the halt decider
>>>>>>> decides is the same pattern of the liar paradox (if it is true that
>>>>>>> makes it untrue) and the pattern of the 1931 incompleteness 
>>>>>>> theorem if
>>>>>>> you can prove that a sentence asserting its own unprovability is
>>>>>>> provable is indeed unprovable then this contradicts its assertion 
>>>>>>> making
>>>>>>> it untrue.
>>>>>>>
>>>>>>
>>>>>> Actually, Linz H^ is different than the Liar's Paradox.
>>>>>>
>>>>>> The statement: "This Statement is False"
>>>>>>
>>>>>> Can not be assigned a truth value, as it is logically contradictory,
>>>>>
>>>>> In this exact same way Halts cannot return a correct halting 
>>>>> decision to
>>>>> H_Hat, both {true, false} are incorrect return values to H_Hat.
>>>>
>>>> - The Liar Paradox *does not* have a valid interpretation of its truth
>>>>     value.
>>>>
>>>>     That's a statement about reality.
>>>>
>>>> - Halts *cannot* return a correct value, sure
>>>>
>>>>     That's a statement about a fantasy: the wish to have it return a 
>>>> correct
>>>>     value, which doesn't come true.
>>>>
>>>>     Halts in fact *does* return a specific, and that value is wrong.
>>>>
>>>>     There is no paradox.
>>>>
>>>
>>> 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;
>>> }
>>>
>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>> Number of Instructions Executed(2777)
>>
>> Here, H_Hat has not terminated. Yet, H has not returned the correct
>> value to indicate this. The whole show simply stopped.
>>
>> Therefore H did not decide anything.
>>
>> H must terminate by returning normally with a return value that
>> is true or false.
>>
>> You need a program like this:
>>
>>    int main()
>>    {
>>       if (H((u32)H_Hat, (u32)H_Hat)) {
>>          puts("H_Hat(H_Hat) halts!");
>>       } else {
>>          puts("H_Hat(H_Hat) does not hal!");
>>       }
>>
>>       return 0;
>>    }
>>
>> This program must terminate, having printed either one of the two
>> messages. If it does so, then it is deemed to have successfully decided.
> 
> I am working on this. This is actually just window dressing.
> It is a little tricky unwinding recursion cleanly.
[...]

Has your window been splashed with black paint? Can it tell if an 
unknown function halts? I say, hell no.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2020-12-04 22:55 -0600
SubjectRe: Halting test example [ Correct refutation of Peter Linz proof ](Kaz)
Message-ID<UeydnZ6NPuJej1bCnZ2dnUU7-KWdnZ2d@giganews.com>
In reply to#2088
On 12/4/2020 10:47 PM, Chris M. Thomasson wrote:
> On 12/4/2020 8:13 PM, olcott wrote:
>> On 12/4/2020 9:55 PM, Kaz Kylheku wrote:
>>> ["Followup-To:" header set to comp.theory.]
>>> On 2020-12-05, olcott <NoOne@NoWhere.com> wrote:
>>>> On 12/4/2020 7:59 PM, Kaz Kylheku wrote:
>>>>> On 2020-12-04, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 12/4/2020 4:18 PM, Richard Damon wrote:
>>>>>>> On 12/4/20 2:49 PM, olcott wrote:
>>>>>>>
>>>>>>>> The same pattern of doing the opposite of whatever the halt decider
>>>>>>>> decides is the same pattern of the liar paradox (if it is true that
>>>>>>>> makes it untrue) and the pattern of the 1931 incompleteness 
>>>>>>>> theorem if
>>>>>>>> you can prove that a sentence asserting its own unprovability is
>>>>>>>> provable is indeed unprovable then this contradicts its 
>>>>>>>> assertion making
>>>>>>>> it untrue.
>>>>>>>>
>>>>>>>
>>>>>>> Actually, Linz H^ is different than the Liar's Paradox.
>>>>>>>
>>>>>>> The statement: "This Statement is False"
>>>>>>>
>>>>>>> Can not be assigned a truth value, as it is logically contradictory,
>>>>>>
>>>>>> In this exact same way Halts cannot return a correct halting 
>>>>>> decision to
>>>>>> H_Hat, both {true, false} are incorrect return values to H_Hat.
>>>>>
>>>>> - The Liar Paradox *does not* have a valid interpretation of its truth
>>>>>     value.
>>>>>
>>>>>     That's a statement about reality.
>>>>>
>>>>> - Halts *cannot* return a correct value, sure
>>>>>
>>>>>     That's a statement about a fantasy: the wish to have it return 
>>>>> a correct
>>>>>     value, which doesn't come true.
>>>>>
>>>>>     Halts in fact *does* return a specific, and that value is wrong.
>>>>>
>>>>>     There is no paradox.
>>>>>
>>>>
>>>> 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;
>>>> }
>>>>
>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>>> Number of Instructions Executed(2777)
>>>
>>> Here, H_Hat has not terminated. Yet, H has not returned the correct
>>> value to indicate this. The whole show simply stopped.
>>>
>>> Therefore H did not decide anything.
>>>
>>> H must terminate by returning normally with a return value that
>>> is true or false.
>>>
>>> You need a program like this:
>>>
>>>    int main()
>>>    {
>>>       if (H((u32)H_Hat, (u32)H_Hat)) {
>>>          puts("H_Hat(H_Hat) halts!");
>>>       } else {
>>>          puts("H_Hat(H_Hat) does not hal!");
>>>       }
>>>
>>>       return 0;
>>>    }
>>>
>>> This program must terminate, having printed either one of the two
>>> messages. If it does so, then it is deemed to have successfully decided.
>>
>> I am working on this. This is actually just window dressing.
>> It is a little tricky unwinding recursion cleanly.
> [...]
> 
> Has your window been splashed with black paint? Can it tell if an 
> unknown function halts? I say, hell no.
> 

It can correctly tell if the impossible to decide function halts.
see page 319:
http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf

-- 
Copyright 2020 Pete Olcott

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

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


Page 1 of 2  [1] 2  Next page →

Back to top | Article view | comp.software-eng


csiph-web