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


Groups > comp.theory > #25219 > unrolled thread

Refuting the halting problem proofs by deciding the previously undecidable input (V7)

Started byolcott <NoOne@NoWhere.com>
First post2020-11-13 09:14 -0600
Last post2020-11-13 14:18 -0700
Articles 20 on this page of 34 — 5 participants

Back to article view | Back to comp.theory


Contents

  Refuting the halting problem proofs by deciding the previously undecidable input (V7) olcott <NoOne@NoWhere.com> - 2020-11-13 09:14 -0600
    Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-13 15:51 +0000
      Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) olcott <NoOne@NoWhere.com> - 2020-11-13 10:09 -0600
        Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Richard Damon <Richard@Damon-Family.org> - 2020-11-13 11:24 -0500
          Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) olcott <NoOne@NoWhere.com> - 2020-11-13 10:37 -0600
            Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-13 17:56 +0000
              Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) olcott <NoOne@NoWhere.com> - 2020-11-13 12:18 -0600
                Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-13 22:31 +0000
                  Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) olcott <NoOne@NoWhere.com> - 2020-11-13 16:45 -0600
                    Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Richard Damon <Richard@Damon-Family.org> - 2020-11-13 17:56 -0500
                      Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) olcott <NoOne@NoWhere.com> - 2020-11-13 17:02 -0600
                        Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Richard Damon <Richard@Damon-Family.org> - 2020-11-13 18:59 -0500
                          Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) olcott <NoOne@NoWhere.com> - 2020-11-13 18:21 -0600
                            Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Richard Damon <Richard@Damon-Family.org> - 2020-11-13 20:54 -0500
                              Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) olcott <NoOne@NoWhere.com> - 2020-11-13 20:35 -0600
                                Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Richard Damon <Richard@Damon-Family.org> - 2020-11-13 22:39 -0500
                                  Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) [ counter-example? ] olcott <NoOne@NoWhere.com> - 2020-11-13 22:11 -0600
                                    Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) [ counter-example? ] olcott <NoOne@NoWhere.com> - 2020-11-13 22:22 -0600
                                    Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) [ counter-example? ] Richard Damon <Richard@Damon-Family.org> - 2020-11-14 09:33 -0500
                    Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-14 01:48 +0000
                      Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) olcott <NoOne@NoWhere.com> - 2020-11-13 20:24 -0600
                        Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-14 15:09 +0000
                      Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) [ counter-example? ] olcott <NoOne@NoWhere.com> - 2020-11-13 23:44 -0600
                        Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) [ counter-example? ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-14 14:54 +0000
        Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-13 17:39 +0000
          Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) olcott <NoOne@NoWhere.com> - 2020-11-13 12:14 -0600
            Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-13 22:12 +0000
              Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) olcott <NoOne@NoWhere.com> - 2020-11-13 16:32 -0600
                Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-14 01:56 +0000
                  Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) olcott <NoOne@NoWhere.com> - 2020-11-13 21:23 -0600
                    Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-14 14:54 +0000
    Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Jeff Barnett <jbb@notatt.com> - 2020-11-13 11:34 -0700
      Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-13 20:45 +0000
        Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) Jeff Barnett <jbb@notatt.com> - 2020-11-13 14:18 -0700

Page 1 of 2  [1] 2  Next page →


#25219 — Refuting the halting problem proofs by deciding the previously undecidable input (V7)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-13 09:14 -0600
SubjectRefuting the halting problem proofs by deciding the previously undecidable input (V7)
Message-ID<zIudnYtFtexAPzPCnZ2dnUU7-K3NnZ2d@giganews.com>
When-so-ever UTM halt decider H decides that:
(1) its input (<P>,I) would never halt unless H stopped simulating it
    and
(2) its input (<P>,I) would never halt unless H stopped simulating it
then H has made a correct not-halting decision on this input.

Since it does divide all of its inputs into {halting and not-halting}** 
it is a halt decider.

That it does not use the defective criteria that can be fooled by an 
input that does the opposite of whatever the halt decider decides*** 
makes the halting problem decidable.

    **The Halting problem is a problem in computer science.
    The problem is looking at a computer program and finding
    out if the program is going to run forever or not. We say
    that a program "solves the halting problem" if it can
    look at any other program and tell if that other program
    will run forever or not.
    https://simple.wikipedia.org/wiki/Halting_problem

    *** Now we construct a new Turing machine D with H as
    a subroutine. This new TM calls H to determine what M
    does when the input to M is its own description <M>.
    Once D has determined this information, it does the
    opposite. That is, it rejects if M accepts and accepts
    if M does not accept. The following is a description of D.
    (Sipser 1997) http://www.liarparadox.org/sipser_165.pdf

Sipser, Michael 1997. Introduction to the Theory of Computation. Boston: 
PWS Publishing Company (165-167)





-- 
Copyright 2020 Pete Olcott

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

[toc] | [next] | [standalone]


#25229

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-13 15:51 +0000
Message-ID<874kltp85f.fsf@bsb.me.uk>
In reply to#25219
olcott <NoOne@NoWhere.com> writes:

> When-so-ever UTM halt decider H decides that:
> (1) its input (<P>,I) would never halt unless H stopped simulating it
>    and
> (2) its input (<P>,I) would never halt unless H stopped simulating it
> then H has made a correct not-halting decision on this input.
>
> Since it does divide all of its inputs into {halting and
> not-halting}** it is a halt decider.

No, that's not what the halting problem is about.

-- 
Ben.

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


#25232

Fromolcott <NoOne@NoWhere.com>
Date2020-11-13 10:09 -0600
Message-ID<dsidnXe82rgBMjPCnZ2dnUU7-TudnZ2d@giganews.com>
In reply to#25229
On 11/13/2020 9:51 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> When-so-ever UTM halt decider H decides that:
>> (1) its input (<P>,I) would never halt unless H stopped simulating it
>>     and
>> (2) its input (<P>,I) would never halt unless H stopped simulating it
>> then H has made a correct not-halting decision on this input.
>>
>> Since it does divide all of its inputs into {halting and
>> not-halting}** it is a halt decider.
> 
> No, that's not what the halting problem is about.
> 

Sure it is:

    **The Halting problem is a problem in computer science.
    The problem is looking at a computer program and finding
    out if the program is going to run forever or not. We say
    that a program "solves the halting problem" if it can
    look at any other program and tell if that other program
    will run forever or not.
    https://simple.wikipedia.org/wiki/Halting_problem

Glancing at a few of my words for the purpose of contriving some sort of 
rebuttal has not ultimately been a very effective strategy for you.

-- 
Copyright 2020 Pete Olcott

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

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


#25237

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-13 11:24 -0500
Message-ID<bryrH.427984$Av7.295018@fx34.iad>
In reply to#25232
On 11/13/20 11:09 AM, olcott wrote:
> On 11/13/2020 9:51 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> When-so-ever UTM halt decider H decides that:
>>> (1) its input (<P>,I) would never halt unless H stopped simulating it
>>>     and
>>> (2) its input (<P>,I) would never halt unless H stopped simulating it
>>> then H has made a correct not-halting decision on this input.
>>>
>>> Since it does divide all of its inputs into {halting and
>>> not-halting}** it is a halt decider.
>>
>> No, that's not what the halting problem is about.
>>
> 
> Sure it is:
> 
>    **The Halting problem is a problem in computer science.
>    The problem is looking at a computer program and finding
>    out if the program is going to run forever or not. We say
>    that a program "solves the halting problem" if it can
>    look at any other program and tell if that other program
>    will run forever or not.
>    https://simple.wikipedia.org/wiki/Halting_problem
> 
> Glancing at a few of my words for the purpose of contriving some sort of
> rebuttal has not ultimately been a very effective strategy for you.
> 

The key differencne between that and what you say is that this
definition is based on the ACTUAL behavior of the actual program, and
not on what some program did or did not do while analyising the program.

YOUR definition focuses on what the decider did, not what the program
under test does, and if there is a possible difference, you resolve it
by focusing on the decider, and NOT on the actual program. Thus, you
program is NOT a true Halting Decider.

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


#25238

Fromolcott <NoOne@NoWhere.com>
Date2020-11-13 10:37 -0600
Message-ID<xsKdnfrzZrqzKzPCnZ2dnUU7-R3NnZ2d@giganews.com>
In reply to#25237
On 11/13/2020 10:24 AM, Richard Damon wrote:
> On 11/13/20 11:09 AM, olcott wrote:
>> On 11/13/2020 9:51 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> When-so-ever UTM halt decider H decides that:
>>>> (1) its input (<P>,I) would never halt unless H stopped simulating it
>>>>      and
>>>> (2) its input (<P>,I) would never halt unless H stopped simulating it
>>>> then H has made a correct not-halting decision on this input.
>>>>
>>>> Since it does divide all of its inputs into {halting and
>>>> not-halting}** it is a halt decider.
>>>
>>> No, that's not what the halting problem is about.
>>>
>>
>> Sure it is:
>>
>>     **The Halting problem is a problem in computer science.
>>     The problem is looking at a computer program and finding
>>     out if the program is going to run forever or not. We say
>>     that a program "solves the halting problem" if it can
>>     look at any other program and tell if that other program
>>     will run forever or not.
>>     https://simple.wikipedia.org/wiki/Halting_problem
>>
>> Glancing at a few of my words for the purpose of contriving some sort of
>> rebuttal has not ultimately been a very effective strategy for you.
>>
> 
> The key differencne between that and what you say is that this
> definition is based on the ACTUAL behavior of the actual program, and
> not on what some program did or did not do while analyising the program.
> 
> YOUR definition focuses on what the decider did, not what the program
> under test does, and if there is a possible difference, you resolve it
> by focusing on the decider, and NOT on the actual program. Thus, you
> program is NOT a true Halting Decider.
> 

