Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.software-eng > #2472 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-01-05 12:26 -0600 |
| Last post | 2021-01-05 22:43 +0000 |
| Articles | 20 on this page of 113 — 4 participants |
Back to article view | Back to comp.software-eng
This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by
below is the oldest one visible, not the original post.
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] olcott <NoOne@NoWhere.com> - 2021-01-05 12:26 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] olcott <NoOne@NoWhere.com> - 2021-01-05 13:37 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-05 21:15 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] olcott <NoOne@NoWhere.com> - 2021-01-05 15:42 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-05 22:24 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-05 23:00 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-06 07:55 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-06 13:17 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-06 21:48 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-06 16:38 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-07 05:28 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Deceiver?) olcott <NoOne@NoWhere.com> - 2021-01-07 10:00 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-07 13:41 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-07 13:45 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-07 18:11 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-07 17:43 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-08 11:47 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-08 18:00 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-08 11:40 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-08 15:59 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-08 21:53 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-08 23:08 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Jeff Barnett <jbb@notatt.com> - 2021-01-08 22:36 -0700
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-09 05:39 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 12:40 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-09 16:03 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-09 22:28 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-09 16:51 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-09 23:22 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-12 10:06 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 17:15 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-12 12:07 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-11 12:07 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-11 12:18 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-11 18:53 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-11 14:03 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-11 20:19 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](Axiomatic basis) olcott <NoOne@NoWhere.com> - 2021-01-11 20:46 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](Axiomatic basis) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-01-11 22:23 -0800
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 09:36 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 10:23 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 11:06 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](decider defined) olcott <NoOne@NoWhere.com> - 2021-01-12 19:14 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 11:00 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 13:40 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](laser focused) olcott <NoOne@NoWhere.com> - 2021-01-12 18:32 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](actual behavior) olcott <NoOne@NoWhere.com> - 2021-01-12 19:44 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 17:27 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](of a single point) olcott <NoOne@NoWhere.com> - 2021-01-12 12:50 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](of a single point) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 19:51 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](of a single point) olcott <NoOne@NoWhere.com> - 2021-01-12 14:06 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 09:36 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 09:39 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 10:33 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 13:18 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 16:31 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 19:36 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-10 02:10 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 23:12 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-11 12:34 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-11 12:43 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-11 19:01 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 10:31 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 17:32 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 12:59 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 20:07 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 14:49 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-12 16:47 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-01-12 14:50 -0800
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 23:33 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-12 18:10 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-13 00:31 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-12 20:05 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-12 21:07 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-13 15:16 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-13 21:39 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-13 22:34 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 09:08 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 09:32 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 10:48 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-16 15:09 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-14 16:54 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 11:22 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-14 17:33 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 12:10 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-14 19:25 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 12:28 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 18:43 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 20:50 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-13 00:39 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-13 11:10 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-13 14:53 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](the gist of things) olcott <NoOne@NoWhere.com> - 2021-01-13 15:27 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](the gist of things) olcott <NoOne@NoWhere.com> - 2021-01-13 16:22 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) olcott <NoOne@NoWhere.com> - 2021-01-14 09:23 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-14 17:10 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) olcott <NoOne@NoWhere.com> - 2021-01-14 11:26 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) olcott <NoOne@NoWhere.com> - 2021-01-14 11:25 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 20:53 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 19:55 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-13 18:57 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-13 21:21 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-13 22:15 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-14 09:18 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-14 10:41 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-14 12:16 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](gullible fools) olcott <NoOne@NoWhere.com> - 2021-01-16 14:50 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](gullible fools) olcott <NoOne@NoWhere.com> - 2021-01-16 16:04 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](gullible fools) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-17 04:46 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-16 15:23 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] (brain dead morons) olcott <NoOne@NoWhere.com> - 2021-01-05 16:03 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] olcott <NoOne@NoWhere.com> - 2021-01-05 16:10 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-05 22:43 +0000
Page 1 of 6 [1] 2 3 4 5 6 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-05 12:26 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] |
| Message-ID | <6MydnSUEIKOgMmnCnZ2dnUU7-R3NnZ2d@giganews.com> |
On 1/5/2021 11:01 AM, André G. Isaak wrote:
> On 2021-01-04 20:46, olcott wrote:
>> On 1/4/2021 9:39 PM, André G. Isaak wrote:
>>> On 2021-01-04 19:49, olcott wrote:
>>>> On 1/4/2021 8:52 AM, Andy Walker wrote:
>>>>> On 04/01/2021 12:10, Richard Damon wrote:
>>>>>> So if detecting the recursion can't be done, then part of PO's
>>>>>> trick is
>>>>>> the passing of pointer to functions as an address rather than
>>>>>> actually
>>>>>> passing an input 'tape'. This allows him to trivially solve the
>>>>>> recursion detection.
>>>>>
>>>>> No, that isn't, in itself, a "trick". After all, we don't
>>>>> expect a compiler to make extra copies of the function code whenever
>>>>> a function is called. A TM has access to the same methods that a
>>>>> real computer has for enabling function calls and recursion -- stash
>>>>> away return addresses, stack parameters, put return values onto the
>>>>> stack, blah-de-blah. ...
>>>>>
>>>>
>>>> Thanks for adding some real software engineering to this dialogue.
>>>>
>>>>>> This says that the REAL problem with his proof is that his 'UTM'
>>>>>> doesn't
>>>>>> fully support the operation of 'make a copy of the input', and
>>>>>> thus is
>>>>>> shown to not be a Turing Complete environment.
>>>>>
>>>>> ... The real problems are (a) recursion is not the only way
>>>>> a program can fail to halt;
>>>>
>>>> I don't have to solve the halting problem to refute the conventional
>>>> proofs. My system already detects some cases of infinte loops.
>>>>
>>>>> and (b) PO's recursion detection works
>>>>> only in very trivial cases. Oh, and of course
>>>>
>>>> No sense making the system more elaborate than required to refute
>>>> the conventional proofs. This would only confuse people making it
>>>> more difficult for them to see that I refuted the conventional proofs.
>>>>
>>>>> (c) the fact that his
>>>>> "H_hat" doesn't [yet] correspond to his "H" in the correct way;
>>>>
>>>> Bullshit. My Halts() corresponds to my H_Hat() in the simplest "do
>>>> the opposite of whatever the halt decider decides" template that all
>>>> the conventional halting problem proofs are based on.
>>>
>>> The problem is that your Halts() function isn't the totality of your
>>> decider. It's simply a function -- you have all this other 'global'
>>> code which you haven't ever shown which somehow wraps itself around
>>> main. Your H_Hat has to be derived from *that* code, not from the
>>> Halts() function.
>>>
>>> André
>>
>> All this code is finally working correctly now.
>> It is not as you describe.
>
> Since you've never provided the code, all we have to go on is your
> descriptions. If it is not as I describe, then perhaps you can describe
> how it actually is. In particular, what is the difference between your
> 'global' and 'local' decider and why is it necessary to make such a
> distinction in the first place. We don't make such a distinction for any
> other mathematical function such as sqrt(), so why does Halts() require
> this?
>
> André
>
The key reason why I need three halt deciding modes is so that people
can see the nuanced details of what is really going on with this case:
int main()
{
H_Hat((u32)H_Hat);
}
I am focusing my attention on completing the code because the code
speaks for itself.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-05 13:37 -0600 |
| Message-ID | <m5OdndGhUYyPXWnCnZ2dnUU7-c_NnZ2d@giganews.com> |
| In reply to | #2472 |
On 1/5/2021 1:15 PM, Kaz Kylheku wrote:
> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>> The key reason why I need three halt deciding modes is so that people
>> can see the nuanced details of what is really going on with this case:
>
> Your results are invalid if you don't follow these requirements,
> (and possibly even if you do):
>
The above statement is moronically stupid when understood within this
context:
Without (the mandatory prerequisite of) carefully studying the full
execution trace of this code:
int main()
{
H_Hat((u32)H_Hat);
HALT
}
in all three halt decider modes: {disabled, local, global}
while carefully looking for any error and finding none:
The above statement is moronically stupid
It is just as stupid as counting as evidence the effect of the damned
lies of a God damned liar that there was any actual discrepancies with
integrity of the presidential election.
Trump knows damn well the any president with approval ratings
consistently under water by a large margin defines "election loser" in a
Democracy.
https://projects.fivethirtyeight.com/trump-approval-ratings/
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-01-05 21:15 +0000 |
| Message-ID | <20210105130908.810@kylheku.com> |
| In reply to | #2473 |
["Followup-To:" header set to comp.theory.]
On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
> On 1/5/2021 1:15 PM, Kaz Kylheku wrote:
>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>> The key reason why I need three halt deciding modes is so that people
>>> can see the nuanced details of what is really going on with this case:
>>
>> Your results are invalid if you don't follow these requirements,
>> (and possibly even if you do):
>>
>
> The above statement is moronically stupid when understood within this
> context:
Note that I included the part in parentheses due to my lingering
suspicion that you don't understand logical if/then conditionals.
I'm emphasizing that the requirements I stated are necessary, not
sufficient.
> Without (the mandatory prerequisite of) carefully studying the full
> execution trace of this code:
>
> int main()
> {
> H_Hat((u32)H_Hat);
> HALT
> }
>
> in all three halt decider modes: {disabled, local, global}
>
> while carefully looking for any error and finding none:
> The above statement is moronically stupid
But the statement along with the requirements it refers to is not in
confict with what you're saying here.
The first requirement just says: you can't interpret the traces
under one mode (e.g. local) as pertaining to the halting of
H_Hat(H_Hat) in any other mode (e.g. disabled).
Study all the traces you want; just don't mix modes.
--
TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-05 15:42 -0600 |
| Message-ID | <vZadnfU_JNnDQGnCnZ2dnUU7-KvNnZ2d@giganews.com> |
| In reply to | #2474 |
On 1/5/2021 3:15 PM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>> On 1/5/2021 1:15 PM, Kaz Kylheku wrote:
>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>> The key reason why I need three halt deciding modes is so that people
>>>> can see the nuanced details of what is really going on with this case:
>>>
>>> Your results are invalid if you don't follow these requirements,
>>> (and possibly even if you do):
>>>
>>
>> The above statement is moronically stupid when understood within this
>> context:
>
> Note that I included the part in parentheses due to my lingering
> suspicion that you don't understand logical if/then conditionals.
>
> I'm emphasizing that the requirements I stated are necessary, not
> sufficient.
>
>> Without (the mandatory prerequisite of) carefully studying the full
>> execution trace of this code:
>>
>> int main()
>> {
>> H_Hat((u32)H_Hat);
>> HALT
>> }
>>
>> in all three halt decider modes: {disabled, local, global}
>>
>> while carefully looking for any error and finding none:
>> The above statement is moronically stupid
>
> But the statement along with the requirements it refers to is not in
> confict with what you're saying here.
>
> The first requirement just says: you can't interpret the traces
> under one mode (e.g. local) as pertaining to the halting of
> H_Hat(H_Hat) in any other mode (e.g. disabled).
>
> Study all the traces you want; just don't mix modes.
>
When the execution trace of this code:
(full source code provided)
int main()
{
H_Hat((u32)H_Hat);
}
Is carefully examined looking for coding or logic errors then the
non-existence of coding or logic errors proves that the halt decider
does decide the above code correctly as infinitely recursive in global
mode and the input to H_Hat() as infinitely recursive in local mode.
Without having the full (hundreds of pages) of execution trace and all
the source code the correct assessment of the halt decider's decision is
over everyone's head.
People may still "believe" that the halt decider decides inconsistently
yet the fact that it is impossible to point to any logic or coding error
(because none exist) proves that this belief is vacuous.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-01-05 22:24 +0000 |
| Message-ID | <20210105140850.684@kylheku.com> |
| In reply to | #2475 |
["Followup-To:" header set to comp.theory.]
On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
> On 1/5/2021 3:15 PM, Kaz Kylheku wrote:
>> ["Followup-To:" header set to comp.theory.]
>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>> On 1/5/2021 1:15 PM, Kaz Kylheku wrote:
>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>> The key reason why I need three halt deciding modes is so that people
>>>>> can see the nuanced details of what is really going on with this case:
>>>>
>>>> Your results are invalid if you don't follow these requirements,
>>>> (and possibly even if you do):
>>>>
>>>
>>> The above statement is moronically stupid when understood within this
>>> context:
>>
>> Note that I included the part in parentheses due to my lingering
>> suspicion that you don't understand logical if/then conditionals.
>>
>> I'm emphasizing that the requirements I stated are necessary, not
>> sufficient.
>>
>>> Without (the mandatory prerequisite of) carefully studying the full
>>> execution trace of this code:
>>>
>>> int main()
>>> {
>>> H_Hat((u32)H_Hat);
>>> HALT
>>> }
>>>
>>> in all three halt decider modes: {disabled, local, global}
>>>
>>> while carefully looking for any error and finding none:
>>> The above statement is moronically stupid
>>
>> But the statement along with the requirements it refers to is not in
>> confict with what you're saying here.
>>
>> The first requirement just says: you can't interpret the traces
>> under one mode (e.g. local) as pertaining to the halting of
>> H_Hat(H_Hat) in any other mode (e.g. disabled).
>>
>> Study all the traces you want; just don't mix modes.
>>
>
> When the execution trace of this code:
> (full source code provided)
>
> int main()
> {
> H_Hat((u32)H_Hat);
> }
>
> Is carefully examined looking for coding or logic errors then the
> non-existence of coding or logic errors proves that the halt decider
> does decide the above code correctly as infinitely recursive in global
> mode and the input to H_Hat() as infinitely recursive in local mode.
H_Hat isn't infinitely recursive in local mode, because Halts isn't.
So the decision is wrong.
Halts isn't recursive because it makes a decision: it stops and
returns a value.
What the program is saying is that a different H_Hat(H_Hat) is
infinitely recursive: a H_Hat(H_Hat) running in disabled mode.
The decision is correct that way, but it doesn't invalidate any proof,
because the required self-reference is not replicated.
The decider which is saying that the disabled-mode H_Hat(H_Hat)
fails to halt is not the decider which that H_Hat(H_Hat) calls.
The disabled-mode H_Hat(H_Hat) call invokes the disabled-mode
Halts(P, P).
The local-mode Halts(H_Hat, H_Hat) returns 0, indicating that
the disabled-mode H_Hat(H_Hat) fails to halt.
The local-mode Halts is different from the disabled-mode halts. It may
be the same compiled code, but the machine it runs on has different
behavior in its instruction set, such that what looks like exactly the
same function call can return in one mode, or fail to return in the
other.
The proof doesn't say H_Hat(H_Hat) cannot be decided absolutely,
but only by that specific decider: the exact same one that H_Hat
integrates and calls.
> Without having the full (hundreds of pages) of execution trace and all
> the source code the correct assessment of the halt decider's decision is
> over everyone's head.
Nope; it's *because* you have that execution trace that it's over your
own head, and nobody else's.
You've confused and bamboozled ourself with your own program.
> People may still "believe" that the halt decider decides inconsistently
> yet the fact that it is impossible to point to any logic or coding error
> (because none exist) proves that this belief is vacuous.
I believe that what I understand to be the "local" and "disabled" modes
allow (or can do so, in any case) the Halt decider to be a function
which consistently returns a value based only on its two arguments
(which are immutable code).
You've not demonstrated any traces from a single program, all operating
in the same mode, which shows that H_Hat(H_Hat) actually behaves in the
way that Halts(H_Hat, H_Hat) decides.
I.e.
1. Call Halts(H_Hat, H_Hat), and log the return value on ouput.
2. Then call H_Hat(H_Hat). Also inside that function, log the value *it*
obtains from Halts(P, P), before doing anything else, to confirm it
is getting the same one.
3. Also include a debug trace after the call to H_Hat(H_Hat) to positively
confirm if/when it terminates.
I posted such a program several times, but you refused to try it.
--
TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-05 23:00 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <KdKdnRiWV4Zn3mjCnZ2dnUU7-S3NnZ2d@giganews.com> |
| In reply to | #2478 |
On 1/5/2021 5:52 PM, Kaz Kylheku wrote:
> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>> On 1/5/2021 4:24 PM, Kaz Kylheku wrote:
>>> ["Followup-To:" header set to comp.theory.]
>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>> On 1/5/2021 3:15 PM, Kaz Kylheku wrote:
>>>>> ["Followup-To:" header set to comp.theory.]
>>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 1/5/2021 1:15 PM, Kaz Kylheku wrote:
>>>>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> The key reason why I need three halt deciding modes is so that people
>>>>>>>> can see the nuanced details of what is really going on with this case:
>>>>>>>
>>>>>>> Your results are invalid if you don't follow these requirements,
>>>>>>> (and possibly even if you do):
>>>>>>>
>>>>>>
>>>>>> The above statement is moronically stupid when understood within this
>>>>>> context:
>>>>>
>>>>> Note that I included the part in parentheses due to my lingering
>>>>> suspicion that you don't understand logical if/then conditionals.
>>>>>
>>>>> I'm emphasizing that the requirements I stated are necessary, not
>>>>> sufficient.
>>>>>
>>>>>> Without (the mandatory prerequisite of) carefully studying the full
>>>>>> execution trace of this code:
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> H_Hat((u32)H_Hat);
>>>>>> HALT
>>>>>> }
>>>>>>
>>>>>> in all three halt decider modes: {disabled, local, global}
>>>>>>
>>>>>> while carefully looking for any error and finding none:
>>>>>> The above statement is moronically stupid
>>>>>
>>>>> But the statement along with the requirements it refers to is not in
>>>>> confict with what you're saying here.
>>>>>
>>>>> The first requirement just says: you can't interpret the traces
>>>>> under one mode (e.g. local) as pertaining to the halting of
>>>>> H_Hat(H_Hat) in any other mode (e.g. disabled).
>>>>>
>>>>> Study all the traces you want; just don't mix modes.
>>>>>
>>>>
>>>> When the execution trace of this code:
>>>> (full source code provided)
>>>>
>>>> int main()
>>>> {
>>>> H_Hat((u32)H_Hat);
>>>> }
>>>>
>>>> Is carefully examined looking for coding or logic errors then the
>>>> non-existence of coding or logic errors proves that the halt decider
>>>> does decide the above code correctly as infinitely recursive in global
>>>> mode and the input to H_Hat() as infinitely recursive in local mode.
>>>
>>> H_Hat isn't infinitely recursive in local mode, because Halts isn't.
>>> So the decision is wrong.
>> You might be bright enough to understand what pathological
>> self-reference is, how it screws up reasoning, and how it can be overcome.
>
> The self-reference in the halting proofs isn't pathological. It is midly
> ironic, at best. And in fact, I will argue that it isn't self-reference.
// P is the machine address of H_Hat()
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
Here is a multiple choice question for you please don't pull the same
dishonest dodge crap that Ben does:
Is the value that Halts() can correctly return to H_Hat()
(a) true
(b) false
(c) neither true nor false
Although you can provide commentary after your multiple choice
selection, failing to choose one of the three options above will cause
me to conclude that you are deceitful and no longer worth my time.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-01-06 07:55 +0000 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <20210105211352.322@kylheku.com> |
| In reply to | #2480 |
["Followup-To:" header set to comp.theory.]
On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
> On 1/5/2021 5:52 PM, Kaz Kylheku wrote:
>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>> On 1/5/2021 4:24 PM, Kaz Kylheku wrote:
>>>> ["Followup-To:" header set to comp.theory.]
>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 1/5/2021 3:15 PM, Kaz Kylheku wrote:
>>>>>> ["Followup-To:" header set to comp.theory.]
>>>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 1/5/2021 1:15 PM, Kaz Kylheku wrote:
>>>>>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> The key reason why I need three halt deciding modes is so that people
>>>>>>>>> can see the nuanced details of what is really going on with this case:
>>>>>>>>
>>>>>>>> Your results are invalid if you don't follow these requirements,
>>>>>>>> (and possibly even if you do):
>>>>>>>>
>>>>>>>
>>>>>>> The above statement is moronically stupid when understood within this
>>>>>>> context:
>>>>>>
>>>>>> Note that I included the part in parentheses due to my lingering
>>>>>> suspicion that you don't understand logical if/then conditionals.
>>>>>>
>>>>>> I'm emphasizing that the requirements I stated are necessary, not
>>>>>> sufficient.
>>>>>>
>>>>>>> Without (the mandatory prerequisite of) carefully studying the full
>>>>>>> execution trace of this code:
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> H_Hat((u32)H_Hat);
>>>>>>> HALT
>>>>>>> }
>>>>>>>
>>>>>>> in all three halt decider modes: {disabled, local, global}
>>>>>>>
>>>>>>> while carefully looking for any error and finding none:
>>>>>>> The above statement is moronically stupid
>>>>>>
>>>>>> But the statement along with the requirements it refers to is not in
>>>>>> confict with what you're saying here.
>>>>>>
>>>>>> The first requirement just says: you can't interpret the traces
>>>>>> under one mode (e.g. local) as pertaining to the halting of
>>>>>> H_Hat(H_Hat) in any other mode (e.g. disabled).
>>>>>>
>>>>>> Study all the traces you want; just don't mix modes.
>>>>>>
>>>>>
>>>>> When the execution trace of this code:
>>>>> (full source code provided)
>>>>>
>>>>> int main()
>>>>> {
>>>>> H_Hat((u32)H_Hat);
>>>>> }
>>>>>
>>>>> Is carefully examined looking for coding or logic errors then the
>>>>> non-existence of coding or logic errors proves that the halt decider
>>>>> does decide the above code correctly as infinitely recursive in global
>>>>> mode and the input to H_Hat() as infinitely recursive in local mode.
>>>>
>>>> H_Hat isn't infinitely recursive in local mode, because Halts isn't.
>>>> So the decision is wrong.
>>> You might be bright enough to understand what pathological
>>> self-reference is, how it screws up reasoning, and how it can be overcome.
>>
>> The self-reference in the halting proofs isn't pathological. It is midly
>> ironic, at best. And in fact, I will argue that it isn't self-reference.
>
>
> // P is the machine address of H_Hat()
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> return;
> }
>
> Here is a multiple choice question for you please don't pull the same
> dishonest dodge crap that Ben does:
> "Is the value that Halts() can correctly return to H_Hat()"
(for P = H_Hat, of course)
> (a) true
> (b) false
> (c) neither true nor false
It has to be (c).
A definition of Halts that returns a correct value doesn't exist.
A function that doesn't exist doesn't return anything.
That eliminates (a) and (b).
(c) can be interpretated as re-iterating the fact that (a) and (b)
are eliminated, which makes (c) true. A function that doesn't exist
returns neither true nor false.
This is exactly the same as:
"Is the camel which can climb a tree ..."
(a) dromedary
(b) bactrian
(c) neither dromedary nor bactrian
The answer has to be (c).
(c) is the only choice which is consistent with there there not existing
a tree-climbing camel. If something can climb a tree, it is not a camel;
if it is not a camel, it is neither bactrian nor dromedary.
If there is any pathology, it's coming from the question, not from
the domain of discourse.
The question is pathological because he way it is worded suggests that
there exists a camel which can climb a tree, and inquires about that
camel's properties, but a nonexistent object has no properties to speak
of. The elements of a set individually have properties. An empty set has
no elements and so no objects with properties.
Likewise, your question is pathological in the same way because it
suggests that a Halts definition exists which returns a correct value,
and then it asks about its Boolean property: which of the two values
that is.
The pathology is introduced by the way you chose to ask the question,
not by the the problem domain itself. The problem domain contains no
such question in that form.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-06 13:17 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <V_SdnRraJbxfkWvCnZ2dnUU7-XHNnZ2d@giganews.com> |
| In reply to | #2481 |
On 1/6/2021 1:55 AM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
>> On 1/5/2021 5:52 PM, Kaz Kylheku wrote:
>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>> On 1/5/2021 4:24 PM, Kaz Kylheku wrote:
>>>>> ["Followup-To:" header set to comp.theory.]
>>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 1/5/2021 3:15 PM, Kaz Kylheku wrote:
>>>>>>> ["Followup-To:" header set to comp.theory.]
>>>>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> On 1/5/2021 1:15 PM, Kaz Kylheku wrote:
>>>>>>>>> On 2021-01-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> The key reason why I need three halt deciding modes is so that people
>>>>>>>>>> can see the nuanced details of what is really going on with this case:
>>>>>>>>>
>>>>>>>>> Your results are invalid if you don't follow these requirements,
>>>>>>>>> (and possibly even if you do):
>>>>>>>>>
>>>>>>>>
>>>>>>>> The above statement is moronically stupid when understood within this
>>>>>>>> context:
>>>>>>>
>>>>>>> Note that I included the part in parentheses due to my lingering
>>>>>>> suspicion that you don't understand logical if/then conditionals.
>>>>>>>
>>>>>>> I'm emphasizing that the requirements I stated are necessary, not
>>>>>>> sufficient.
>>>>>>>
>>>>>>>> Without (the mandatory prerequisite of) carefully studying the full
>>>>>>>> execution trace of this code:
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> H_Hat((u32)H_Hat);
>>>>>>>> HALT
>>>>>>>> }
>>>>>>>>
>>>>>>>> in all three halt decider modes: {disabled, local, global}
>>>>>>>>
>>>>>>>> while carefully looking for any error and finding none:
>>>>>>>> The above statement is moronically stupid
>>>>>>>
>>>>>>> But the statement along with the requirements it refers to is not in
>>>>>>> confict with what you're saying here.
>>>>>>>
>>>>>>> The first requirement just says: you can't interpret the traces
>>>>>>> under one mode (e.g. local) as pertaining to the halting of
>>>>>>> H_Hat(H_Hat) in any other mode (e.g. disabled).
>>>>>>>
>>>>>>> Study all the traces you want; just don't mix modes.
>>>>>>>
>>>>>>
>>>>>> When the execution trace of this code:
>>>>>> (full source code provided)
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> H_Hat((u32)H_Hat);
>>>>>> }
>>>>>>
>>>>>> Is carefully examined looking for coding or logic errors then the
>>>>>> non-existence of coding or logic errors proves that the halt decider
>>>>>> does decide the above code correctly as infinitely recursive in global
>>>>>> mode and the input to H_Hat() as infinitely recursive in local mode.
>>>>>
>>>>> H_Hat isn't infinitely recursive in local mode, because Halts isn't.
>>>>> So the decision is wrong.
>>>> You might be bright enough to understand what pathological
>>>> self-reference is, how it screws up reasoning, and how it can be overcome.
>>>
>>> The self-reference in the halting proofs isn't pathological. It is midly
>>> ironic, at best. And in fact, I will argue that it isn't self-reference.
>>
>>
>> // P is the machine address of H_Hat()
>> void H_Hat(u32 P)
>> {
>> u32 Input_Halts = Halts(P, P);
>> if (Input_Halts)
>> HERE: goto HERE;
>> return;
>> }
>>
>> Here is a multiple choice question for you please don't pull the same
>> dishonest dodge crap that Ben does:
>
>> "Is the value that Halts() can correctly return to H_Hat()"
>
> (for P = H_Hat, of course)
>
>> (a) true
>> (b) false
>> (c) neither true nor false
>
> It has to be (c).
>
> A definition of Halts that returns a correct value doesn't exist.
>
> A function that doesn't exist doesn't return anything.
>
> That eliminates (a) and (b).
>
> (c) can be interpretated as re-iterating the fact that (a) and (b)
> are eliminated, which makes (c) true. A function that doesn't exist
> returns neither true nor false.
>
> This is exactly the same as:
>
> "Is the camel which can climb a tree ..."
>
> (a) dromedary
> (b) bactrian
> (c) neither dromedary nor bactrian
>
> The answer has to be (c).
>
Great! Now when I define my terms it will be easier to see what I mean:
Pathological Self-Reference(Olcott 2004)
is defined as the case where a
(a) declarative sentence,
(b) polar question,
(c) logical proposition
cannot be resolved to yes/no true/false because of self-reference.
When we ask the polar question:
What Boolean value can Halts() correctly return to H_Hat()
we see that this question has Pathological Self-Reference(Olcott 2004).
> (c) is the only choice which is consistent with there there not existing
> a tree-climbing camel. If something can climb a tree, it is not a camel;
> if it is not a camel, it is neither bactrian nor dromedary.
>
> If there is any pathology, it's coming from the question, not from
> the domain of discourse.
>
>> // P is the machine address of H_Hat()
>> void H_Hat(u32 P)
>> {
>> u32 Input_Halts = Halts(P, P);
>> if (Input_Halts)
>> HERE: goto HERE;
>> return;
>> }
The question is hard-wired into the conventional undecidability proof
trick of "do the opposite of whatever the halt decider decides"
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. http://www.liarparadox.org/sipser_165.pdf
Sipser, Michael 1997. Introduction to the Theory of Computation. Boston:
PWS Publishing Company (165-167)
> The question is pathological because he way it is worded suggests that
> there exists a camel which can climb a tree, and inquires about that
"do the opposite of whatever the halt decider decides" as an integral
aspect of the undecidability proof places Pathological
Self-Reference(Olcott 2004) as an integral part of this proof itself.
> camel's properties, but a nonexistent object has no properties to speak
> of. The elements of a set individually have properties. An empty set has
> no elements and so no objects with properties.
>
> Likewise, your question is pathological in the same way because it
> suggests that a Halts definition exists which returns a correct value,
> and then it asks about its Boolean property: which of the two values
> that is.
>
When we consider which of the two values that Halts() can return to
H_Hat() the correct answer is neither because the invocation of Halts()
by H_Hat() would be infinitely recursive if Halts() did not abort this
invocation.
There is never ever any case where any function can ever correctly
return a value to its infinitely recursive invocation, not even if we
sprinkle magic fairy dust.
Although a decider must always eventually indicate a decision it is not
required to return a result to every caller. That so many people in this
forum seemed to think otherwise seems quite nuts. They might as well
have said that all infinite loops only iterate ten times.
The term decider doesn't really have a standard meaning.
In fact, it is lamentable that Sipser chose the terms
decider and recognizer, since they seem to confuse students.
Yuval Filmus
Assistant Professor in the Henry and Marilyn Taub Department
of Computer Science at the Technion – Israel Institute of
Technology.
https://cs.stackexchange.com/questions/84433/what-is-decider
> The pathology is introduced by the way you chose to ask the question,
> not by the the problem domain itself. The problem domain contains no
> such question in that form.
>
The question is hard-wired into the conventional undecidability proof
trick of "do the opposite of whatever the halt decider decides"
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-01-06 21:48 +0000 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <20210106132650.676@kylheku.com> |
| In reply to | #2482 |
On 2021-01-06, olcott <NoOne@NoWhere.com> wrote: > Great! Now when I define my terms it will be easier to see what I mean: > > Pathological Self-Reference(Olcott 2004) > is defined as the case where a > (a) declarative sentence, > (b) polar question, > (c) logical proposition > cannot be resolved to yes/no true/false because of self-reference. Suit yourself. > When we ask the polar question: > What Boolean value can Halts() correctly return to H_Hat() Nobody is asking that question though; that's a loaded question you invented, similar to "have you stopped beating your wife". The correct question is: "does there exist a function Halts which can be embedded into H_Hat, and return a correct value when P = H_Hat?" That question has a straightforward "no" answer. Just like "does there exist a tree-climbing camel?" Moreover, if Halts returns, it has a stable true or false value. Whether or not H_Hat(H_hat) halts or not is also determined as true or false. So this has nothing to do with a self-referential logical proposition whose Boolean value cannot be established. No logical propositions are being abused in any way, like in the Liar Paradox. > we see that this question has Pathological Self-Reference(Olcott 2004). All you have done is invent an idiotically worded question, equivalent to "is a nonexistent camel bactrian or dromedary"? No such question is used in serious literature about the halting problem. Nobody calling themselves a mathematician would blab about what a function "can" return. Functions only denote mappings from inputs to outputs; there is no "can" or "cannot".
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-06 16:38 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <c-qdnTCYheVFpmvCnZ2dnUU7-UvNnZ2d@giganews.com> |
| In reply to | #2483 |
On 1/6/2021 3:48 PM, Kaz Kylheku wrote: > On 2021-01-06, olcott <NoOne@NoWhere.com> wrote: >> Great! Now when I define my terms it will be easier to see what I mean: >> >> Pathological Self-Reference(Olcott 2004) >> is defined as the case where a >> (a) declarative sentence, >> (b) polar question, >> (c) logical proposition >> cannot be resolved to yes/no true/false because of self-reference. > > Suit yourself. > >> When we ask the polar question: >> What Boolean value can Halts() correctly return to H_Hat() > > Nobody is asking that question though; that's a loaded question you > invented, similar to "have you stopped beating your wife". > > The correct question is: "does there exist a function Halts which can > be embedded into H_Hat, and return a correct value when P = H_Hat?" > That question has a straightforward "no" answer. > > Just like "does there exist a tree-climbing camel?" > > Moreover, if Halts returns, it has a stable true or false value. > > Whether or not H_Hat(H_hat) halts or not is also determined as true or > false. > > So this has nothing to do with a self-referential logical proposition > whose Boolean value cannot be established. No logical propositions are > being abused in any way, like in the Liar Paradox. > >> we see that this question has Pathological Self-Reference(Olcott 2004). > > All you have done is invent an idiotically worded question, > equivalent to "is a nonexistent camel bactrian or dromedary"? > > No such question is used in serious literature about the halting > problem. > > Nobody calling themselves a mathematician would blab about what > a function "can" return. Functions only denote mappings from inputs to > outputs; there is no "can" or "cannot". > The question is hard-wired into the conventional undecidability proof trick of "do the opposite of whatever the halt decider decides" "do the opposite of whatever the halt decider decides" "do the opposite of whatever the halt decider decides" "do the opposite of whatever the halt decider decides" "do the opposite of whatever the halt decider decides" 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. http://www.liarparadox.org/sipser_165.pdf Sipser, Michael 1997. Introduction to the Theory of Computation. Boston: PWS Publishing Company (165-167) This makes all the conventional HP undecidability proofs based on Pathological Self-Reference(Olcott 2004) This makes all the conventional HP undecidability proofs based on Pathological Self-Reference(Olcott 2004) This makes all the conventional HP undecidability proofs based on Pathological Self-Reference(Olcott 2004) This makes all the conventional HP undecidability proofs based on Pathological Self-Reference(Olcott 2004) This makes all the conventional HP undecidability proofs based on Pathological Self-Reference(Olcott 2004) -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-01-07 05:28 +0000 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <20210106145623.388@kylheku.com> |
| In reply to | #2484 |
On 2021-01-06, olcott <NoOne@NoWhere.com> wrote: > The question is hard-wired into the conventional undecidability proof > trick of No, it isn't. Not any more than the "have you stopped beating your wife" question is hard-wired into the psychology of marriage. It's just nonsense that you're insisting on. Nobody in their right mind asks whether a function that doesn't exist returns true or false, or whether a nonexistent camel is dromedary or bactrian, or whether someone not known to beat their wife (or not even married) has stopped beating their wife. Pretending that the phrase "nonexistent function" refers to a real object, which has to have real properties (like returning true or false) is just word semantic nonsense. It's purely a verbal construct you've come up with. You've confused map and territory. The map you're choosing to view the territory and explain it to yourself is incorrect and pathological, not the territory.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-07 10:00 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Deceiver?) |
| Message-ID | <NfednYH41NqNrWrCnZ2dnUU7-VXNnZ2d@giganews.com> |
| In reply to | #2485 |
On 1/6/2021 11:28 PM, Kaz Kylheku wrote:
> On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
>> The question is hard-wired into the conventional undecidability proof
>> trick of
>
> No, it isn't. Not any more than the "have you stopped beating your wife"
> question is hard-wired into the psychology of marriage.
>
Choosing to interpret [the logical law of polar questions] as pertaining
to psychology of marriage instead of the formal semantics of natural
language is the same king of intentionally deceiptful crap that Ben
always pulls.
Have you decided to become a God damned liar?
sci.lang
Peter Olcott
Feb 20, 2015, 11:38:48 AM
The logical law of polar questions
When posed to a man whom has never been married,
the question: Have you stopped beating your wife?
Is an incorrect polar question because neither yes nor
no is a correct answer.
All polar questions (including incorrect polar questions)
have exactly one answer from the following:
1) No
2) Yes
3) Neither // Only applies to incorrect polar questions
As far as I know I am the original discoverer of the
above logical law, thus copyright 2015 by Peter Olcott.
Permission to copy and freely distribute the above
is hereby granted as long as it is distributed in
its entirely including this license agreement.
https://groups.google.com/g/sci.lang/c/AO5Vlupeelo/m/nxJy7N2vULwJ
> It's just nonsense that you're insisting on.
>
> Nobody in their right mind asks whether a function that doesn't exist
> returns true or false, or whether a nonexistent camel is dromedary or
> bactrian, or whether someone not known to beat their wife (or not even
> married) has stopped beating their wife.
By your same screwy reasoning no one would ever talk about the liar
paradox because the fact that it is not true causes it to cease to exist.
Pathological Self-Reference(Olcott 2004)
is defined as the case where a
(a) declarative sentence,
(b) polar question,
(c) logical proposition
cannot be resolved to yes/no true/false because of self-reference.
The above phenomenon does not cause expressions of formal or natural
language to cease to exist, it causes them to be logically incoherent.
> Pretending that the phrase "nonexistent function" refers to a real
> object, which has to have real properties (like returning true or
> false) is just word semantic nonsense.
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
When math looks at the halting problem counter example within
existential quantification math concludes that there is no mathematical
mapping from the above invocation of Halts() to a return value to
H_Hat() of true or false.
Pathological Self-Reference(Olcott 2004)
Explains why no such mapping exists.
The great error in your analysis is conflating the technical term of the
art of existential quantification with the common meaning of the term
existence. Gullible people would be fooled by such a ruse. Ben tried
this same deceptive crap.
When math says that a function does not exist math is only saying that a
specific mathematical mapping does not exist.
When we know this and avoid the fallacy of equivocation error thenn
(then and only then) we can ask: What prevents the mathematical mapping
from existing?
The answer to this question is that the logical incoherence of
Pathological Self-Reference(Olcott 2004) prevents the mapping from
existing.
> It's purely a verbal construct you've come up with.
>
> You've confused map and territory. The map you're choosing to view the
> territory and explain it to yourself is incorrect and pathological, not
> the territory.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-07 13:41 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) |
| Message-ID | <KPGdnTx3ipdh_mrCnZ2dnUU7-e3NnZ2d@giganews.com> |
| In reply to | #2485 |
On 1/7/2021 1:25 PM, André G. Isaak wrote:
> On 2021-01-07 12:05, olcott wrote:
>> On 1/7/2021 5:57 AM, Ben Bacarisse wrote:
>>> Kaz Kylheku <563-365-8930@kylheku.com> writes:
>>>
>>>> On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
>>>>> The question is hard-wired into the conventional undecidability proof
>>>>> trick of
>>>>
>>>> No, it isn't. Not any more than the "have you stopped beating your
>>>> wife"
>>>> question is hard-wired into the psychology of marriage.
>>>>
>>>> It's just nonsense that you're insisting on.
>>>>
>>>> Nobody in their right mind asks whether a function that doesn't exist
>>>> returns true or false, or whether a nonexistent camel is dromedary or
>>>> bactrian, or whether someone not known to beat their wife (or not even
>>>> married) has stopped beating their wife.
>>>>
>>>> Pretending that the phrase "nonexistent function" refers to a real
>>>> object, which has to have real properties (like returning true or
>>>> false) is just word semantic nonsense.
>>>
>>> The trouble PO has is that "the function" clearly exists. He's written
>>> it, and he can see that neither return value can be right.
>>>
>>> Don't get me wrong -- I do understand what you are saying. "The
>>> function" that does not exist is a correct halt decider (that's the CS
>>> point of view) but PO is thinking like an engineer. He has actual code.
>>> For him "the function" is that real, actual code and, at some level, it
>>> just appeared to have "a bug" in that it gives the wrong answer in some
>>> cases. But he can now see that this bug can't be fixed. To an
>>> engineer, an unfixable bug means there is something wrong with the
>>> specification.
>>>
>>> This is why I hate the argument that Linz presents, even if he does so
>>> only for historical interest. To engineers (and most software people
>>> have been taught to think like engineers) the "assume H is a halt
>>> decider" style of proof makes it simply too easy to think that there's a
>>> function with an, apparently, unfixable bug. A class of engineers will
>>> spend a lot of time trying to fix the bug and, failing that, try to find
>>> out what's wrong with the specification.
>>>
>>> The other proof in Linz is also problematic for a class of engineers
>>> because it is so abstract. Like a lot of mathematical proofs it's hard
>>> to see how it explains the "why". It's just a bald fact -- a halt
>>> decider would contradict theorem 11.5 (or whatever). That's why I
>>> preferred the diagonal argument: every TM computes a function (sometimes
>>> a partial one) but every TM has the property that the function it
>>> computes is not the halting function. Nothing nonexistent is ever
>>> imagined, we simply learn something universal about TMs.
>>>
>>
>> void H_Hat(u32 P)
>> {
>> u32 Input_Halts = Halts(P, P);
>> if (Input_Halts)
>> HERE: goto HERE;
>> return;
>> }
>>
>> The diagonal argument only shows that neither true nor false is a
>> correct value that Halts() can return to H_Hat().
>>
>> This shallow analysis utterly ignores the possibility that H_Hat() can
>> be correctly decided by aborting the simulation of H_Hat before
>> Halts() returns any value to H_Hat() on the basis that the H_Hat()
>> invocation of Halts() would otherwise be infinitely recursive if
>> Halts() did not stop simulating it.
>>
>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>> > A computation that would not halt if its simulation were not
>> > halted is indeed a non-halting computation.
>>
>>
>> int main()
>> {
>> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>> }
>>
>> What is decider?
>>
>> The term decider doesn't really have a standard meaning.
>> In fact, it is lamentable that Sipser chose the terms decider
>> and recognizer, since they seem to confuse students.
>>
>> Intuitively, a decider should be a Turing machine that given
>> an input, halts and either accepts or rejects, relaying its
>> answer in one of many equivalent ways, such as halting
>> at an ACCEPT or REJECT state, or leaving its answer on
>> the output tape.
>>
>> answered Nov 25 '17 at 8:35 Yuval Filmus top 0.03% overall
>> Assistant Professor in the Henry and Marilyn
>> Taub Department of Computer Science at the
>> Technion – Israel Institute of Technology.
>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>
>> The above proves that your stupid idea that a decider must return a
>> value to its every invocation is just as dishonest as many of the
>> things that you say. A decider must eventually halt in an accept
>> or reject state, yet is never required to return any value to it
>> otherwise infinite invocation.
>
> You've cited this particular website on numerous occasions but you don't
> seem to understand what is being said in it. The author is pointing to
> an ambiguity in the *type* of value which a decider returns. There is no
> disagreement whatsoever over the fact that a decider is defined as a TM
> which *always* halts and returns a value. The only ambiguity which is
> being addressed here is whether that value should be limited to true or
> false.
>
> Any TM which can possibly enter an infinite loop or infinite recursion
> and which thus sometimes fails to return an answer is *not* a decider by
> any definition.
>
> André
>
Yet this code <is> a decider for H_Hat() even though it never returns
any value to H_hat();
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
int main()
{
u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
Output("Input_Would_Halt =", Input_Would_Halt);
}
I finally got rid of the need for this instruction:
#define HALT __asm hlt
I had initially needed it as a part of my context switching protocol.
I still use it internally to indicate the end of a simulation.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-07 13:45 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) |
| Message-ID | <B-Cdnazixp54-WrCnZ2dnUU7-V3NnZ2d@giganews.com> |
| In reply to | #2487 |
On 1/7/2021 1:41 PM, olcott wrote:
> On 1/7/2021 1:25 PM, André G. Isaak wrote:
>> On 2021-01-07 12:05, olcott wrote:
>>> On 1/7/2021 5:57 AM, Ben Bacarisse wrote:
>>>> Kaz Kylheku <563-365-8930@kylheku.com> writes:
>>>>
>>>>> On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
>>>>>> The question is hard-wired into the conventional undecidability proof
>>>>>> trick of
>>>>>
>>>>> No, it isn't. Not any more than the "have you stopped beating your
>>>>> wife"
>>>>> question is hard-wired into the psychology of marriage.
>>>>>
>>>>> It's just nonsense that you're insisting on.
>>>>>
>>>>> Nobody in their right mind asks whether a function that doesn't exist
>>>>> returns true or false, or whether a nonexistent camel is dromedary or
>>>>> bactrian, or whether someone not known to beat their wife (or not even
>>>>> married) has stopped beating their wife.
>>>>>
>>>>> Pretending that the phrase "nonexistent function" refers to a real
>>>>> object, which has to have real properties (like returning true or
>>>>> false) is just word semantic nonsense.
>>>>
>>>> The trouble PO has is that "the function" clearly exists. He's written
>>>> it, and he can see that neither return value can be right.
>>>>
>>>> Don't get me wrong -- I do understand what you are saying. "The
>>>> function" that does not exist is a correct halt decider (that's the CS
>>>> point of view) but PO is thinking like an engineer. He has actual
>>>> code.
>>>> For him "the function" is that real, actual code and, at some level, it
>>>> just appeared to have "a bug" in that it gives the wrong answer in some
>>>> cases. But he can now see that this bug can't be fixed. To an
>>>> engineer, an unfixable bug means there is something wrong with the
>>>> specification.
>>>>
>>>> This is why I hate the argument that Linz presents, even if he does so
>>>> only for historical interest. To engineers (and most software people
>>>> have been taught to think like engineers) the "assume H is a halt
>>>> decider" style of proof makes it simply too easy to think that
>>>> there's a
>>>> function with an, apparently, unfixable bug. A class of engineers will
>>>> spend a lot of time trying to fix the bug and, failing that, try to
>>>> find
>>>> out what's wrong with the specification.
>>>>
>>>> The other proof in Linz is also problematic for a class of engineers
>>>> because it is so abstract. Like a lot of mathematical proofs it's hard
>>>> to see how it explains the "why". It's just a bald fact -- a halt
>>>> decider would contradict theorem 11.5 (or whatever). That's why I
>>>> preferred the diagonal argument: every TM computes a function
>>>> (sometimes
>>>> a partial one) but every TM has the property that the function it
>>>> computes is not the halting function. Nothing nonexistent is ever
>>>> imagined, we simply learn something universal about TMs.
>>>>
>>>
>>> void H_Hat(u32 P)
>>> {
>>> u32 Input_Halts = Halts(P, P);
>>> if (Input_Halts)
>>> HERE: goto HERE;
>>> return;
>>> }
>>>
>>> The diagonal argument only shows that neither true nor false is a
>>> correct value that Halts() can return to H_Hat().
>>>
>>> This shallow analysis utterly ignores the possibility that H_Hat()
>>> can be correctly decided by aborting the simulation of H_Hat before
>>> Halts() returns any value to H_Hat() on the basis that the H_Hat()
>>> invocation of Halts() would otherwise be infinitely recursive if
>>> Halts() did not stop simulating it.
>>>
>>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>> > A computation that would not halt if its simulation were not
>>> > halted is indeed a non-halting computation.
>>>
>>>
>>> int main()
>>> {
>>> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>>> }
>>>
>>> What is decider?
>>>
>>> The term decider doesn't really have a standard meaning.
>>> In fact, it is lamentable that Sipser chose the terms decider
>>> and recognizer, since they seem to confuse students.
>>>
>>> Intuitively, a decider should be a Turing machine that given
>>> an input, halts and either accepts or rejects, relaying its
>>> answer in one of many equivalent ways, such as halting
>>> at an ACCEPT or REJECT state, or leaving its answer on
>>> the output tape.
>>>
>>> answered Nov 25 '17 at 8:35 Yuval Filmus top 0.03% overall
>>> Assistant Professor in the Henry and Marilyn
>>> Taub Department of Computer Science at the
>>> Technion – Israel Institute of Technology.
>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>
>>> The above proves that your stupid idea that a decider must return a
>>> value to its every invocation is just as dishonest as many of the
>>> things that you say. A decider must eventually halt in an accept
>>> or reject state, yet is never required to return any value to it
>>> otherwise infinite invocation.
>>
>> You've cited this particular website on numerous occasions but you
>> don't seem to understand what is being said in it. The author is
>> pointing to an ambiguity in the *type* of value which a decider
>> returns. There is no disagreement whatsoever over the fact that a
>> decider is defined as a TM which *always* halts and returns a value.
>> The only ambiguity which is being addressed here is whether that value
>> should be limited to true or false.
>>
>
>
>
>> Any TM which can possibly enter an infinite loop or infinite recursion
>> and which thus sometimes fails to return an answer is *not* a decider
>> by any definition.
>>
>> André
>>
>
> Yet this code <is> a decider for H_Hat() even though it never returns
> any value to H_hat();
>
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
> Output("Input_Would_Halt =", Input_Would_Halt);
> }
>
Output_Decoded_Instructions_from_address_list() [000211b6] size(64)
capacity(4096)
***[0000088a](01) 55 push ebp
***[0000088b](02) 8bec mov ebp,esp
***[0000088d](01) 51 push ecx
***[0000088e](03) 8b4508 mov eax,[ebp+08]
***[00000891](01) 50 push eax
***[00000892](03) 8b4d08 mov ecx,[ebp+08]
***[00000895](01) 51 push ecx
***[00000896](05) e8dffdffff call 0000067a
***[0000088a](01) 55 push ebp
***[0000088b](02) 8bec mov ebp,esp
***[0000088d](01) 51 push ecx
***[0000088e](03) 8b4508 mov eax,[ebp+08]
***[00000891](01) 50 push eax
***[00000892](03) 8b4d08 mov ecx,[ebp+08]
***[00000895](01) 51 push ecx
***[00000896](05) e8dffdffff call 0000067a
...[000008cd](03) 83c408 add esp,+08
...[000008d0](03) 8945fc mov [ebp-04],eax
...[000008d3](03) 8b45fc mov eax,[ebp-04]
...[000008d6](01) 50 push eax
...[000008d7](05) 6827030000 push 00000327
Input_Would_Halt = 0
[000008dc](05) e879faffff call 0000035a
...[000008e1](03) 83c408 add esp,+08
...[000008e4](02) 33c0 xor eax,eax
...[000008e6](02) 8be5 mov esp,ebp
...[000008e8](01) 5d pop ebp
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-07 18:11 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) |
| Message-ID | <2YidnV3DcNuGPmrCnZ2dnUU7-L3NnZ2d@giganews.com> |
| In reply to | #2487 |
On 1/7/2021 5:45 PM, Richard Damon wrote:
> On 1/7/21 2:41 PM, olcott wrote:
>> On 1/7/2021 1:25 PM, André G. Isaak wrote:
>>> On 2021-01-07 12:05, olcott wrote:
>>>> On 1/7/2021 5:57 AM, Ben Bacarisse wrote:
>>>>> Kaz Kylheku <563-365-8930@kylheku.com> writes:
>>>>>
>>>>>> On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> The question is hard-wired into the conventional undecidability proof
>>>>>>> trick of
>>>>>>
>>>>>> No, it isn't. Not any more than the "have you stopped beating your
>>>>>> wife"
>>>>>> question is hard-wired into the psychology of marriage.
>>>>>>
>>>>>> It's just nonsense that you're insisting on.
>>>>>>
>>>>>> Nobody in their right mind asks whether a function that doesn't exist
>>>>>> returns true or false, or whether a nonexistent camel is dromedary or
>>>>>> bactrian, or whether someone not known to beat their wife (or not even
>>>>>> married) has stopped beating their wife.
>>>>>>
>>>>>> Pretending that the phrase "nonexistent function" refers to a real
>>>>>> object, which has to have real properties (like returning true or
>>>>>> false) is just word semantic nonsense.
>>>>>
>>>>> The trouble PO has is that "the function" clearly exists. He's written
>>>>> it, and he can see that neither return value can be right.
>>>>>
>>>>> Don't get me wrong -- I do understand what you are saying. "The
>>>>> function" that does not exist is a correct halt decider (that's the CS
>>>>> point of view) but PO is thinking like an engineer. He has actual
>>>>> code.
>>>>> For him "the function" is that real, actual code and, at some level, it
>>>>> just appeared to have "a bug" in that it gives the wrong answer in some
>>>>> cases. But he can now see that this bug can't be fixed. To an
>>>>> engineer, an unfixable bug means there is something wrong with the
>>>>> specification.
>>>>>
>>>>> This is why I hate the argument that Linz presents, even if he does so
>>>>> only for historical interest. To engineers (and most software people
>>>>> have been taught to think like engineers) the "assume H is a halt
>>>>> decider" style of proof makes it simply too easy to think that
>>>>> there's a
>>>>> function with an, apparently, unfixable bug. A class of engineers will
>>>>> spend a lot of time trying to fix the bug and, failing that, try to
>>>>> find
>>>>> out what's wrong with the specification.
>>>>>
>>>>> The other proof in Linz is also problematic for a class of engineers
>>>>> because it is so abstract. Like a lot of mathematical proofs it's hard
>>>>> to see how it explains the "why". It's just a bald fact -- a halt
>>>>> decider would contradict theorem 11.5 (or whatever). That's why I
>>>>> preferred the diagonal argument: every TM computes a function
>>>>> (sometimes
>>>>> a partial one) but every TM has the property that the function it
>>>>> computes is not the halting function. Nothing nonexistent is ever
>>>>> imagined, we simply learn something universal about TMs.
>>>>>
>>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>> u32 Input_Halts = Halts(P, P);
>>>> if (Input_Halts)
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> The diagonal argument only shows that neither true nor false is a
>>>> correct value that Halts() can return to H_Hat().
>>>>
>>>> This shallow analysis utterly ignores the possibility that H_Hat()
>>>> can be correctly decided by aborting the simulation of H_Hat before
>>>> Halts() returns any value to H_Hat() on the basis that the H_Hat()
>>>> invocation of Halts() would otherwise be infinitely recursive if
>>>> Halts() did not stop simulating it.
>>>>
>>>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>>> > A computation that would not halt if its simulation were not
>>>> > halted is indeed a non-halting computation.
>>>>
>>>>
>>>> int main()
>>>> {
>>>> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>>>> }
>>>>
>>>> What is decider?
>>>>
>>>> The term decider doesn't really have a standard meaning.
>>>> In fact, it is lamentable that Sipser chose the terms decider
>>>> and recognizer, since they seem to confuse students.
>>>>
>>>> Intuitively, a decider should be a Turing machine that given
>>>> an input, halts and either accepts or rejects, relaying its
>>>> answer in one of many equivalent ways, such as halting
>>>> at an ACCEPT or REJECT state, or leaving its answer on
>>>> the output tape.
>>>>
>>>> answered Nov 25 '17 at 8:35 Yuval Filmus top 0.03% overall
>>>> Assistant Professor in the Henry and Marilyn
>>>> Taub Department of Computer Science at the
>>>> Technion – Israel Institute of Technology.
>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>
>>>> The above proves that your stupid idea that a decider must return a
>>>> value to its every invocation is just as dishonest as many of the
>>>> things that you say. A decider must eventually halt in an accept
>>>> or reject state, yet is never required to return any value to it
>>>> otherwise infinite invocation.
>>>
>>> You've cited this particular website on numerous occasions but you
>>> don't seem to understand what is being said in it. The author is
>>> pointing to an ambiguity in the *type* of value which a decider
>>> returns. There is no disagreement whatsoever over the fact that a
>>> decider is defined as a TM which *always* halts and returns a value.
>>> The only ambiguity which is being addressed here is whether that value
>>> should be limited to true or false.
>>>
>>
>>
>>
>>> Any TM which can possibly enter an infinite loop or infinite recursion
>>> and which thus sometimes fails to return an answer is *not* a decider
>>> by any definition.
>>>
>>> André
>>>
>>
>> Yet this code <is> a decider for H_Hat() even though it never returns
>> any value to H_hat();
>>
>> void H_Hat(u32 P)
>> {
>> u32 Input_Halts = Halts(P, P);
>> if (Input_Halts)
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>> Output("Input_Would_Halt =", Input_Would_Halt);
>> }
>>
>> I finally got rid of the need for this instruction:
>> #define HALT __asm hlt
>>
>> I had initially needed it as a part of my context switching protocol.
>> I still use it internally to indicate the end of a simulation.
>>
>
> But if it represents the equivalent of the Turing Machine H, and H_Hat
> represents the Linz H^, then Halts MUST return that same value to H_Hat,
> or the equivelence was done wrong, or Halts doesn't actually return its
> value.
>
Not at all. All the proofs simply fail to consider that when the halt
decider bases its decision on simulating its input that this halt
decider must stop simulating H_Hat() before ever returning a value to
H_Hat().
That you cannot seem to understand that there is never ever any case
where the otherwise infinite invocation of a function can ever return a
value to its caller makes me think that something is seriously wrong
with your brain.
It is like you are thinking that once in a while there is a case where a
baby kitten really is a type of office building. **
** conventional meaning of the terms.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-07 17:43 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) |
| Message-ID | <XoudnSykpY8oAWrCnZ2dnUU7-YPNnZ2d@giganews.com> |
| In reply to | #2485 |
On 1/7/2021 1:59 PM, Kaz Kylheku wrote:
> On 2021-01-07, olcott <NoOne@NoWhere.com> wrote:
>> On 1/7/2021 5:57 AM, Ben Bacarisse wrote:
>>> Kaz Kylheku <563-365-8930@kylheku.com> writes:
>>>
>>>> On 2021-01-06, olcott <NoOne@NoWhere.com> wrote:
>>>>> The question is hard-wired into the conventional undecidability proof
>>>>> trick of
>>>>
>>>> No, it isn't. Not any more than the "have you stopped beating your wife"
>>>> question is hard-wired into the psychology of marriage.
>>>>
>>>> It's just nonsense that you're insisting on.
>>>>
>>>> Nobody in their right mind asks whether a function that doesn't exist
>>>> returns true or false, or whether a nonexistent camel is dromedary or
>>>> bactrian, or whether someone not known to beat their wife (or not even
>>>> married) has stopped beating their wife.
>>>>
>>>> Pretending that the phrase "nonexistent function" refers to a real
>>>> object, which has to have real properties (like returning true or
>>>> false) is just word semantic nonsense.
>>>
>>> The trouble PO has is that "the function" clearly exists. He's written
>>> it, and he can see that neither return value can be right.
>>>
>>> Don't get me wrong -- I do understand what you are saying. "The
>>> function" that does not exist is a correct halt decider (that's the CS
>>> point of view) but PO is thinking like an engineer. He has actual code.
>>> For him "the function" is that real, actual code and, at some level, it
>>> just appeared to have "a bug" in that it gives the wrong answer in some
>>> cases. But he can now see that this bug can't be fixed. To an
>>> engineer, an unfixable bug means there is something wrong with the
>>> specification.
>>>
>>> This is why I hate the argument that Linz presents, even if he does so
>>> only for historical interest. To engineers (and most software people
>>> have been taught to think like engineers) the "assume H is a halt
>>> decider" style of proof makes it simply too easy to think that there's a
>>> function with an, apparently, unfixable bug. A class of engineers will
>>> spend a lot of time trying to fix the bug and, failing that, try to find
>>> out what's wrong with the specification.
>>>
>>> The other proof in Linz is also problematic for a class of engineers
>>> because it is so abstract. Like a lot of mathematical proofs it's hard
>>> to see how it explains the "why". It's just a bald fact -- a halt
>>> decider would contradict theorem 11.5 (or whatever). That's why I
>>> preferred the diagonal argument: every TM computes a function (sometimes
>>> a partial one) but every TM has the property that the function it
>>> computes is not the halting function. Nothing nonexistent is ever
>>> imagined, we simply learn something universal about TMs.
>>>
>>
>> void H_Hat(u32 P)
>> {
>> u32 Input_Halts = Halts(P, P);
>> if (Input_Halts)
>> HERE: goto HERE;
>> return;
>> }
>>
>> The diagonal argument only shows that neither true nor false is a
>> correct value that Halts() can return to H_Hat().
>
> It shows no such thing; the language you are using here is ill-formed.
>
> The correct language is that exists no definition of Halts which returns
> the correct value (when P = H_Hat, don't forget that).
>
It is you that is forgetting not me.
In the following code Halts() DOES do return the correct value, it
simply doesn't return it to H_Hat().
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
int main()
{
u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
Output("Input_Would_Halt =", Input_Would_Halt);
}
_H_Hat()
[0000088a](01) 55 push ebp
[0000088b](02) 8bec mov ebp,esp
[0000088d](01) 51 push ecx
[0000088e](03) 8b4508 mov eax,[ebp+08]
[00000891](01) 50 push eax
[00000892](03) 8b4d08 mov ecx,[ebp+08]
[00000895](01) 51 push ecx
[00000896](05) e8dffdffff call 0000067a
[0000089b](03) 83c408 add esp,+08
[0000089e](03) 8945fc mov [ebp-04],eax
[000008a1](04) 837dfc00 cmp dword [ebp-04],+00
[000008a5](02) 7402 jz 000008a9
[000008a7](02) ebfe jmp 000008a7
[000008a9](02) 8be5 mov esp,ebp
[000008ab](01) 5d pop ebp
[000008ac](01) c3 ret
_main()
[000008ba](01) 55 push ebp
[000008bb](02) 8bec mov ebp,esp
[000008bd](01) 51 push ecx
[000008be](05) 688a080000 push 0000088a
[000008c3](05) 688a080000 push 0000088a
[000008c8](05) e8adfdffff call 0000067a
[000008cd](03) 83c408 add esp,+08
[000008d0](03) 8945fc mov [ebp-04],eax
[000008d3](03) 8b45fc mov eax,[ebp-04]
[000008d6](01) 50 push eax
[000008d7](05) 6827030000 push 00000327
[000008dc](05) e879faffff call 0000035a
[000008e1](03) 83c408 add esp,+08
[000008e4](02) 33c0 xor eax,eax
[000008e6](02) 8be5 mov esp,ebp
[000008e8](01) 5d pop ebp
[000008e9](01) c3 ret
***[0000088a](01) 55 push ebp
***[0000088b](02) 8bec mov ebp,esp
***[0000088d](01) 51 push ecx
***[0000088e](03) 8b4508 mov eax,[ebp+08]
***[00000891](01) 50 push eax
***[00000892](03) 8b4d08 mov ecx,[ebp+08]
***[00000895](01) 51 push ecx
***[00000896](05) e8dffdffff call 0000067a
***[0000088a](01) 55 push ebp
***[0000088b](02) 8bec mov ebp,esp
***[0000088d](01) 51 push ecx
***[0000088e](03) 8b4508 mov eax,[ebp+08]
***[00000891](01) 50 push eax
***[00000892](03) 8b4d08 mov ecx,[ebp+08]
***[00000895](01) 51 push ecx
***[00000896](05) e8dffdffff call 0000067a
...[000008cd](03) 83c408 add esp,+08
...[000008d0](03) 8945fc mov [ebp-04],eax
...[000008d3](03) 8b45fc mov eax,[ebp-04]
...[000008d6](01) 50 push eax
...[000008d7](05) 6827030000 push 00000327
Input_Would_Halt = 0
[000008dc](05) e879faffff call 0000035a
...[000008e1](03) 83c408 add esp,+08
...[000008e4](02) 33c0 xor eax,eax
...[000008e6](02) 8be5 mov esp,ebp
...[000008e8](01) 5d pop ebp
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-08 11:47 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) |
| Message-ID | <KtydnXnOSf0CB2XCnZ2dnUU7-XPNnZ2d@giganews.com> |
| In reply to | #2489 |
On 1/7/2021 6:59 PM, Kaz Kylheku wrote: > On 2021-01-07, olcott <NoOne@NoWhere.com> wrote: >> On 1/7/2021 1:59 PM, Kaz Kylheku wrote: >>> It shows no such thing; the language you are using here is ill-formed. >>> >>> The correct language is that exists no definition of Halts which returns >>> the correct value (when P = H_Hat, don't forget that). >>> >> It is you that is forgetting not me. >> >> In the following code Halts() DOES do return the correct value, it >> simply doesn't return it to H_Hat(). > > I'm afraid that is not valid. A function returns the value implied > by its arguments, regardless of any context. > Like Ben is saying I am talking from a software engineering perspective where every single detail is explicitly encoded and nothing is simply assumed away. To say that from a software engineering perspective that there are times when a software function returns a value to its otherwise infinite invocation is just like saying that there are times when a baby kitten really is a type of office building. ** ** Within the conventional meaning of the terms "kitten" and "office building". -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-01-08 18:00 +0000 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) |
| Message-ID | <20210108095829.941@kylheku.com> |
| In reply to | #2492 |
["Followup-To:" header set to comp.theory.] On 2021-01-08, olcott <NoOne@NoWhere.com> wrote: > On 1/7/2021 6:59 PM, Kaz Kylheku wrote: >> On 2021-01-07, olcott <NoOne@NoWhere.com> wrote: >>> On 1/7/2021 1:59 PM, Kaz Kylheku wrote: >>>> It shows no such thing; the language you are using here is ill-formed. >>>> >>>> The correct language is that exists no definition of Halts which returns >>>> the correct value (when P = H_Hat, don't forget that). >>>> >>> It is you that is forgetting not me. >>> >>> In the following code Halts() DOES do return the correct value, it >>> simply doesn't return it to H_Hat(). >> >> I'm afraid that is not valid. A function returns the value implied >> by its arguments, regardless of any context. >> > > Like Ben is saying I am talking from a software engineering perspective > where every single detail is explicitly encoded and nothing is simply > assumed away. You're deliberately refusing to test your code in obvious ways and provide the results. You cannot call yourself an engineer, therefore. In the context of an engineering organization, you belong in sales and marketing.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-08 11:40 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <Jo6dnSEyULCJBGXCnZ2dnUU7-e_NnZ2d@giganews.com> |
| In reply to | #2482 |
On 1/6/2021 9:20 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 1/6/2021 7:00 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> When we consider which of the two values that Halts() can return to >>>> H_Hat() the correct answer is neither because the invocation of >>>> Halts() by H_Hat() would be infinitely recursive if Halts() did not >>>> abort this invocation. >>> >>> Not so long ago you said: >>> >>> | I have proven that this argument is not valid by making an H that >>> | decides (Ĥ, Ĥ). >>> >>> Causing me to check, and you to confirm (albeit rather evasively): >>> >>> || What is the decision -- halts, or does not halt? >>> | Yes it is one of those. >>> >>> || Do you claim that the decision is the correct one? >>> | It is easily verifiably correct. >>> >>> So what is the easily verifiably correct, halts or does not halt >>> decision that H gave for (Ĥ, Ĥ) back then? > > No answer? > >> On 11/27/2020 9:02 PM, Ben Bacarisse wrote: >>> A computation that would not halt if its simulation were not >>> halted is indeed a non-halting computation. > > This is not an answer -- it's barely more than a tautology. What is the > correct halts/not halts answer you calmed you got from H for (Ĥ, Ĥ)? > > I don't expect an answer. But your not answering will help people to > understand how evasive you are. > > Here's the real explanation (that you cut): > > The (current) resolution to these apparently contradictory remarks is > that there are two algorithms both called Halts (or H). The one called > from or used by H_Hat (or Ĥ) does not answer, and the other does. It would be incorrect for me to answer questions that are based on fundamental false assumptions until after all these false assumptions are first corrected. Since I have already corrected these fundamental false assumptions many times it seems question obvious that you have no interest in the actual truth. The fundamental false assumption that you make in your above paragraph is that there is more than one halting algorithm. As I have said many many times: there is only a single instance of the machine language of the local halt decider there is only a single instance of the machine language of the local halt decider there is only a single instance of the machine language of the local halt decider Is it that you are too stupid to get this? Are you too dishonest to get this? Do you have actual brain damage such as dementia? As soon as you acknowledge: there is only a single instance of the machine language of the local halt decider We can move on to the next point. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-08 15:59 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <ceudndzElfdHSGXCnZ2dnUU7-XHNnZ2d@giganews.com> |
| In reply to | #2491 |
On 1/8/2021 3:34 PM, André G. Isaak wrote:
> On 2021-01-08 10:40, olcott wrote:
>> On 1/6/2021 9:20 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 1/6/2021 7:00 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> When we consider which of the two values that Halts() can return to
>>>>>> H_Hat() the correct answer is neither because the invocation of
>>>>>> Halts() by H_Hat() would be infinitely recursive if Halts() did not
>>>>>> abort this invocation.
>>>>>
>>>>> Not so long ago you said:
>>>>>
>>>>> | I have proven that this argument is not valid by making an H that
>>>>> | decides (Ĥ, Ĥ).
>>>>>
>>>>> Causing me to check, and you to confirm (albeit rather evasively):
>>>>>
>>>>> || What is the decision -- halts, or does not halt?
>>>>> | Yes it is one of those.
>>>>>
>>>>> || Do you claim that the decision is the correct one?
>>>>> | It is easily verifiably correct.
>>>>>
>>>>> So what is the easily verifiably correct, halts or does not halt
>>>>> decision that H gave for (Ĥ, Ĥ) back then?
>>>
>>> No answer?
>>>
>>>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>>>> A computation that would not halt if its simulation were not
>>>>> halted is indeed a non-halting computation.
>>>
>>> This is not an answer -- it's barely more than a tautology. What is the
>>> correct halts/not halts answer you calmed you got from H for (Ĥ, Ĥ)?
>>>
>>> I don't expect an answer. But your not answering will help people to
>>> understand how evasive you are.
>>>
>>> Here's the real explanation (that you cut):
>>>
>>> The (current) resolution to these apparently contradictory remarks is
>>> that there are two algorithms both called Halts (or H). The one called
>>> from or used by H_Hat (or Ĥ) does not answer, and the other does.
>>
>> It would be incorrect for me to answer questions that are based on
>> fundamental false assumptions until after all these false assumptions
>> are first corrected.
>>
>> Since I have already corrected these fundamental false assumptions
>> many times it seems question obvious that you have no interest in the
>> actual truth.
>>
>> The fundamental false assumption that you make in your above paragraph
>> is that there is more than one halting algorithm. As I have said many
>> many times:
>>
>> there is only a single instance of the machine language of the local
>> halt decider
>
> Which means that your Halts() and your H_Hat() do not stand in the same
> relation as Linz's H and H_Hat, and therefore your program has nothing
> to say about this proof.
>
> André
>
The key thing (that I have said far too many times) is that it does have
the exact same "do the opposite of whatever the halt decider decides"
that is the key basis of all of the conventional proofs.
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.
(Sipser 1997) http://www.liarparadox.org/sipser_165.pdf
Sipser, Michael 1997. Introduction to the Theory of Computation. Boston:
PWS Publishing Company (165-167)
BECAUSE I HAVE REFUTED THE KEY BASIS OF ALL OF THESE PROOFS I HAVE
REFUTED ALL OF THESE PROOFS.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 1 of 6 [1] 2 3 4 5 6 Next page →
Back to top | Article view | comp.software-eng
csiph-web