Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #25219 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2020-11-13 09:14 -0600 |
| Last post | 2020-11-13 14:18 -0700 |
| Articles | 20 on this page of 34 — 5 participants |
Back to article view | Back to comp.theory
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 →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-13 09:14 -0600 |
| Subject | Refuting 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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-13 22:11 -0600 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-13 22:22 -0600 |
| Subject | Re: 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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-11-14 09:33 -0500 |
| Subject | Re: 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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-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