Since H does divide all of its inputs into {halting and not-halting} it 
is a halt decider.

// Linz H with some of the ⊢* states shown
08 bool H(u32 P, u32 I)  // Page 318
09 {
10   bool Halted  = false;
11   bool Aborted = false;
12   while (!Halted && !Aborted)
13   {
14     Halted  = DebugStep(P, I);
15     Aborted = Needs_To_Be_Aborted();
16   }
17   return !Aborted;
18 }

When we remove line 15 all of the inputs that would have been decided to 
be not halting prove that they are indeed not halting by the fact that 
they fail to ever halt when line 15 is removed.

-- 
Copyright 2020 Pete Olcott

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

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


#25244

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-13 17:56 +0000
Message-ID<87a6vlnns8.fsf@bsb.me.uk>
In reply to#25238
olcott <NoOne@NoWhere.com> writes:

> On 11/13/2020 10:24 AM, Richard Damon wrote:
>> On 11/13/20 11:09 AM, olcott wrote:
>>> On 11/13/2020 9:51 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> When-so-ever UTM halt decider H decides that:
>>>>> (1) its input (<P>,I) would never halt unless H stopped simulating it
>>>>>      and
>>>>> (2) its input (<P>,I) would never halt unless H stopped simulating it
>>>>> then H has made a correct not-halting decision on this input.
>>>>>
>>>>> Since it does divide all of its inputs into {halting and
>>>>> not-halting}** it is a halt decider.
>>>>
>>>> No, that's not what the halting problem is about.
>>>>
>>>
>>> Sure it is:
>>>
>>>     **The Halting problem is a problem in computer science.
>>>     The problem is looking at a computer program and finding
>>>     out if the program is going to run forever or not. We say
>>>     that a program "solves the halting problem" if it can
>>>     look at any other program and tell if that other program
>>>     will run forever or not.
>>>     https://simple.wikipedia.org/wiki/Halting_problem
>>>
>>> Glancing at a few of my words for the purpose of contriving some sort of
>>> rebuttal has not ultimately been a very effective strategy for you.
>>>
>>
>> The key differencne between that and what you say is that this
>> definition is based on the ACTUAL behavior of the actual program, and
>> not on what some program did or did not do while analyising the program.
>>
>> YOUR definition focuses on what the decider did, not what the program
>> under test does, and if there is a possible difference, you resolve it
>> by focusing on the decider, and NOT on the actual program. Thus, you
>> program is NOT a true Halting Decider.
>>
>
> Since H does divide all of its inputs into {halting and not-halting}
> it is a halt decider.

It does not, as you yourself have told us.  Given

void H_Hat(u32 P) { if (H(P, P)) while (1); }

> 08 bool H(u32 P, u32 I)
> 09 {
> 10   bool Halted  = false;
> 11   bool Aborted = false;
> 12   while (!Halted && !Aborted)
> 13   {
> 14     Halted  = DebugStep(P, I);
> 15     Aborted = Needs_To_Be_Aborted();
> 16   }
> 17   return !Aborted;
> 18 }

You have confirmed that H(H_Hat, H_Hat) is false and that H_Hat(H_hat)
is a finite computation.

> When we remove line 15 all of the inputs that would have been decided
> to be not halting prove that they are indeed not halting by the fact
> that they fail to ever halt when line 15 is removed.

Sad to, this is an interesting point, and one that crops up most times
this material is taught.  I'd be happy to discuss it were it not for the
fact that you are determined to assert than you are correct about
halting in the face of undisputed facts!

-- 
Ben.

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


#25246

Fromolcott <NoOne@NoWhere.com>
Date2020-11-13 12:18 -0600
Message-ID<oa6dncC29b13UDPCnZ2dnUU7-cnNnZ2d@giganews.com>
In reply to#25244
On 11/13/2020 11:56 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/13/2020 10:24 AM, Richard Damon wrote:
>>> On 11/13/20 11:09 AM, olcott wrote:
>>>> On 11/13/2020 9:51 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> When-so-ever UTM halt decider H decides that:
>>>>>> (1) its input (<P>,I) would never halt unless H stopped simulating it
>>>>>>       and
>>>>>> (2) its input (<P>,I) would never halt unless H stopped simulating it
>>>>>> then H has made a correct not-halting decision on this input.
>>>>>>
>>>>>> Since it does divide all of its inputs into {halting and
>>>>>> not-halting}** it is a halt decider.
>>>>>
>>>>> No, that's not what the halting problem is about.
>>>>>
>>>>
>>>> Sure it is:
>>>>
>>>>      **The Halting problem is a problem in computer science.
>>>>      The problem is looking at a computer program and finding
>>>>      out if the program is going to run forever or not. We say
>>>>      that a program "solves the halting problem" if it can
>>>>      look at any other program and tell if that other program
>>>>      will run forever or not.
>>>>      https://simple.wikipedia.org/wiki/Halting_problem
>>>>
>>>> Glancing at a few of my words for the purpose of contriving some sort of
>>>> rebuttal has not ultimately been a very effective strategy for you.
>>>>
>>>
>>> The key differencne between that and what you say is that this
>>> definition is based on the ACTUAL behavior of the actual program, and
>>> not on what some program did or did not do while analyising the program.
>>>
>>> YOUR definition focuses on what the decider did, not what the program
>>> under test does, and if there is a possible difference, you resolve it
>>> by focusing on the decider, and NOT on the actual program. Thus, you
>>> program is NOT a true Halting Decider.
>>>
>>
>> Since H does divide all of its inputs into {halting and not-halting}
>> it is a halt decider.
> 
> It does not, as you yourself have told us.  Given
> 
> void H_Hat(u32 P) { if (H(P, P)) while (1); }
> 
>> 08 bool H(u32 P, u32 I)
>> 09 {
>> 10   bool Halted  = false;
>> 11   bool Aborted = false;
>> 12   while (!Halted && !Aborted)
>> 13   {
>> 14     Halted  = DebugStep(P, I);
>> 15     Aborted = Needs_To_Be_Aborted();
>> 16   }
>> 17   return !Aborted;
>> 18 }
> 
> You have confirmed that H(H_Hat, H_Hat) is false and that H_Hat(H_hat)
> is a finite computation.

When anyone cites what is purported to be a counter-example to a halt 
decider correctly deciding its inputs and this "counter-example" is not 
an input to this halt decider they commit the straw-man error of 
reasoning.  https://en.wikipedia.org/wiki/Straw_man



-- 
Copyright 2020 Pete Olcott

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

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


#25254

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-13 22:31 +0000
Message-ID<87v9e8nb1v.fsf@bsb.me.uk>
In reply to#25246
olcott <NoOne@NoWhere.com> writes:

> On 11/13/2020 11:56 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/13/2020 10:24 AM, Richard Damon wrote:
>>>> On 11/13/20 11:09 AM, olcott wrote:
>>>>> On 11/13/2020 9:51 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> When-so-ever UTM halt decider H decides that:
>>>>>>> (1) its input (<P>,I) would never halt unless H stopped simulating it
>>>>>>>       and
>>>>>>> (2) its input (<P>,I) would never halt unless H stopped simulating it
>>>>>>> then H has made a correct not-halting decision on this input.
>>>>>>>
>>>>>>> Since it does divide all of its inputs into {halting and
>>>>>>> not-halting}** it is a halt decider.
>>>>>>
>>>>>> No, that's not what the halting problem is about.
>>>>>>
>>>>>
>>>>> Sure it is:
>>>>>
>>>>>      **The Halting problem is a problem in computer science.
>>>>>      The problem is looking at a computer program and finding
>>>>>      out if the program is going to run forever or not. We say
>>>>>      that a program "solves the halting problem" if it can
>>>>>      look at any other program and tell if that other program
>>>>>      will run forever or not.
>>>>>      https://simple.wikipedia.org/wiki/Halting_problem
>>>>>
>>>>> Glancing at a few of my words for the purpose of contriving some sort of
>>>>> rebuttal has not ultimately been a very effective strategy for you.
>>>>>
>>>>
>>>> The key differencne between that and what you say is that this
>>>> definition is based on the ACTUAL behavior of the actual program, and
>>>> not on what some program did or did not do while analyising the program.
>>>>
>>>> YOUR definition focuses on what the decider did, not what the program
>>>> under test does, and if there is a possible difference, you resolve it
>>>> by focusing on the decider, and NOT on the actual program. Thus, you
>>>> program is NOT a true Halting Decider.
>>>>
>>>
>>> Since H does divide all of its inputs into {halting and not-halting}
>>> it is a halt decider.
>>
>> It does not, as you yourself have told us.  Given
>>
>> void H_Hat(u32 P) { if (H(P, P)) while (1); }
>>
>>> 08 bool H(u32 P, u32 I)
>>> 09 {
>>> 10   bool Halted  = false;
>>> 11   bool Aborted = false;
>>> 12   while (!Halted && !Aborted)
>>> 13   {
>>> 14     Halted  = DebugStep(P, I);
>>> 15     Aborted = Needs_To_Be_Aborted();
>>> 16   }
>>> 17   return !Aborted;
>>> 18 }
>>
>> You have confirmed that H(H_Hat, H_Hat) is false and that H_Hat(H_hat)
>> is a finite computation.
>
> When anyone cites what is purported to be a counter-example to a halt
> decider correctly deciding its inputs and this "counter-example" is not
> an input to this halt decider they commit the straw-man error of
> reasoning.

I gave a counter example to H being a halt decider.  It is the pair
(H_Hat, H_Hat).  It is "input" (at least as close as your code has to
such a thing) to the halt decider H.  H gives the wrong answer
(according to you).  Are you actually agreeing that the H you showed is
not a halt decider, because the counter example I gave is right there as
an "input" to H?

If you are saying that some other function is in fact a halt decider,
please actually show it, and I will give you the counter example to it
being one.  The same counter-example does not apply to all deciders,
though they often look similar.

-- 
Ben.

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


#25256

Fromolcott <NoOne@NoWhere.com>
Date2020-11-13 16:45 -0600
Message-ID<UKKdnZM2Yp8dkTLCnZ2dnUU7-X_NnZ2d@giganews.com>
In reply to#25254
On 11/13/2020 4:31 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 11/13/2020 11:56 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/13/2020 10:24 AM, Richard Damon wrote:
>>>>> On 11/13/20 11:09 AM, olcott wrote:
>>>>>> On 11/13/2020 9:51 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> When-so-ever UTM halt decider H decides that:
>>>>>>>> (1) its input (<P>,I) would never halt unless H stopped simulating it
>>>>>>>>        and
>>>>>>>> (2) its input (<P>,I) would never halt unless H stopped simulating it
>>>>>>>> then H has made a correct not-halting decision on this input.
>>>>>>>>
>>>>>>>> Since it does divide all of its inputs into {halting and
>>>>>>>> not-halting}** it is a halt decider.
>>>>>>>
>>>>>>> No, that's not what the halting problem is about.
>>>>>>>
>>>>>>
>>>>>> Sure it is:
>>>>>>
>>>>>>       **The Halting problem is a problem in computer science.
>>>>>>       The problem is looking at a computer program and finding
>>>>>>       out if the program is going to run forever or not. We say
>>>>>>       that a program "solves the halting problem" if it can
>>>>>>       look at any other program and tell if that other program
>>>>>>       will run forever or not.
>>>>>>       https://simple.wikipedia.org/wiki/Halting_problem
>>>>>>
>>>>>> Glancing at a few of my words for the purpose of contriving some sort of
>>>>>> rebuttal has not ultimately been a very effective strategy for you.
>>>>>>
>>>>>
>>>>> The key differencne between that and what you say is that this
>>>>> definition is based on the ACTUAL behavior of the actual program, and
>>>>> not on what some program did or did not do while analyising the program.
>>>>>
>>>>> YOUR definition focuses on what the decider did, not what the program
>>>>> under test does, and if there is a possible difference, you resolve it
>>>>> by focusing on the decider, and NOT on the actual program. Thus, you
>>>>> program is NOT a true Halting Decider.
>>>>>
>>>>
>>>> Since H does divide all of its inputs into {halting and not-halting}
>>>> it is a halt decider.
>>>
>>> It does not, as you yourself have told us.  Given
>>>
>>> void H_Hat(u32 P) { if (H(P, P)) while (1); }
>>>
>>>> 08 bool H(u32 P, u32 I)
>>>> 09 {
>>>> 10   bool Halted  = false;
>>>> 11   bool Aborted = false;
>>>> 12   while (!Halted && !Aborted)
>>>> 13   {
>>>> 14     Halted  = DebugStep(P, I);
>>>> 15     Aborted = Needs_To_Be_Aborted();
>>>> 16   }
>>>> 17   return !Aborted;
>>>> 18 }
>>>
>>> You have confirmed that H(H_Hat, H_Hat) is false and that H_Hat(H_hat)
>>> is a finite computation.
>>
>> When anyone cites what is purported to be a counter-example to a halt
>> decider correctly deciding its inputs and this "counter-example" is not
>> an input to this halt decider they commit the straw-man error of
>> reasoning.
> 
> I gave a counter example to H being a halt decider.  It is the pair
> (H_Hat, H_Hat).  It is "input" (at least as close as your code has to
> such a thing) to the halt decider H.  

> H gives the wrong answer
> (according to you).  

You know that I never said that.
The H that I defined gives the correct answer.

> Are you actually agreeing that the H you showed is
> not a halt decider, because the counter example I gave is right there as
> an "input" to H?

H(H_Hat, H_Hat) decides not-halting and all of the not-halting decisions 
can be easily verified as definitely correct by this process:

When simply removing the halt deciding capability of H (on line 15) 
results in the infinite execution of all of these inputs this proves 
beyond all doubt what-so-ever that H did decide all of these not-halting 
inputs correctly.

> If you are saying that some other function is in fact a halt decider,
> please actually show it, and I will give you the counter example to it
> being one.  The same counter-example does not apply to all deciders,
> though they often look similar.
> 

It seems that you only have rhetoric and misunderstandings.

The halt decider defined above cannot be fooled by the conventional 
halting problem trick so I have at least refuted the conclusion of all 
of these proofs.

-- 
Copyright 2020 Pete Olcott

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

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


#25257

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-13 17:56 -0500
Message-ID<UaErH.362602$5_4.6743@fx40.iad>
In reply to#25256
On 11/13/20 5:45 PM, olcott wrote:
> On 11/13/2020 4:31 PM, Ben Bacarisse wrote:

>> H gives the wrong answer
>> (according to you).  
> 
> You know that I never said that.
> The H that I defined gives the correct answer.
> 
>> Are you actually agreeing that the H you showed is
>> not a halt decider, because the counter example I gave is right there as
>> an "input" to H?
> 
> H(H_Hat, H_Hat) decides not-halting and all of the not-halting decisions
> can be easily verified as definitely correct by this process:

But H_Hat(H_Hat) is halting!!!, so H(H_Hat, H_Hat) saying non-halting is
wrong.
> 
> When simply removing the halt deciding capability of H (on line 15)
> results in the infinite execution of all of these inputs this proves
> beyond all doubt what-so-ever that H did decide all of these not-halting
> inputs correctly.
> 

Which is CHEATING because you change not only the code in the decider in
question but in the input.

If you look at the execution trace of this case, you will also see that
H is no no longer a decider, because it does not return in finite time,
and in fact THIS is the reason that you get non-halting in this test.

>> If you are saying that some other function is in fact a halt decider,
>> please actually show it, and I will give you the counter example to it
>> being one.  The same counter-example does not apply to all deciders,
>> though they often look similar.
>>
> 
> It seems that you only have rhetoric and misunderstandings.
> 
> The halt decider defined above cannot be fooled by the conventional
> halting problem trick so I have at least refuted the conclusion of all
> of these proofs.
> 

But it is, I guess because it was built by a bigger fool.

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


#25258

Fromolcott <NoOne@NoWhere.com>
Date2020-11-13 17:02 -0600
Message-ID<n8idnT2377wZjTLCnZ2dnUU7-LHNnZ2d@giganews.com>
In reply to#25257
On 11/13/2020 4:56 PM, Richard Damon wrote:
> On 11/13/20 5:45 PM, olcott wrote:
>> On 11/13/2020 4:31 PM, Ben Bacarisse wrote:
> 
>>> H gives the wrong answer
>>> (according to you).
>>
>> You know that I never said that.
>> The H that I defined gives the correct answer.
>>
>>> Are you actually agreeing that the H you showed is
>>> not a halt decider, because the counter example I gave is right there as
>>> an "input" to H?
>>
>> H(H_Hat, H_Hat) decides not-halting and all of the not-halting decisions
>> can be easily verified as definitely correct by this process:
> 
> But H_Hat(H_Hat) is halting!!!, so H(H_Hat, H_Hat) saying non-halting is
> wrong. 

Anyone can know with complete certainty entirely based on the meaning of 
the words that every counter-example proving that a decider decides its 
inputs incorrectly must itself be an input to this decider that this 
decider decides incorrectly.

Anything short of this is mere rhetorical double-talk.

>>
>> When simply removing the halt deciding capability of H (on line 15)
>> results in the infinite execution of all of these inputs this proves
>> beyond all doubt what-so-ever that H did decide all of these not-halting
>> inputs correctly.
>>
> 
> Which is CHEATING because you change not only the code in the decider in
> question but in the input.
> 

This may be beyond what you can imagine in your head.
You might have to wait a little while longer when you can try out 
different variations of the halt decider code for yourself.

> If you look at the execution trace of this case, you will also see that
> H is no no longer a decider, because it does not return in finite time,
> and in fact THIS is the reason that you get non-halting in this test.
> 
>>> If you are saying that some other function is in fact a halt decider,
>>> please actually show it, and I will give you the counter example to it
>>> being one.  The same counter-example does not apply to all deciders,
>>> though they often look similar.
>>>
>>
>> It seems that you only have rhetoric and misunderstandings.
>>
>> The halt decider defined above cannot be fooled by the conventional
>> halting problem trick so I have at least refuted the conclusion of all
>> of these proofs.
>>
> 
> But it is, I guess because it was built by a bigger fool.
> 


-- 
Copyright 2020 Pete Olcott

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

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


#25259

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-13 18:59 -0500
Message-ID<c5FrH.193737$6L.71106@fx17.iad>
In reply to#25258
On 11/13/20 6:02 PM, olcott wrote:
> On 11/13/2020 4:56 PM, Richard Damon wrote:
>> On 11/13/20 5:45 PM, olcott wrote:
>>> On 11/13/2020 4:31 PM, Ben Bacarisse wrote:
>>
>>>> H gives the wrong answer
>>>> (according to you).
>>>
>>> You know that I never said that.
>>> The H that I defined gives the correct answer.
>>>
>>>> Are you actually agreeing that the H you showed is
>>>> not a halt decider, because the counter example I gave is right
>>>> there as
>>>> an "input" to H?
>>>
>>> H(H_Hat, H_Hat) decides not-halting and all of the not-halting decisions
>>> can be easily verified as definitely correct by this process:
>>
>> But H_Hat(H_Hat) is halting!!!, so H(H_Hat, H_Hat) saying non-halting is
>> wrong. 
> 
> Anyone can know with complete certainty entirely based on the meaning of
> the words that every counter-example proving that a decider decides its
> inputs incorrectly must itself be an input to this decider that this
> decider decides incorrectly.
> 
> Anything short of this is mere rhetorical double-talk.

You are going to have to decide if you are going to be talking about
your decider as the classical Halt Decider, in which case we can compare
its result to the plain meaning of the classical halt decider, which it
fails at, or if your decider isn't the classical Halt Decider, in which
case your examples prove nothing about Linz and other proofs about the
non-exstance of a halt decider. Which is it?

> 
>>>
>>> When simply removing the halt deciding capability of H (on line 15)
>>> results in the infinite execution of all of these inputs this proves
>>> beyond all doubt what-so-ever that H did decide all of these not-halting
>>> inputs correctly.
>>>
>>
>> Which is CHEATING because you change not only the code in the decider in
>> question but in the input.
>>
> 
> This may be beyond what you can imagine in your head.
> You might have to wait a little while longer when you can try out
> different variations of the halt decider code for yourself.


If you would actully RE#AD and RESPOND to the questions actually put
before you, people might take you a bit more serious, but that seems to
be beyond what YOU can handle. YOU insist on changing the machines that
people present as the counter example, and thus you negate your defense
that they have done something wrong and that you are right.

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


#25260

Fromolcott <NoOne@NoWhere.com>
Date2020-11-13 18:21 -0600
Message-ID<wZGdnfT6gv6HvjLCnZ2dnUU7-Q3NnZ2d@giganews.com>
In reply to#25259
On 11/13/2020 5:59 PM, Richard Damon wrote:
> On 11/13/20 6:02 PM, olcott wrote:
>> On 11/13/2020 4:56 PM, Richard Damon wrote:
>>> On 11/13/20 5:45 PM, olcott wrote:
>>>> On 11/13/2020 4:31 PM, Ben Bacarisse wrote:
>>>
>>>>> H gives the wrong answer
>>>>> (according to you).
>>>>
>>>> You know that I never said that.
>>>> The H that I defined gives the correct answer.
>>>>
>>>>> Are you actually agreeing that the H you showed is
>>>>> not a halt decider, because the counter example I gave is right
>>>>> there as
>>>>> an "input" to H?
>>>>
>>>> H(H_Hat, H_Hat) decides not-halting and all of the not-halting decisions
>>>> can be easily verified as definitely correct by this process:
>>>
>>> But H_Hat(H_Hat) is halting!!!, so H(H_Hat, H_Hat) saying non-halting is
>>> wrong.
>>
>> Anyone can know with complete certainty entirely based on the meaning of
>> the words that every counter-example proving that a decider decides its
>> inputs incorrectly must itself be an input to this decider that this
>> decider decides incorrectly.
>>
>> Anything short of this is mere rhetorical double-talk.
> 
> You are going to have to decide if you are going to be talking about
> your decider as the classical Halt Decider, in which case we can compare
> its result to the plain meaning of the classical halt decider, which it
> fails at, or if your decider isn't the classical Halt Decider, in which
> case your examples prove nothing about Linz and other proofs about the
> non-exstance of a halt decider. Which is it?
> 

Let,s talk about the Halting Problem instead:
    The Halting problem is a problem in computer science.
    The problem is looking at a computer program and finding
    out if the program is going to run forever or not. We say
    that a program "solves the halting problem" if it can look
    at any other program and tell if that other program will
    run forever or not.

    https://simple.wikipedia.org/wiki/Halting_problem

If the conventional proofs conclude that such a halt decider cannot 
possibly exist on the basis of this sort of counter-example:

01 void H_Hat(u32 P)
02 {
03   if (H(P, P))
04     HERE: goto HERE;
05   else
06     HALT
07 }

When I show the steps for correctly deciding that counter-example then I 
have refuted the basis and thus conclusion of all these proofs.

>>
>>>>
>>>> When simply removing the halt deciding capability of H (on line 15)
>>>> results in the infinite execution of all of these inputs this proves
>>>> beyond all doubt what-so-ever that H did decide all of these not-halting
>>>> inputs correctly.
>>>>
>>>
>>> Which is CHEATING because you change not only the code in the decider in
>>> question but in the input.
>>>
>>
>> This may be beyond what you can imagine in your head.
>> You might have to wait a little while longer when you can try out
>> different variations of the halt decider code for yourself.
> 
> 
> If you would actully RE#AD and RESPOND to the questions actually put
> before you, people might take you a bit more serious, but that seems to
> be beyond what YOU can handle. YOU insist on changing the machines that
> people present as the counter example, and thus you negate your defense
> that they have done something wrong and that you are right.
> 

The following has apparently exceeded the threshold of your 
understanding yet can be empirically proven by actual working code.

This statement can be known to be true with 100% complete certainty in 
the same way that we can know that black cats are black:

My argument unequivocally refutes any and all counter-arguments that H 
is not a halt decider for the inputs that it decides are not-halting.

When simply removing the halt deciding capability of H (on line 15) 
results in the infinite execution of all of these inputs this proves 
beyond all doubt what-so-ever that H did decide all of these not-halting 
inputs correctly.

Any disagreement is analogous to disagreeing that black cats are black.

-- 
Copyright 2020 Pete Olcott

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

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


#25262

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-13 20:54 -0500
Message-ID<ENGrH.502477$zX4.71792@fx41.iad>
In reply to#25260
On 11/13/20 7:21 PM, olcott wrote:
> On 11/13/2020 5:59 PM, Richard Damon wrote:
>> On 11/13/20 6:02 PM, olcott wrote:
>>> On 11/13/2020 4:56 PM, Richard Damon wrote:
>>>> On 11/13/20 5:45 PM, olcott wrote:
>>>>> On 11/13/2020 4:31 PM, Ben Bacarisse wrote:
>>>>
>>>>>> H gives the wrong answer
>>>>>> (according to you).
>>>>>
>>>>> You know that I never said that.
>>>>> The H that I defined gives the correct answer.
>>>>>
>>>>>> Are you actually agreeing that the H you showed is
>>>>>> not a halt decider, because the counter example I gave is right
>>>>>> there as
>>>>>> an "input" to H?
>>>>>
>>>>> H(H_Hat, H_Hat) decides not-halting and all of the not-halting
>>>>> decisions
>>>>> can be easily verified as definitely correct by this process:
>>>>
>>>> But H_Hat(H_Hat) is halting!!!, so H(H_Hat, H_Hat) saying
>>>> non-halting is
>>>> wrong.
>>>
>>> Anyone can know with complete certainty entirely based on the meaning of
>>> the words that every counter-example proving that a decider decides its
>>> inputs incorrectly must itself be an input to this decider that this
>>> decider decides incorrectly.
>>>
>>> Anything short of this is mere rhetorical double-talk.
>>
>> You are going to have to decide if you are going to be talking about
>> your decider as the classical Halt Decider, in which case we can compare
>> its result to the plain meaning of the classical halt decider, which it
>> fails at, or if your decider isn't the classical Halt Decider, in which
>> case your examples prove nothing about Linz and other proofs about the
>> non-exstance of a halt decider. Which is it?
>>
> 
> Let,s talk about the Halting Problem instead:
>    The Halting problem is a problem in computer science.
>    The problem is looking at a computer program and finding
>    out if the program is going to run forever or not. We say
>    that a program "solves the halting problem" if it can look
>    at any other program and tell if that other program will
>    run forever or not.
> 
>    https://simple.wikipedia.org/wiki/Halting_problem
> 
> If the conventional proofs conclude that such a halt decider cannot
> possibly exist on the basis of this sort of counter-example:
> 
> 01 void H_Hat(u32 P)
> 02 {
> 03   if (H(P, P))
> 04     HERE: goto HERE;
> 05   else
> 06     HALT
> 07 }
> 
> When I show the steps for correctly deciding that counter-example then I
> have refuted the basis and thus conclusion of all these proofs.
> 

Then why is your answer 'correct' when you say that it will not stop
(needed to be aborted) but when you actually run that program it halts?

Note, that the proof is that it is impossible to build a halt decider
that works on ALL programs. There are methods to build one for many
cases, so the partial answer is available.

Your 'correctly deciding' is based on that 'trick' of changing the
definition of the problem and trying to solve that different problem (a
Strawman as you aptly charged others with), but your answers don't even
meet your own definition except by extreame twisting of words (needs to
abort doesn'r really mean that it needs to be aborted, but that your
code decided that it had to abort it, and you code must be God and thus
right).

>>>
>>>>>
>>>>> When simply removing the halt deciding capability of H (on line 15)
>>>>> results in the infinite execution of all of these inputs this proves
>>>>> beyond all doubt what-so-ever that H did decide all of these
>>>>> not-halting
>>>>> inputs correctly.
>>>>>
>>>>
>>>> Which is CHEATING because you change not only the code in the
>>>> decider in
>>>> question but in the input.
>>>>
>>>
>>> This may be beyond what you can imagine in your head.
>>> You might have to wait a little while longer when you can try out
>>> different variations of the halt decider code for yourself.
>>
>>
>> If you would actully RE#AD and RESPOND to the questions actually put
>> before you, people might take you a bit more serious, but that seems to
>> be beyond what YOU can handle. YOU insist on changing the machines that
>> people present as the counter example, and thus you negate your defense
>> that they have done something wrong and that you are right.
>>
> 
> The following has apparently exceeded the threshold of your
> understanding yet can be empirically proven by actual working code.
> 
> This statement can be known to be true with 100% complete certainty in
> the same way that we can know that black cats are black:
> 
> My argument unequivocally refutes any and all counter-arguments that H
> is not a halt decider for the inputs that it decides are not-halting.
> 
> When simply removing the halt deciding capability of H (on line 15)
> results in the infinite execution of all of these inputs this proves
> beyond all doubt what-so-ever that H did decide all of these not-halting
> inputs correctly.
> 
> Any disagreement is analogous to disagreeing that black cats are black.
> 

But the 'black cat' you are describing is white! (It halts when you
claim it runs forever).

The counter has obviously exceeded YOUR capacity as you have made no
indication that you have even read it, and absolutely no responce to it,
other than it must be wrong because it disagrees with your proposition.

Ultimately, you are going to need to decide which side of the argument
you are going to try to be on. Either you stick to needing to be
compatible with the proper definition of a halting detector, so your
results could be used against the classical proof of the non-existance
of a Universal Halt Detector, and see that your algorythm doesn't not
match that required behavior (because the fact that it DOES halt, means
that you can't claim that you needed to abort it), or can insist on your
altered definition of aborting, defined however you want, but then
accept that by not using the classical definition you arguements don't
apply to the classical proofs.

Remember, you don't get to make the rules when you are working with
classical proofs, they are based on established definitions, so to prove
or disprove them you need to work under their specified (or assumed by
context) constraints.

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


#25265

Fromolcott <NoOne@NoWhere.com>
Date2020-11-13 20:35 -0600
Message-ID<i5idnUw1MIke3zLCnZ2dnUU7-TnNnZ2d@giganews.com>
In reply to#25262
On 11/13/2020 7:54 PM, Richard Damon wrote:
> On 11/13/20 7:21 PM, olcott wrote:
>> On 11/13/2020 5:59 PM, Richard Damon wrote:
>>> On 11/13/20 6:02 PM, olcott wrote:
>>>> On 11/13/2020 4:56 PM, Richard Damon wrote:
>>>>> On 11/13/20 5:45 PM, olcott wrote:
>>>>>> On 11/13/2020 4:31 PM, Ben Bacarisse wrote:
>>>>>
>>>>>>> H gives the wrong answer
>>>>>>> (according to you).
>>>>>>
>>>>>> You know that I never said that.
>>>>>> The H that I defined gives the correct answer.
>>>>>>
>>>>>>> Are you actually agreeing that the H you showed is
>>>>>>> not a halt decider, because the counter example I gave is right
>>>>>>> there as
>>>>>>> an "input" to H?
>>>>>>
>>>>>> H(H_Hat, H_Hat) decides not-halting and all of the not-halting
>>>>>> decisions
>>>>>> can be easily verified as definitely correct by this process:
>>>>>
>>>>> But H_Hat(H_Hat) is halting!!!, so H(H_Hat, H_Hat) saying
>>>>> non-halting is
>>>>> wrong.
>>>>
>>>> Anyone can know with complete certainty entirely based on the meaning of
>>>> the words that every counter-example proving that a decider decides its
>>>> inputs incorrectly must itself be an input to this decider that this
>>>> decider decides incorrectly.
>>>>
>>>> Anything short of this is mere rhetorical double-talk.
>>>
>>> You are going to have to decide if you are going to be talking about
>>> your decider as the classical Halt Decider, in which case we can compare
>>> its result to the plain meaning of the classical halt decider, which it
>>> fails at, or if your decider isn't the classical Halt Decider, in which
>>> case your examples prove nothing about Linz and other proofs about the
>>> non-exstance of a halt decider. Which is it?
>>>
>>
>> Let,s talk about the Halting Problem instead:
>>     The Halting problem is a problem in computer science.
>>     The problem is looking at a computer program and finding
>>     out if the program is going to run forever or not. We say
>>     that a program "solves the halting problem" if it can look
>>     at any other program and tell if that other program will
>>     run forever or not.
>>
>>     https://simple.wikipedia.org/wiki/Halting_problem
>>
>> If the conventional proofs conclude that such a halt decider cannot
>> possibly exist on the basis of this sort of counter-example:
>>
>> 01 void H_Hat(u32 P)
>> 02 {
>> 03   if (H(P, P))
>> 04     HERE: goto HERE;
>> 05   else
>> 06     HALT
>> 07 }
>>
>> When I show the steps for correctly deciding that counter-example then I
>> have refuted the basis and thus conclusion of all these proofs.
>>
> 
> Then why is your answer 'correct' when you say that it will not stop
> (needed to be aborted) but when you actually run that program it halts?

Anyone can know with complete certainty entirely based on the meaning of 
the words that every counter-example proving that a decider decides its 
inputs incorrectly must itself be an input to this decider that this 
decider decides incorrectly.

Anything short of this is mere rhetorical double-talk.
The following IS NOT a counter-example proving that a decider decides 
its inputs incorrectly because it is NOT AN INPUT !!!

int main()
   H_Hat_(H_Hat);

> Note, that the proof is that it is impossible to build a halt decider
> that works on ALL programs. There are methods to build one for many
> cases, so the partial answer is available.
> 
> Your 'correctly deciding' is based on that 'trick' of changing the
> definition of the problem and trying to solve that different problem (a
> Strawman as you aptly charged others with), but your answers don't even
> meet your own definition except by extreame twisting of words (needs to
> abort doesn'r really mean that it needs to be aborted, but that your
> code decided that it had to abort it, and you code must be God and thus
> right).

When-so-ever a UTM halt decider H makes its not-halting decision by 
ceasing to simulate its input (<P>,I) the correctness of a not-halting 
decision is verified when the input (<P>,I) fails to terminate after the 
halt decider has had its halt deciding capability disabled.



>>>>
>>>>>>
>>>>>> When simply removing the halt deciding capability of H (on line 15)
>>>>>> results in the infinite execution of all of these inputs this proves
>>>>>> beyond all doubt what-so-ever that H did decide all of these
>>>>>> not-halting
>>>>>> inputs correctly.
>>>>>>
>>>>>
>>>>> Which is CHEATING because you change not only the code in the
>>>>> decider in
>>>>> question but in the input.
>>>>>
>>>>
>>>> This may be beyond what you can imagine in your head.
>>>> You might have to wait a little while longer when you can try out
>>>> different variations of the halt decider code for yourself.
>>>
>>>
>>> If you would actully RE#AD and RESPOND to the questions actually put
>>> before you, people might take you a bit more serious, but that seems to
>>> be beyond what YOU can handle. YOU insist on changing the machines that
>>> people present as the counter example, and thus you negate your defense
>>> that they have done something wrong and that you are right.
>>>
>>
>> The following has apparently exceeded the threshold of your
>> understanding yet can be empirically proven by actual working code.
>>
>> This statement can be known to be true with 100% complete certainty in
>> the same way that we can know that black cats are black:
>>
>> My argument unequivocally refutes any and all counter-arguments that H
>> is not a halt decider for the inputs that it decides are not-halting.
>>
>> When simply removing the halt deciding capability of H (on line 15)
>> results in the infinite execution of all of these inputs this proves
>> beyond all doubt what-so-ever that H did decide all of these not-halting
>> inputs correctly.
>>
>> Any disagreement is analogous to disagreeing that black cats are black.
>>
> 
> But the 'black cat' you are describing is white! (It halts when you
> claim it runs forever).

So in other words do not understand how logical tautologies work.

When-so-ever a UTM halt decider H makes its not-halting decision by 
ceasing to simulate its input (<P>,I) the correctness of a not-halting 
decision is verified when the input (<P>,I) fails to terminate after the 
halt decider has had its halt deciding capability disabled.

> The counter has obviously exceeded YOUR capacity as you have made no
> indication that you have even read it, and absolutely no responce to it,
> other than it must be wrong because it disagrees with your proposition.
> 
> Ultimately, you are going to need to decide which side of the argument
> you are going to try to be on. Either you stick to needing to be
> compatible with the proper definition of a halting detector, so your

No, No, Hell No !!! I stick the the definition of the halting problem.

I discard the worthless definition of a halt detector and replace it 
with one that works.

> results could be used against the classical proof of the non-existance
> of a Universal Halt Detector, and see that your algorythm doesn't not
> match that required behavior (because the fact that it DOES halt, means
> that you can't claim that you needed to abort it), 

YOU ARE UTTERLY FAILING TO COMPREHEND THAT YOU HAVE NOT PROVIDED A VALID 
COUNTER-EXAMPLE.

Anyone can know with complete certainty entirely based on the meaning of 
the words that every counter-example proving that a decider decides its 
inputs incorrectly must itself be an input to this decider that this 
decider decides incorrectly.

> or can insist on your
> altered definition of aborting, defined however you want, but then
> accept that by not using the classical definition you arguements don't
> apply to the classical proofs.
> 
> Remember, you don't get to make the rules when you are working with
> classical proofs, they are based on established definitions, so to prove
> or disprove them you need to work under their specified (or assumed by
> context) constraints.
> 


-- 
Copyright 2020 Pete Olcott

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

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


#25267

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-13 22:39 -0500
Message-ID<hkIrH.82203$jvn.18663@fx01.iad>
In reply to#25265
On 11/13/20 9:35 PM, olcott wrote:
> On 11/13/2020 7:54 PM, Richard Damon wrote:
>> On 11/13/20 7:21 PM, olcott wrote:
>>> On 11/13/2020 5:59 PM, Richard Damon wrote:

>>>>
>>>> If you would actully RE#AD and RESPOND to the questions actually put
>>>> before you, people might take you a bit more serious, but that seems to
>>>> be beyond what YOU can handle. YOU insist on changing the machines that
>>>> people present as the counter example, and thus you negate your defense
>>>> that they have done something wrong and that you are right.
>>>>
>>>
>>> The following has apparently exceeded the threshold of your
>>> understanding yet can be empirically proven by actual working code.
>>>
>>> This statement can be known to be true with 100% complete certainty in
>>> the same way that we can know that black cats are black:
>>>
>>> My argument unequivocally refutes any and all counter-arguments that H
>>> is not a halt decider for the inputs that it decides are not-halting.
>>>
>>> When simply removing the halt deciding capability of H (on line 15)
>>> results in the infinite execution of all of these inputs this proves
>>> beyond all doubt what-so-ever that H did decide all of these not-halting
>>> inputs correctly.
>>>
>>> Any disagreement is analogous to disagreeing that black cats are black.
>>>
>>
>> But the 'black cat' you are describing is white! (It halts when you
>> claim it runs forever).
> 
> So in other words do not understand how logical tautologies work.

Saying a black cat is black may be a tautology, but it may be an
incorrect statement if the cat in question is actually white.

You make CLAIMS that you arguement is a tautology, but it is based on
word twisting and incorrect operations. It has fallicies in it. In
essense your arguement is of the form:

A -> B
C
therefore B

A being the statement H_Hat(H_Hat) had to be aborted.
B is H(H_Hat, H_Hat) is non-Halting
C when H_Hat(H_Hat) is modified, it does not halt.

When in actuality, it can be shown A', as when H(H_Hat, H_Hat) is run it
halts.

> 
> When-so-ever a UTM halt decider H makes its not-halting decision by
> ceasing to simulate its input (<P>,I) the correctness of a not-halting
> decision is verified when the input (<P>,I) fails to terminate after the
> halt decider has had its halt deciding capability disabled.

But only when you cheat and change the machine being tested!!! If you
actually do the test per the description of a Turing Machine, where the
input to H is not changed at all, but H has its abort code disabled, the
machine H WILL HALT. Only by forcing a change in the input by forcing it
to use the same subroutine that was changed do you get your example.

This was clearly shown by the machines you have FAILED to look at that
modifed the code so that the disabling of the halting was done as a
parameter and not an edit of the function, so that your improper changes
don't occur.

The fact that the UTM decided to abort the processing of a machine is
aboslutely NOT proof that the machine would be non-halting. The test
wold be to run that same UTM with the ONLY change being the abort in
that outer level of code AND NOW WHERE ELSE removed, and then proving
that the machine is non-halting. The fact that the machine under
question has similar code to the halt-decider is irrelevent to this
decision, and that code must not be changed.

> 
>> The counter has obviously exceeded YOUR capacity as you have made no
>> indication that you have even read it, and absolutely no responce to it,
>> other than it must be wrong because it disagrees with your proposition.
>>
>> Ultimately, you are going to need to decide which side of the argument
>> you are going to try to be on. Either you stick to needing to be
>> compatible with the proper definition of a halting detector, so your
> 
> No, No, Hell No !!! I stick the the definition of the halting problem.
> 
> I discard the worthless definition of a halt detector and replace it
> with one that works.

Wait, did you just say that contradiction? You claim to stick wth the
definition of the halting problem, but reject its definition?

What is worthless about the definition of a halt-decider that it decides
wether a given Turing Machine will halt in finite time or run
indefinately, always giving the right answer in finite time?? That
definition follows directly from the statement of the halting problem,

> 
>> results could be used against the classical proof of the non-existance
>> of a Universal Halt Detector, and see that your algorythm doesn't not
>> match that required behavior (because the fact that it DOES halt, means
>> that you can't claim that you needed to abort it), 
> 
> YOU ARE UTTERLY FAILING TO COMPREHEND THAT YOU HAVE NOT PROVIDED A VALID
> COUNTER-EXAMPLE.

WHY IS IT NOT???

It is a clearly written program.
It shows that H(H_Hat) predicts that the machine H(H_Hat, H_Hat) will
non halt.

It shows that disabling the halt test in the top level of H, so that
H_Hat is not modified, still runs to completion, and thus shows that the
aborting was NOT 'needed'

It also shows that when H_Hat(H_Hat) is run by itself, it also runs to
completion and halts.


> 
> Anyone can know with complete certainty entirely based on the meaning of
> the words that every counter-example proving that a decider decides its
> inputs incorrectly must itself be an input to this decider that this
> decider decides incorrectly.

It is easy to misuse words to LIE. Your machine decised H_Hat
incorrectly. It even decides incorrectly the machine I gave you earlier
what just duplicates its input and then goes into H, which is a clearly
halting machine, so it isn't even the self-contradiction of Linz's H_Hat
that gives your decider indegestion.

Note also a key point in the halting problem, that halting problem is
ALL about the actual MACHINE that is in question, and uses a
representation of that machine as its input. The KEY attribute is that
of the machine, not the input. The input is a tool, it is a method, it
is not the master.
> 
>> or can insist on your
>> altered definition of aborting, defined however you want, but then
>> accept that by not using the classical definition you arguements don't
>> apply to the classical proofs.
>>
>> Remember, you don't get to make the rules when you are working with
>> classical proofs, they are based on established definitions, so to prove
>> or disprove them you need to work under their specified (or assumed by
>> context) constraints.
>>
> 
> 

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


#25268 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) [ counter-example? ]

Fromolcott <NoOne@NoWhere.com>
Date2020-11-13 22:11 -0600
SubjectRe: Refuting the halting problem proofs by deciding the previously undecidable input (V7) [ counter-example? ]
Message-ID<v-SdnfT2iuyVxDLCnZ2dnUU7-RnNnZ2d@giganews.com>
In reply to#25267
On 11/13/2020 9:39 PM, Richard Damon wrote:
> On 11/13/20 9:35 PM, olcott wrote:
>> On 11/13/2020 7:54 PM, Richard Damon wrote:
>>> On 11/13/20 7:21 PM, olcott wrote:
>>>> On 11/13/2020 5:59 PM, Richard Damon wrote:
> 
>>>>>
>>>>> If you would actully RE#AD and RESPOND to the questions actually put
>>>>> before you, people might take you a bit more serious, but that seems to
>>>>> be beyond what YOU can handle. YOU insist on changing the machines that
>>>>> people present as the counter example, and thus you negate your defense
>>>>> that they have done something wrong and that you are right.
>>>>>
>>>>
>>>> The following has apparently exceeded the threshold of your
>>>> understanding yet can be empirically proven by actual working code.
>>>>
>>>> This statement can be known to be true with 100% complete certainty in
>>>> the same way that we can know that black cats are black:
>>>>
>>>> My argument unequivocally refutes any and all counter-arguments that H
>>>> is not a halt decider for the inputs that it decides are not-halting.
>>>>
>>>> When simply removing the halt deciding capability of H (on line 15)
>>>> results in the infinite execution of all of these inputs this proves
>>>> beyond all doubt what-so-ever that H did decide all of these not-halting
>>>> inputs correctly.
>>>>
>>>> Any disagreement is analogous to disagreeing that black cats are black.
>>>>
>>>
>>> But the 'black cat' you are describing is white! (It halts when you
>>> claim it runs forever).
>>
>> So in other words do not understand how logical tautologies work.
> 
> Saying a black cat is black may be a tautology, but it may be an
> incorrect statement if the cat in question is actually white.

That cat in question is the one in the sentence so it is clear that you 
do not understand tautologies.

> You make CLAIMS that you arguement is a tautology, but it is based on
> word twisting and incorrect operations. It has fallicies in it. In
> essense your arguement is of the form:
> A -> B
> C
> therefore B
> 
> A being the statement H_Hat(H_Hat) had to be aborted.
> B is H(H_Hat, H_Hat) is non-Halting
> C when H_Hat(H_Hat) is modified, it does not halt.
> 
> When in actuality, it can be shown A', as when H(H_Hat, H_Hat) is run it
> halts.

This is NOT a valid counter-example proving that a decider decides its 
inputs incorrectly:

int main()
   H_Halt_(H_Hat)

Because every counter-example proving that a decider decides its inputs 
incorrectly must itself be an input to this decider that this decider 
decides incorrectly.

Can you come up with an actual counter-example?


-- 
Copyright 2020 Pete Olcott

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

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


#25269 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) [ counter-example? ]

Fromolcott <NoOne@NoWhere.com>
Date2020-11-13 22:22 -0600
SubjectRe: Refuting the halting problem proofs by deciding the previously undecidable input (V7) [ counter-example? ]
Message-ID<o66dnTFfh5HxxjLCnZ2dnUU7-YmdnZ2d@giganews.com>
In reply to#25268
On 11/13/2020 10:11 PM, olcott wrote:
> On 11/13/2020 9:39 PM, Richard Damon wrote:
>> On 11/13/20 9:35 PM, olcott wrote:
>>> On 11/13/2020 7:54 PM, Richard Damon wrote:
>>>> On 11/13/20 7:21 PM, olcott wrote:
>>>>> On 11/13/2020 5:59 PM, Richard Damon wrote:
>>
>>>>>>
>>>>>> If you would actully RE#AD and RESPOND to the questions actually put
>>>>>> before you, people might take you a bit more serious, but that 
>>>>>> seems to
>>>>>> be beyond what YOU can handle. YOU insist on changing the machines 
>>>>>> that
>>>>>> people present as the counter example, and thus you negate your 
>>>>>> defense
>>>>>> that they have done something wrong and that you are right.
>>>>>>
>>>>>
>>>>> The following has apparently exceeded the threshold of your
>>>>> understanding yet can be empirically proven by actual working code.
>>>>>
>>>>> This statement can be known to be true with 100% complete certainty in
>>>>> the same way that we can know that black cats are black:
>>>>>
>>>>> My argument unequivocally refutes any and all counter-arguments that H
>>>>> is not a halt decider for the inputs that it decides are not-halting.
>>>>>
>>>>> When simply removing the halt deciding capability of H (on line 15)
>>>>> results in the infinite execution of all of these inputs this proves
>>>>> beyond all doubt what-so-ever that H did decide all of these 
>>>>> not-halting
>>>>> inputs correctly.
>>>>>
>>>>> Any disagreement is analogous to disagreeing that black cats are 
>>>>> black.
>>>>>
>>>>
>>>> But the 'black cat' you are describing is white! (It halts when you
>>>> claim it runs forever).
>>>
>>> So in other words do not understand how logical tautologies work.
>>
>> Saying a black cat is black may be a tautology, but it may be an
>> incorrect statement if the cat in question is actually white.
> 
> That cat in question is the one in the sentence so it is clear that you 
> do not understand tautologies.
> 
>> You make CLAIMS that you arguement is a tautology, but it is based on
>> word twisting and incorrect operations. It has fallicies in it. In
>> essense your arguement is of the form:
>> A -> B
>> C
>> therefore B
>>
>> A being the statement H_Hat(H_Hat) had to be aborted.
>> B is H(H_Hat, H_Hat) is non-Halting
>> C when H_Hat(H_Hat) is modified, it does not halt.
>>
>> When in actuality, it can be shown A', as when H(H_Hat, H_Hat) is run it
>> halts.
> 
> This is NOT a valid counter-example proving that a decider decides its 
> inputs incorrectly:
> 
> int main()
>    H_Halt_(H_Hat)


Correction:
      H_Hat(H_Hat)


> 
> Because every counter-example proving that a decider decides its inputs 
> incorrectly must itself be an input to this decider that this decider 
> decides incorrectly.
> 
> Can you come up with an actual counter-example?
> 
> 


-- 
Copyright 2020 Pete Olcott

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

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


#25272 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V7) [ counter-example? ]

FromRichard Damon <Richard@Damon-Family.org>
Date2020-11-14 09:33 -0500
SubjectRe: Refuting the halting problem proofs by deciding the previously undecidable input (V7) [ counter-example? ]
Message-ID<SURrH.435161$Av7.85671@fx34.iad>
In reply to#25268
On 11/13/20 11:11 PM, olcott wrote:
> On 11/13/2020 9:39 PM, Richard Damon wrote:
>> On 11/13/20 9:35 PM, olcott wrote:
>>> On 11/13/2020 7:54 PM, Richard Damon wrote:
>>>> On 11/13/20 7:21 PM, olcott wrote:
>>>>> On 11/13/2020 5:59 PM, Richard Damon wrote:
>>
>>>>>>
>>>>>> If you would actully RE#AD and RESPOND to the questions actually put
>>>>>> before you, people might take you a bit more serious, but that
>>>>>> seems to
>>>>>> be beyond what YOU can handle. YOU insist on changing the machines
>>>>>> that
>>>>>> people present as the counter example, and thus you negate your
>>>>>> defense
>>>>>> that they have done something wrong and that you are right.
>>>>>>
>>>>>
>>>>> The following has apparently exceeded the threshold of your
>>>>> understanding yet can be empirically proven by actual working code.
>>>>>
>>>>> This statement can be known to be true with 100% complete certainty in
>>>>> the same way that we can know that black cats are black:
>>>>>
>>>>> My argument unequivocally refutes any and all counter-arguments that H
>>>>> is not a halt decider for the inputs that it decides are not-halting.
>>>>>
>>>>> When simply removing the halt deciding capability of H (on line 15)
>>>>> results in the infinite execution of all of these inputs this proves
>>>>> beyond all doubt what-so-ever that H did decide all of these
>>>>> not-halting
>>>>> inputs correctly.
>>>>>
>>>>> Any disagreement is analogous to disagreeing that black cats are
>>>>> black.
>>>>>
>>>>
>>>> But the 'black cat' you are describing is white! (It halts when you
>>>> claim it runs forever).
>>>
>>> So in other words do not understand how logical tautologies work.
>>
>> Saying a black cat is black may be a tautology, but it may be an
>> incorrect statement if the cat in question is actually white.
> 
> That cat in question is the one in the sentence so it is clear that you
> do not understand tautologies.
> 

Then your statement
> When simply removing the halt deciding capability of H (on line 15)
> results in the infinite execution of all of these inputs this proves
> beyond all doubt what-so-ever that H did decide all of these
> not-halting
> inputs correctly.

Is a non-sense statement and not applicable because the removal of line
15 is NOT the test in question and proves nothing.

This is like saying a black cat is black as an attempt to prove that
Trump won the presidency.

The test of if the decider made the correct answer is to compare the
results it gives to the actual machine (if you are claiming an actual
halt decider) or against the specification of needing to abort ITS
input, which means removing the test ONLY from the outer code, and not
changing the code that the system under test has.

This is obvious once you remove the blinders that you are wearing are
realise that operation like 'make a copy of a function' are fully legal
operations, and to prohibit them, you are no longer in the realm of the
computer science you claim to be working with.

>> You make CLAIMS that you arguement is a tautology, but it is based on
>> word twisting and incorrect operations. It has fallicies in it. In
>> essense your arguement is of the form:
>> A -> B
>> C
>> therefore B
>>
>> A being the statement H_Hat(H_Hat) had to be aborted.
>> B is H(H_Hat, H_Hat) is non-Halting
>> C when H_Hat(H_Hat) is modified, it does not halt.
>>
>> When in actuality, it can be shown A', as when H(H_Hat, H_Hat) is run it
>> halts.
> 
> This is NOT a valid counter-example proving that a decider decides its
> inputs incorrectly:
> 
> int main()
>   H_Halt_(H_Hat)
> 
> Because every counter-example proving that a decider decides its inputs
> incorrectly must itself be an input to this decider that this decider
> decides incorrectly.
> 
> Can you come up with an actual counter-example?
> 
> 

As I said before, and you decided was too 'convoluted' to understand:

// The Halt Detector under test,
bool H(u32 P, u32 I)
{
  bool Halted = false;
  bool Aborted = false;
  while(!Halted && !Aborted)
  {
     Halted = DebugStep(P, I);
     Aborted = Needs_To_Be_Aborted();
  }
  return !Aborted;
}

// Linz's H_Hat
void H_Hat(U32 P)
{
  if(H(P, P))
    Here: goto Here;
  else
    HALT
}

// Version of H without the abort test actually aborting the execution
// For a given input, if the original H returned false, then if it was
// right, this version should end up in an infinite loop.

// We need a separate function so we don't change the program under test.

bool H_T(u32 P, u32 I)
{
  bool Halted = false;
  bool Aborted = false;
  while(!Halted)
  {
     Halted = DebugStep(P, I);
     Aborted = Needs_To_Be_Aborted();
  }
  return !Aborted;
}

// Test program to see if the specifed program will abort,
// Or verify the need to abort reported.

bool Test_H(U32 P, bool test)
{
  if(test)
     return H_T(P, P)
  else
     return H(P, P)
}

int main()
  // This will indicate that H_Hat needed to be aborted
  Test_H(H_Hat, false)
  // This will complete showing that it didn't need to be aborted
  Test_H(H_Hat, true)
}


Maybe you can actually LOOK at it and comment on it?????

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


#25261

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-14 01:48 +0000
Message-ID<87mtzkn1xr.fsf@bsb.me.uk>
In reply to#25256
olcott <NoOne@NoWhere.com> writes:

> On 11/13/2020 4:31 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/13/2020 11:56 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/13/2020 10:24 AM, Richard Damon wrote:
>>>>>> On 11/13/20 11:09 AM, olcott wrote:
>>>>>>> On 11/13/2020 9:51 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> When-so-ever UTM halt decider H decides that:
>>>>>>>>> (1) its input (<P>,I) would never halt unless H stopped simulating it
>>>>>>>>>        and
>>>>>>>>> (2) its input (<P>,I) would never halt unless H stopped simulating it
>>>>>>>>> then H has made a correct not-halting decision on this input.
>>>>>>>>>
>>>>>>>>> Since it does divide all of its inputs into {halting and
>>>>>>>>> not-halting}** it is a halt decider.
>>>>>>>>
>>>>>>>> No, that's not what the halting problem is about.
>>>>>>>>
>>>>>>>
>>>>>>> Sure it is:
>>>>>>>
>>>>>>>       **The Halting problem is a problem in computer science.
>>>>>>>       The problem is looking at a computer program and finding
>>>>>>>       out if the program is going to run forever or not. We say
>>>>>>>       that a program "solves the halting problem" if it can
>>>>>>>       look at any other program and tell if that other program
>>>>>>>       will run forever or not.
>>>>>>>       https://simple.wikipedia.org/wiki/Halting_problem
>>>>>>>
>>>>>>> Glancing at a few of my words for the purpose of contriving some sort of
>>>>>>> rebuttal has not ultimately been a very effective strategy for you.
>>>>>>>
>>>>>>
>>>>>> The key differencne between that and what you say is that this
>>>>>> definition is based on the ACTUAL behavior of the actual program, and
>>>>>> not on what some program did or did not do while analyising the program.
>>>>>>
>>>>>> YOUR definition focuses on what the decider did, not what the program
>>>>>> under test does, and if there is a possible difference, you resolve it
>>>>>> by focusing on the decider, and NOT on the actual program. Thus, you
>>>>>> program is NOT a true Halting Decider.
>>>>>>
>>>>>
>>>>> Since H does divide all of its inputs into {halting and not-halting}
>>>>> it is a halt decider.
>>>>
>>>> It does not, as you yourself have told us.  Given
>>>>
>>>> void H_Hat(u32 P) { if (H(P, P)) while (1); }
>>>>
>>>>> 08 bool H(u32 P, u32 I)
>>>>> 09 {
>>>>> 10   bool Halted  = false;
>>>>> 11   bool Aborted = false;
>>>>> 12   while (!Halted && !Aborted)
>>>>> 13   {
>>>>> 14     Halted  = DebugStep(P, I);
>>>>> 15     Aborted = Needs_To_Be_Aborted();
>>>>> 16   }
>>>>> 17   return !Aborted;
>>>>> 18 }
>>>>
>>>> You have confirmed that H(H_Hat, H_Hat) is false and that H_Hat(H_hat)
>>>> is a finite computation.
>>>
>>> When anyone cites what is purported to be a counter-example to a halt
>>> decider correctly deciding its inputs and this "counter-example" is not
>>> an input to this halt decider they commit the straw-man error of
>>> reasoning.
>>
>> I gave a counter example to H being a halt decider.  It is the pair
>> (H_Hat, H_Hat).  It is "input" (at least as close as your code has to
>> such a thing) to the halt decider H.  
>
>> H gives the wrong answer
>> (according to you).  
>
> You know that I never said that.

If you say, as you have, that H(H_Hat, H_Hat) is false, and that
H_Hat(H_Hat) halts, you are telling the world that H is getting it wrong
on the plain facts of the matter.

> The H that I defined gives the correct answer.

As you know, false is the wrong answer for a finite computation.  We
have entered a Big Brother world where truth has changed its meaning.
"Halting" is no longer about the actual program in question but by
assessing different program:

> H(H_Hat, H_Hat) decides not-halting and all of the not-halting
> decisions can be easily verified as definitely correct by this
> process:

Unfortunately (as you know perfectly well) they must be verified
according to whether they are or are not finite computations, not by the
process of constructing a slightly different computation and assessing
that instead.

> When simply removing the halt deciding capability of H (on line 15)
> results in the infinite execution of all of these inputs this proves
> beyond all doubt what-so-ever that H did decide all of these
> not-halting inputs correctly.

Yes, these other computations, with different embedded H functions,
might indeed behave differently, but as written above, H_Hat(H_Hat) is a
finite computation yet H(H_Hat, H_Hat) reports otherwise.

>> If you are saying that some other function is in fact a halt decider,
>> please actually show it, and I will give you the counter example to it
>> being one.  The same counter-example does not apply to all deciders,
>> though they often look similar.
>
> It seems that you only have rhetoric and misunderstandings.

Unfortunately you have been clear.  You know, from two years ago, that
being clear can only lead to trouble, and so it has this time around
too.  There is no confusion at all about the facts here:

(a) H(H_Hat, H_Hat) == false.

(b) H_Hat(H_hat) is a finite computation.

(c) You say false from this H is correct because a different
    computation, where a different H is embedded in H_Hat, makes
    H_Hat(H_hat) a non-finite computation.

> The halt decider defined above cannot be fooled by the conventional
> halting problem trick so I have at least refuted the conclusion of all
> of these proofs.

H gets the example I gave wrong.  False is the wrong answer for a finite
computation.  You are just too cowardly to say so, or to admit to your
Orwellian tactic of redefining what the right answer is.

I know why you can't admit it -- it would mean 16 or more years down the
tube -- but you should know that by now you look very foolish indeed.
You can not dispute the facts (a) or (b) -- because you yourself
provided them -- but neither can you admit what those facts mean.

You can only restate, again and again, your redefinition of what the
right answer is, whilst trying to suggest that it's the "proper" meaning
of the term.  Saying that explicitly would simply be the end of the
matter because no one cares about your definition.

-- 
Ben.

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


Page 1 of 2  [1] 2  Next page →

Back to top | Article view | comp.theory


csiph-web