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 5 of 6 — ← Prev page 1 2 3 4 [5] 6 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-16 15:09 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) |
| Message-ID | <rdqdnc6eJOG8y579nZ2dnUU7-c3NnZ2d@giganews.com> |
| In reply to | #2569 |
On 1/14/2021 6:58 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 1/14/2021 10:00 AM, Richard Damon wrote: >>> On 1/14/21 10:32 AM, olcott wrote: > >>>> On 1/10/2021 9:09 AM, Ben Bacarisse wrote: >>>>> Yes, except that the question "Does the simulation of the >>>>> input have to be stopped to prevent its otherwise infinite >>>>> execution" is, itself, the classical halting problem. > >>>> Although the above question divides inputs into halting and not halting >>>> when the original question: >>>> Does the input halt on its input? >>>> >>>> is applied to a halt decider based on the above question it conflates >>>> halting inputs with not-halting inputs and calls them both halting. >>>> >>> >>> And you still don't understand and cherry pick comments out of context, >>> showing yourself to be the cheat that you are. >>> >>> Ben was commenting that making the decision to REALLY be that otherwise >>> infinite recursion will occur, you need to solve that actual halting >>> problem, >> >> No he certainly did not mean that. > > Yes I did. Exactly that. I do not have to freaking solve the halting problem to show that the conventional proofs are incorrect and you damn well know it. Why lie? -- 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-14 16:54 +0000 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) |
| Message-ID | <20210114084604.3@kylheku.com> |
| In reply to | #2564 |
On 2021-01-14, olcott <NoOne@NoWhere.com> wrote:
> On 1/14/2021 6:26 AM, Richard Damon wrote:
>> Except that (f) is not shown to be satisfied as some of the trace has
>> been omitted (the code starting at 0000066E and ending up at 0000084E.
>>
>> (f) does NOT say only 'user' code, and is FALSE if modified to say that.
>>
>> Your AXIOM is also not true in the general case, it presumes that
>> machine has no interrupts or traps that are able to affect the execution
>> of the program, and you 'global' decider system seems to have a trap
>> mechanism to let Halts know that it has detected 'infinite recursion',
>> that or Halts needs to have a direct conditional in it.
>>
>> Since your proof is based on a false statement, it is unsound.
>>
>
> The mistake that you continue to make over and over and over is that you
> keep presuming that the question is: Does the input halt on its input?
Not at all!
Even with this compromised logic of tracing only selected instructions
from the simulation, your H_Hat(H_Hat) halts, and yet Halts(H_Hat,
H_Hat) returns 0.
It makes no difference whether your machine assiduously analyzes all the
instructions, or whether you define Halts as
bool Halts(u32, u32) { return 0; }.
It's not going to return an answer which matches the H_Hat(H_Hat)
behavior.
And that is what is based on the so-called "incorrect question" (the
real halting problem instead of the strawman version).
What is being pointed out here is just a secondary, mostly irrelevant
way in which you are also dishonest/wrong, which ultimately makes no
difference.
You're not even able to analyze deeply enough to figure out which
criticisms of your ideas are related to adherence to correct formulation
of the halting problem, and which come from other facors.
--
TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-14 11:22 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) |
| Message-ID | <_qednbFqgr5z4J39nZ2dnUU7-N3NnZ2d@giganews.com> |
| In reply to | #2570 |
On 1/14/2021 10:54 AM, Kaz Kylheku wrote: > On 2021-01-14, olcott <NoOne@NoWhere.com> wrote: >> On 1/14/2021 6:26 AM, Richard Damon wrote: >>> Except that (f) is not shown to be satisfied as some of the trace has >>> been omitted (the code starting at 0000066E and ending up at 0000084E. >>> >>> (f) does NOT say only 'user' code, and is FALSE if modified to say that. >>> >>> Your AXIOM is also not true in the general case, it presumes that >>> machine has no interrupts or traps that are able to affect the execution >>> of the program, and you 'global' decider system seems to have a trap >>> mechanism to let Halts know that it has detected 'infinite recursion', >>> that or Halts needs to have a direct conditional in it. >>> >>> Since your proof is based on a false statement, it is unsound. >>> >> >> The mistake that you continue to make over and over and over is that you >> keep presuming that the question is: Does the input halt on its input? > > Not at all! > > Even with this compromised logic of tracing only selected instructions > from the simulation, your H_Hat(H_Hat) halts, and yet Halts(H_Hat, > H_Hat) returns 0. As I have already said fifty times now when we put the halt decider in disabled mode where it only reports true when an input program has already halted on its own then every instance of the invocation of H_Hat(H_Hat) executes infinitely. We have to determine that it executes infinitely analytically because it is impossible to wait until an eternity of time has completed. -- 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-14 17:33 +0000 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) |
| Message-ID | <20210114092350.403@kylheku.com> |
| In reply to | #2572 |
["Followup-To:" header set to comp.theory.] On 2021-01-14, olcott <NoOne@NoWhere.com> wrote: > On 1/14/2021 10:54 AM, Kaz Kylheku wrote: >> On 2021-01-14, olcott <NoOne@NoWhere.com> wrote: >>> On 1/14/2021 6:26 AM, Richard Damon wrote: >>>> Except that (f) is not shown to be satisfied as some of the trace has >>>> been omitted (the code starting at 0000066E and ending up at 0000084E. >>>> >>>> (f) does NOT say only 'user' code, and is FALSE if modified to say that. >>>> >>>> Your AXIOM is also not true in the general case, it presumes that >>>> machine has no interrupts or traps that are able to affect the execution >>>> of the program, and you 'global' decider system seems to have a trap >>>> mechanism to let Halts know that it has detected 'infinite recursion', >>>> that or Halts needs to have a direct conditional in it. >>>> >>>> Since your proof is based on a false statement, it is unsound. >>>> >>> >>> The mistake that you continue to make over and over and over is that you >>> keep presuming that the question is: Does the input halt on its input? >> >> Not at all! >> >> Even with this compromised logic of tracing only selected instructions >> from the simulation, your H_Hat(H_Hat) halts, and yet Halts(H_Hat, >> H_Hat) returns 0. > > > As I have already said fifty times now Repetition does not help in logic. P ^ P ^ ... ^ P is equiavlent to P. > when we put the halt decider in > disabled mode ... we are changing an input, which means we have a different decider, and since H_Hat is based on the decider, we have a different H_Hat. Please bugger off, until your code properly has this input in the parameter list, so that Halts is a three-place function, and H_Hat a two-place function. Note that Halts really needs to be a four-place function: bool Halts(u32 P, u32 I, bool inputDeciderMode, bool ownDeciderMode) Halts should be capable of operating in one decider mode, while analyzing H_Hat in a different decider mode. Your system might not support that, in which case the three-argument form is good enough. The top-level call to H_Hat or else to Halts specifies the mode, which is then passed to all the child functions.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-14 12:10 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) |
| Message-ID | <yfydnVLbTZlhFZ39nZ2dnUU7-Y_NnZ2d@giganews.com> |
| In reply to | #2575 |
On 1/14/2021 11:33 AM, Kaz Kylheku wrote: > ["Followup-To:" header set to comp.theory.] > On 2021-01-14, olcott <NoOne@NoWhere.com> wrote: >> On 1/14/2021 10:54 AM, Kaz Kylheku wrote: >>> On 2021-01-14, olcott <NoOne@NoWhere.com> wrote: >>>> On 1/14/2021 6:26 AM, Richard Damon wrote: >>>>> Except that (f) is not shown to be satisfied as some of the trace has >>>>> been omitted (the code starting at 0000066E and ending up at 0000084E. >>>>> >>>>> (f) does NOT say only 'user' code, and is FALSE if modified to say that. >>>>> >>>>> Your AXIOM is also not true in the general case, it presumes that >>>>> machine has no interrupts or traps that are able to affect the execution >>>>> of the program, and you 'global' decider system seems to have a trap >>>>> mechanism to let Halts know that it has detected 'infinite recursion', >>>>> that or Halts needs to have a direct conditional in it. >>>>> >>>>> Since your proof is based on a false statement, it is unsound. >>>>> >>>> >>>> The mistake that you continue to make over and over and over is that you >>>> keep presuming that the question is: Does the input halt on its input? >>> >>> Not at all! >>> >>> Even with this compromised logic of tracing only selected instructions >>> from the simulation, your H_Hat(H_Hat) halts, and yet Halts(H_Hat, >>> H_Hat) returns 0. >> >> >> As I have already said fifty times now > > Repetition does not help in logic. > > P ^ P ^ ... ^ P is equiavlent to P. > > >> when we put the halt decider in >> disabled mode > > ... we are changing an input, which means we have a different decider, > and since H_Hat is based on the decider, we have a different H_Hat. > > Please bugger off, until your code properly has this input in the > parameter list, so that Halts is a three-place function, and H_Hat > a two-place function. > So it is utterly beyond your imagination that there could be three different instances of a halt decider? I swap between them using #define statements. > Note that Halts really needs to be a four-place function: > > bool Halts(u32 P, u32 I, bool inputDeciderMode, bool ownDeciderMode) > For the purpose of maximizing the effectiveness of communication we must minimize rather than maximize complexity. > Halts should be capable of operating in one decider mode, while > analyzing H_Hat in a different decider mode. > I am not going to give Halts() a [God damned liar] mode. > Your system might not support that, in which case the three-argument > form is good enough. The top-level call to H_Hat or else to Halts > specifies the mode, which is then passed to all the child functions. > -- 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-14 19:25 +0000 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) |
| Message-ID | <20210114105604.565@kylheku.com> |
| In reply to | #2576 |
["Followup-To:" header set to comp.theory.] On 2021-01-14, olcott <NoOne@NoWhere.com> wrote: > On 1/14/2021 11:33 AM, Kaz Kylheku wrote: >> ["Followup-To:" header set to comp.theory.] >> On 2021-01-14, olcott <NoOne@NoWhere.com> wrote: >>> On 1/14/2021 10:54 AM, Kaz Kylheku wrote: >>>> On 2021-01-14, olcott <NoOne@NoWhere.com> wrote: >>>>> On 1/14/2021 6:26 AM, Richard Damon wrote: >>>>>> Except that (f) is not shown to be satisfied as some of the trace has >>>>>> been omitted (the code starting at 0000066E and ending up at 0000084E. >>>>>> >>>>>> (f) does NOT say only 'user' code, and is FALSE if modified to say that. >>>>>> >>>>>> Your AXIOM is also not true in the general case, it presumes that >>>>>> machine has no interrupts or traps that are able to affect the execution >>>>>> of the program, and you 'global' decider system seems to have a trap >>>>>> mechanism to let Halts know that it has detected 'infinite recursion', >>>>>> that or Halts needs to have a direct conditional in it. >>>>>> >>>>>> Since your proof is based on a false statement, it is unsound. >>>>>> >>>>> >>>>> The mistake that you continue to make over and over and over is that you >>>>> keep presuming that the question is: Does the input halt on its input? >>>> >>>> Not at all! >>>> >>>> Even with this compromised logic of tracing only selected instructions >>>> from the simulation, your H_Hat(H_Hat) halts, and yet Halts(H_Hat, >>>> H_Hat) returns 0. >>> >>> >>> As I have already said fifty times now >> >> Repetition does not help in logic. >> >> P ^ P ^ ... ^ P is equiavlent to P. >> >> >>> when we put the halt decider in >>> disabled mode >> >> ... we are changing an input, which means we have a different decider, >> and since H_Hat is based on the decider, we have a different H_Hat. >> >> Please bugger off, until your code properly has this input in the >> parameter list, so that Halts is a three-place function, and H_Hat >> a two-place function. >> > > So it is utterly beyond your imagination that there could be three > different instances of a halt decider? No, it isn't; I'm asking you above to make the instances clear via parameters. The article "a" in "a halt decider" refers to exactly one function. The "instance" of a function isn't a function, it is a function application. A function denotes many possible computations, which are parametrized using free variables known as the parameters. We instantiate a computation by applying an argument to every one of the parameters. If we apply fewer arguments than there are parameters, that is called a "partial application". The result of a partial application is a function of the remaining arguments. Partial application generates different functions for different values of the applied arguments. does not directly support run-time partial application, but you have effectively done that manually by factoring the mode parameter into a #define: you are then patially applying that parameter when building the program. Depending on which value you apply, you get one of three different Halst and H_Hat functions. These are then fully instantiated via parameters: (H_Hat) and (H_Hat, H_Hat). > I swap between them using #define statements. So you effectively have a three-parameter function. Two of the parameters appear as formal parameters in the parameter list. The third one is a #define flag. This function has a vast number of instances, not only three. Every different triplet that we choose <P, I, mode> creates a different instance. We are focused on three particular instances: Halts(H_Hat, H_Hat, mode_0) // does H_Hat(H_Hat, mode_0) halt? Halts(H_Hat, H_Hat, mode_1) // does H_Hat(H_Hat, mode_1) halt? Halts(H_Hat, H_Hat, mode_2) // does H_Hat(H_Hat, mode_1) halt? Each one answers the question about a different, corresponding instance of H_hat. See? For each mode m, each decider instance Halts(H_Hat, H_Hat, m) is concerned with a different H_Hat(H_Hat, m) instance. Each instance of Halts either fails to terminate, or else yields the wrong answer about its corresponding H_Hat instance. Because the mode parameter is compile-time, the other instances of H_Hat not being analyzed cannot even *exist* in the same program!
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-14 12:28 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) |
| Message-ID | <feSdnQMSptzGEJ39nZ2dnUU7-bHNnZ2d@giganews.com> |
| In reply to | #2572 |
On 1/14/2021 11:58 AM, Richard Damon wrote: > On 1/14/21 12:22 PM, olcott wrote: >> On 1/14/2021 10:54 AM, Kaz Kylheku wrote: >>> On 2021-01-14, olcott <NoOne@NoWhere.com> wrote: > >>>> >>>> The mistake that you continue to make over and over and over is that you >>>> keep presuming that the question is: Does the input halt on its input? >>> >>> Not at all! >>> >>> Even with this compromised logic of tracing only selected instructions >>> from the simulation, your H_Hat(H_Hat) halts, and yet Halts(H_Hat, >>> H_Hat) returns 0. >> >> >> As I have already said fifty times now when we put the halt decider in >> disabled mode where it only reports true when an input program has >> already halted on its own then every instance of the invocation of >> H_Hat(H_Hat) executes infinitely. >> >> We have to determine that it executes infinitely analytically because it >> is impossible to wait until an eternity of time has completed. >> >> > > Except that is the wrong test as it has now changed the program on the > tape being evaluated, which isn't allowed. > The test has not changed. The test is the same. The test will report: [the input must be aborted] whether or not the input is aborted. If the input is not aborted and the input is infinitely recursive this proves to anyone that understands these things that the report of "otherwise" infinite recursion was necessarily correct. If the input is not aborted then the input will be infinitely recursive: ~X then Y The input is <not> aborted and it <is> infinitely recursive. The above utterly proves ~X then Y is true. -- 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-12 18:43 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <v7OdnbR5Loe832PCnZ2dnUU7-SvNnZ2d@giganews.com> |
| In reply to | #2538 |
On 1/12/2021 3:28 PM, Kaz Kylheku wrote: > On 2021-01-12, olcott <NoOne@NoWhere.com> wrote: >> On 1/12/2021 2:07 PM, Kaz Kylheku wrote: >>> On 2021-01-12, olcott <NoOne@NoWhere.com> wrote: >>> The pronoun "its" in (a) refers to two different Turing Machines, one >>> which terminates (let's call it A) and one which exhibits infinite >>> execution (B). These are necessarily different machines, because no TM >>> both terminates and fails to terminate. >>> >>> What (a) says is 'The simulation of A has to be stopped to prevent >>> the infinite execution of B'. >>> >>> Because A is stopped, it cannot be B, which has infinite execution. >> >> Any input meeting this criteria is input that would have infinite >> execution if its simulation was not stopped. > > "would have" means the same thing as "does not"! > > "would have" means it "would have to be" a different TM. A TM can be configured to stop the simulation of its input when its input would be otherwise infinitely recursive OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR OR A TM can be configured to NOT stop the simulation of its input when its input would be otherwise infinitely recursive, thus allowing it to be infinitely recursive. When you evaluate the first half of a single sentence you do not evaluate the sentence correctly. -- 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-12 20:50 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <ed2dnRQPFttmwmPCnZ2dnUU7-UXNnZ2d@giganews.com> |
| In reply to | #2538 |
On 1/12/2021 8:28 PM, Richard Damon wrote: > On 1/12/21 3:49 PM, olcott wrote: >> >> Any input meeting this criteria is input that would have infinite >> execution if its simulation was not stopped. >> >> Infinite Recursion detection AXIOM (self-evident truth) >> (a) Within an execution trace >> (b) The same function is called >> (c) From the same machine address >> (d) With the same data // Richard Damon credit >> (e) A second time >> (f) Without any control flow instructions inbetween >> >> The way to prove that this is true is to perform an execution trace on >> H_Hat() with the halt decider in disabled mode. There will also be a >> full trace mode that shows the execution trace of all of operating >> system code too. >> >> When you can look at the 100% complete execution trace and see that >> there are no instructions in this trace that could possibly cause it to >> stop, then it can be understood to be infinite. >> >> It is much much easier to come to a complete understanding of the above >> Infinite Recursion detection AXIOM than it is to verify that thousands >> of pages of x86 code specify infinite execution. None-the-less this >> empirical proof will be available. >> >> Even the full execution trace of Halts() correctly deciding H_Hat() is >> 297 pages long. This was greatly reduced to 297 pages by moving most >> operating system functions into emulator code. >> >> The local halt decider is entirely in emulated code so every single step >> of its execution can be seen. The global halt decider works best as an >> x86utm operating system function so that it can easily watch everything. >> > Except that you never do provide a 100% trace of the execution because > you omit some code that you classify as 'system' code. I will have a mode where you can see all the system code. In that case less than one page of output becomes 297 pages. > Turing Machines have no 'System' Code, and for your axiom to be true, > (f) must include ALL code, AND the machine must not provide an interrupt > or trap capability the the program has access to. I am sure that Halts > fails to pass that test. > When a freaking halt decider is examining the simulation of a program under test it does not have to examine its own code (it already knows what it does) or the code of the simulator. Both of these are out-of-scope. In TM lingo this is a halt deciding UTM. -- 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-13 00:39 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <IOudnUANZP0TCGPCnZ2dnUU7-XPNnZ2d@giganews.com> |
| In reply to | #2550 |
On 1/12/2021 11:53 PM, André G. Isaak wrote: > On 2021-01-12 19:50, olcott wrote: >> On 1/12/2021 8:28 PM, Richard Damon wrote: >>> On 1/12/21 3:49 PM, olcott wrote: >>>> >>>> Any input meeting this criteria is input that would have infinite >>>> execution if its simulation was not stopped. >>>> >>>> Infinite Recursion detection AXIOM (self-evident truth) >>>> (a) Within an execution trace >>>> (b) The same function is called >>>> (c) From the same machine address >>>> (d) With the same data // Richard Damon credit >>>> (e) A second time >>>> (f) Without any control flow instructions inbetween >>>> >>>> The way to prove that this is true is to perform an execution trace on >>>> H_Hat() with the halt decider in disabled mode. There will also be a >>>> full trace mode that shows the execution trace of all of operating >>>> system code too. >>>> >>>> When you can look at the 100% complete execution trace and see that >>>> there are no instructions in this trace that could possibly cause it to >>>> stop, then it can be understood to be infinite. >>>> >>>> It is much much easier to come to a complete understanding of the above >>>> Infinite Recursion detection AXIOM than it is to verify that thousands >>>> of pages of x86 code specify infinite execution. None-the-less this >>>> empirical proof will be available. >>>> >>>> Even the full execution trace of Halts() correctly deciding H_Hat() is >>>> 297 pages long. This was greatly reduced to 297 pages by moving most >>>> operating system functions into emulator code. >>>> >>>> The local halt decider is entirely in emulated code so every single >>>> step >>>> of its execution can be seen. The global halt decider works best as an >>>> x86utm operating system function so that it can easily watch >>>> everything. >>>> >>> Except that you never do provide a 100% trace of the execution because >>> you omit some code that you classify as 'system' code. >> >> I will have a mode where you can see all the system code. In that case >> less than one page of output becomes 297 pages. >> >>> Turing Machines have no 'System' Code, and for your axiom to be true, >>> (f) must include ALL code, AND the machine must not provide an interrupt >>> or trap capability the the program has access to. I am sure that Halts >>> fails to pass that test. >>> >> >> When a freaking halt decider is examining the simulation of a program >> under test it does not have to examine its own code (it already knows >> what it does) or the code of the simulator. Both of these are >> out-of-scope. > > > Except that all of that code is also part of H_Hat, the program under > test. Halts() isn't expected to examine its own code. It is, however, > required to examine *all* of the code of its input program, including > any code which might be identical to code found in Halts(). The advantage to a halt decider that simulates its input is only code that is reached in the execution trace is examined. Because the call to Halts() from H_Hat() is either infinitely recursive or aborted in both of these two possible cases it never returns any value to H_Hat() thus H_Hat() is unable to take either one of the two paths based on a return value from Halts(). > > You keep forgetting that in the Linz proof, H_Hat is created by making a > *copy* of Halts(). I do not keep forgetting that. The Sipser proof doesn't do it that way so I kept the common: "do the opposite of whatever the halt decider decides" basis of Sipser, Linz and Kozen and discarded some of the aspects where they diverge. My proof has the simplest possible instance of the key "do the opposite of whatever the halt decider decides" basis of all of the conventional proofs. -- 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-13 11:10 +0000 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <20210113025715.448@kylheku.com> |
| In reply to | #2553 |
On 2021-01-13, olcott <NoOne@NoWhere.com> wrote: > The advantage to a halt decider that simulates its input is only code > that is reached in the execution trace is examined. Because the call to > Halts() from H_Hat() is either infinitely recursive or aborted in both > of these two possible cases it never returns any value to H_Hat() thus > H_Hat() is unable to take either one of the two paths based on a return > value from Halts(). Sheer nonsense. If H_Hat(H_Hat) is directly called from main, Halts will return 0 to it, and it will promptly terminate. Only the H_Hat calls in the simulation have no chance to terminate because the simulation is stopped short before the Halts simulations return 0 to them. On 2021-01-10, olcott <NoOne@NoWhere.com> wrote: > On 1/9/2021 8:10 PM, Kaz Kylheku wrote: >> The inner Halts is looking for the same terminating condition, but since >> it is nested, it has no chance to get that far. The outer-most, oldest >> simulation terminates everything first. >> >> Botom line, 0 is the wrong answer: H_Hat(H_Hat) halts. > > It is only the wrong answer if we are asking the question: > Does the input halt on its input? -- TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-13 14:53 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <0vydnZ1FWeIywGLCnZ2dnUU7-WXNnZ2d@giganews.com> |
| In reply to | #2553 |
On 1/13/2021 7:21 AM, Malcolm McLean wrote: > On Wednesday, 13 January 2021 at 12:49:21 UTC, Richard Damon wrote: >> >> Maybe you should also read that article where it talks about a program >> taking its representation as its input, as you don't seem to understand >> that as well. >> > That's certainly an issue with the DebugTrace. > The program <is> its x86 configuration. I have never show the actual interface to DebugTrace() because it actually requires many more details that would only be confusing when the goal is explaining the gist of what it does. > Halts takes P and I. P is a Turing machine description in some notation, > and I is any sort of input on a tape with some alphabet. > > However PO uses machine code as the Turing machine description, and > also for I. So P becomes a function pointer that can be called. I wanted to make it as much as possible as one UTM simulating the Turing Machine description of another UTM so P is not a function pointer, it is a raw machine address that is manually converted into a virtual machine pointer. > It's not > clear exactly what is being done, but Halts isn't allowed to do this. It is > allowed to simulate P, but then it has no way of knowing that P contains > a call to Halts. In fact, in Linz's H_Hat, there is no call H, but there is a > copy made of the embedded H as part of the copying of H_Hat's > input. If H emulates P, as is reasonable, you will get another copy of > H_Hat made, and then maybe an infinite accumulation of them, Yes I wrote about this back in 2017 and earlier in 2016. Infinitely Recursive input on HP Proofs https://groups.google.com/g/comp.theory/c/NcFS02hKs1U/m/dhNDYvhFAAAJ > but > each copy will be concatenated on the tape, physically distinct. So > detecting infinite recursion by looking for calls to the same address won't > work. > By proving that the simplest possible example of the: "Do the opposite of whatever the halt decider decides" basis of all the conventional HP undecidability proofs is decidable all of these proof are refuted. -- 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-13 15:27 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](the gist of things) |
| Message-ID | <EK-dneJgNt8l-GLCnZ2dnUU7-V3NnZ2d@giganews.com> |
| In reply to | #2555 |
On 1/13/2021 2:59 PM, Kaz Kylheku wrote:
> On 2021-01-13, olcott <NoOne@NoWhere.com> wrote:
>> On 1/13/2021 7:21 AM, Malcolm McLean wrote:
>>> On Wednesday, 13 January 2021 at 12:49:21 UTC, Richard Damon wrote:
>>>>
>>>> Maybe you should also read that article where it talks about a program
>>>> taking its representation as its input, as you don't seem to understand
>>>> that as well.
>>>>
>>> That's certainly an issue with the DebugTrace.
>>>
>>
>> The program <is> its x86 configuration.
>> I have never show the actual interface to DebugTrace() because it
>> actually requires many more details that would only be confusing when
>> the goal is explaining the gist of what it does.
>
> You're not very good at explaining your stuff.
>
There is a very good chance that is true.
> If your goal really is explaining, you are failing miserably.
>
I am doing the best that I can. My code explains itself.
> You should write a coherent, detailed paper, with diagrams which are as
> accurate as possible, accurate code and pseudo code, and carefully
> written descriptions of everything.
>
I first must make sure that people can understand the gist of what I am
saying.
> Nobody can reconstruct what you're doing from the voluminous Usenet
> postings.
>
I have encoded Halts() such that it correctly decides not halting for
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);
}
> For instance, I think understand the bulk of it, but I could not point a
> third person to a single source of reference material.
>
> Were you never required to document anything in your entire career?
>
The code totally explains itself one you understand that this is true:
Infinite Recursion detection AXIOM (self-evident truth)
(a) Within an execution trace
(b) The same function is called
(c) From the same machine address
(d) With the same data // Richard Damon credit
(e) A second time
(f) Without any control flow instructions inbetween
Actually you don't even need to look at the code as soon as you
understand that the above is true and examine the execution trace of
H_Hat() you can immediately comprehend that Halts() can easily correctly
decide not halting on H_Hat().
--
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-13 16:22 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](the gist of things) |
| Message-ID | <sOWdne9KD7om72LCnZ2dnUU7-RnNnZ2d@giganews.com> |
| In reply to | #2557 |
On 1/13/2021 3:38 PM, Kaz Kylheku wrote: > On 2021-01-13, olcott <NoOne@NoWhere.com> wrote: >> On 1/13/2021 2:59 PM, Kaz Kylheku wrote: >>> On 2021-01-13, olcott <NoOne@NoWhere.com> wrote: >>>> On 1/13/2021 7:21 AM, Malcolm McLean wrote: >>>>> On Wednesday, 13 January 2021 at 12:49:21 UTC, Richard Damon wrote: >>>>>> >>>>>> Maybe you should also read that article where it talks about a program >>>>>> taking its representation as its input, as you don't seem to understand >>>>>> that as well. >>>>>> >>>>> That's certainly an issue with the DebugTrace. >>>>> >>>> >>>> The program <is> its x86 configuration. >>>> I have never show the actual interface to DebugTrace() because it >>>> actually requires many more details that would only be confusing when >>>> the goal is explaining the gist of what it does. >>> >>> You're not very good at explaining your stuff. >>> >> There is a very good chance that is true. >> >>> If your goal really is explaining, you are failing miserably. >>> >> I am doing the best that I can. My code explains itself. > > That is possible, but you've revealed very, very little of it. > > Those revelations are scattered throughout numerous postings in > obscure newsgroups in an obscure Usenet. > > Currently code that explains itself is something that > > 1. Someone can clone from a remote git repository hosted somewhere. > Or at least a tarball. > > 2. Has build instructions that can be successfully followed to > get the software buitl. > > 3. Test cases or instructions: this is how you run it. > Yes I am working towards that. I have all three modes fully operational. >>> You should write a coherent, detailed paper, with diagrams which are as >>> accurate as possible, accurate code and pseudo code, and carefully >>> written descriptions of everything. >>> >> >> I first must make sure that people can understand the gist of what I am >> saying. > > See, there is the problem. You are confusing understanding and > agreement. If you understand that 2 + 3 = 5 is necessarily true then you necessarily agree that it is true because that is the way that logical necessity works. It is the exact same thing with my proof. > No matter how much understanding people show of your nested simulation > constraption, you believe that they are not getting the gist of it > if they don't agree that you have refuted a proof. > With logical necessity one either agrees or one fails to understand. > That is an irrational standard just for the purpose of obtaining > a check that people are grokking the idea, so that you can then > gather it into a better piece of documentation. > The first priority is to get the code as clean as possible. The next priority is to document the code the way that you suggested. The next priority is to write an academic paper based on the code. The next priority is to get the academic paper and the code reviewed by computer scientists in the field. The final priority is to strive to get the paper based on the code published. > "People must totally agree with my ideas and results in an ad-hoc, > piecewise presentation on Usenet, before I will document them properly > in a coherent paper, accompanied by downloadable, buildable code." > If you would very carefully examine this execution trace: Output_Debug_Trace() [0001112e] size(124) capacity(65536) [0000087e](01) 55 push ebp [0000087f](02) 8bec mov ebp,esp [00000881](01) 51 push ecx [00000882](05) 684e080000 push 0000084e [00000887](05) 684e080000 push 0000084e [0000088c](05) e8ddfdffff call 0000066e ;CALL Halts(H_Hat, H_Hat) [0000084e](01) 55 push ebp [0000084f](02) 8bec mov ebp,esp [00000851](01) 51 push ecx [00000852](03) 8b4508 mov eax,[ebp+08] [00000855](01) 50 push eax [00000856](03) 8b4d08 mov ecx,[ebp+08] [00000859](01) 51 push ecx [0000085a](05) e80ffeffff call 0000066e ;CALL Halts(H_Hat, H_Hat) [0000084e](01) 55 push ebp [0000084f](02) 8bec mov ebp,esp [00000851](01) 51 push ecx [00000852](03) 8b4508 mov eax,[ebp+08] [00000855](01) 50 push eax [00000856](03) 8b4d08 mov ecx,[ebp+08] [00000859](01) 51 push ecx [0000085a](05) e80ffeffff call 0000066e ;CALL Halts(H_Hat, H_Hat) With this axiom: Infinite Recursion detection AXIOM (self-evident truth) (a) Within an execution trace (b) The same function is called (c) From the same machine address (d) With the same data // Richard Damon credit (e) A second time (f) Without any control flow instructions inbetween paying as much attention as if I was a famous computer scientist that is probably correct then it would be totally obvious that I am correct. -- 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-14 09:23 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) |
| Message-ID | <VI2dnYlNi4Ri_J39nZ2dnUU7-fnNnZ2d@giganews.com> |
| In reply to | #2555 |
On 1/14/2021 9:14 AM, Andy Walker wrote: > On 13/01/2021 20:53, olcott wrote: >> By proving that the simplest possible example of the: >> "Do the opposite of whatever the halt decider decides" >> basis of all the conventional HP undecidability proofs >> is decidable all of these proof are refuted. > > ??? No-one doubts that the "Do the opposite ..." instance > is decidable. The point is that it is decided incorrectly by the > [purported] halt decider under test*. That is enough to show the > undecidability of the HP. What other [claimed] halt deciders or > simulators or ... do, whether to this instance or any other, is > irrelevant. > The mistake that you continue to make over and over and over is that you keep presuming that the question is: Does the input halt on its input? I have corrected people on this many times and every time they short circuit to the same mistake. When we ask the question: Would the input program on its input be infinitely recursive if this infinite recursion was not stopped? the code that stops the otherwise infinite recursion is not part of the code that is under test because this code is never reached (thus not in the execution trace) until after the decision on the program under test has already been made. -- 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-14 17:10 +0000 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) |
| Message-ID | <20210114085532.434@kylheku.com> |
| In reply to | #2566 |
["Followup-To:" header set to comp.theory.] On 2021-01-14, olcott <NoOne@NoWhere.com> wrote: > On 1/14/2021 9:14 AM, Andy Walker wrote: >> On 13/01/2021 20:53, olcott wrote: >>> By proving that the simplest possible example of the: >>> "Do the opposite of whatever the halt decider decides" >>> basis of all the conventional HP undecidability proofs >>> is decidable all of these proof are refuted. >> >> ??? No-one doubts that the "Do the opposite ..." instance >> is decidable. The point is that it is decided incorrectly by the >> [purported] halt decider under test*. That is enough to show the >> undecidability of the HP. What other [claimed] halt deciders or >> simulators or ... do, whether to this instance or any other, is >> irrelevant. >> > > The mistake that you continue to make over and over and over is that you > keep presuming that the question is: Does the input halt on its input? > > I have corrected people on this many times and every time they short > circuit to the same mistake. I do not accept any other question. I understand the other question and I understand why you're insisting on it. Taken by itself, it is a poor definition of the halting problem. More importantly to your work, it doesn't match the halting problem. > When we ask the question: Would the input program on its input be > infinitely recursive if this infinite recursion was not stopped? Nobody who knows a thing or two about mathematic or logic will accept this kind of moronic sentence. You will not convince anyone who is not crazy or stupid, like yourself. The proposed question is exactly like asking "would the number 3 still be odd if we simulated it in binary, and masked out its bottom bit?" You know that Usenet tolerates has crazy and stupid people, which is why you are presenting your ideas here. This environment both allows you to persist (you would be banned in any modern Internet forum) and gives you a fighting chance at finding a few other crazy/stupid people who will nod their heads to your ideas, and accept your crazy redefined questions and the whole thing. When we ask this question, we must akcnowledge that we are doing one of three things: 1) Using very sloppy, informal language to try to say exactly the same thing as the question in the real halting problem. 2) Playing word semantic games that perpetrate equivocation, because we have in mind a particular simulation apparatus in which functions hange their behavior based on a hidden "mode" input, so that a function's recursion is *acually* stopped, yet we continue to insist that it's the same function due to having the same machine code and same inputs (other than that mode input). 3) Naively saying something completely stupid, like "would the number 3 still be odd if we simulated it in binary and cleared the LSB." -- TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-14 11:26 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) |
| Message-ID | <_qednbNqgr4w4539nZ2dnUU7-N2dnZ2d@giganews.com> |
| In reply to | #2571 |
On 1/14/2021 11:10 AM, Kaz Kylheku wrote: > ["Followup-To:" header set to comp.theory.] > On 2021-01-14, olcott <NoOne@NoWhere.com> wrote: >> On 1/14/2021 9:14 AM, Andy Walker wrote: >>> On 13/01/2021 20:53, olcott wrote: >>>> By proving that the simplest possible example of the: >>>> "Do the opposite of whatever the halt decider decides" >>>> basis of all the conventional HP undecidability proofs >>>> is decidable all of these proof are refuted. >>> >>> ??? No-one doubts that the "Do the opposite ..." instance >>> is decidable. The point is that it is decided incorrectly by the >>> [purported] halt decider under test*. That is enough to show the >>> undecidability of the HP. What other [claimed] halt deciders or >>> simulators or ... do, whether to this instance or any other, is >>> irrelevant. >>> >> >> The mistake that you continue to make over and over and over is that you >> keep presuming that the question is: Does the input halt on its input? >> >> I have corrected people on this many times and every time they short >> circuit to the same mistake. > > I do not accept any other question. On 1/10/2021 9:09 AM, Ben Bacarisse wrote: > ... the question "Does the simulation of the > input have to be stopped to prevent its otherwise infinite > execution" is, itself, the classical halting problem. Although the above question divides inputs into halting and not halting when the original question: Does the input halt on its input? is applied to a halt decider based on the above question it conflates halting inputs with not-halting inputs and calls them both halting. -- 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-14 11:25 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) |
| Message-ID | <_qednbBqgr7z4539nZ2dnUU7-N2dnZ2d@giganews.com> |
| In reply to | #2566 |
On 1/14/2021 11:06 AM, Andy Walker wrote: > On 14/01/2021 15:23, olcott wrote: >>>> By proving that the simplest possible example of the: >>>> "Do the opposite of whatever the halt decider decides" >>>> basis of all the conventional HP undecidability proofs >>>> is decidable all of these proof are refuted. >>> ??? No-one doubts that the "Do the opposite ..." instance >>> is decidable. The point is that it is decided incorrectly by the >>> [purported] halt decider under test*. That is enough to show the >>> undecidability of the HP. What other [claimed] halt deciders or >>> simulators or ... do, whether to this instance or any other, is >>> irrelevant. >> The mistake that you continue to make over and over and over is that >> you keep presuming that the question is: Does the input halt on its >> input? > > Any other question is either equivalent to that one or is > not of any relevance whatsoever to the HP. On 1/10/2021 9:09 AM, Ben Bacarisse wrote: > ... the question "Does the simulation of the > input have to be stopped to prevent its otherwise infinite > execution" is, itself, the classical halting problem. Although the above question divides inputs into halting and not halting when the original question: Does the input halt on its input? is applied to a halt decider based on the above question it conflates halting inputs with not-halting inputs and calls them both halting. -- 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-12 20:53 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <ed2dnRcPFts5_WPCnZ2dnUU7-UWdnZ2d@giganews.com> |
| In reply to | #2538 |
On 1/12/2021 8:28 PM, Richard Damon wrote: > On 1/12/21 3:49 PM, olcott wrote: >> >> Any input meeting this criteria is input that would have infinite >> execution if its simulation was not stopped. >> >> Infinite Recursion detection AXIOM (self-evident truth) >> (a) Within an execution trace >> (b) The same function is called >> (c) From the same machine address >> (d) With the same data // Richard Damon credit >> (e) A second time >> (f) Without any control flow instructions inbetween >> >> The way to prove that this is true is to perform an execution trace on >> H_Hat() with the halt decider in disabled mode. There will also be a >> full trace mode that shows the execution trace of all of operating >> system code too. >> >> When you can look at the 100% complete execution trace and see that >> there are no instructions in this trace that could possibly cause it to >> stop, then it can be understood to be infinite. >> >> It is much much easier to come to a complete understanding of the above >> Infinite Recursion detection AXIOM than it is to verify that thousands >> of pages of x86 code specify infinite execution. None-the-less this >> empirical proof will be available. >> >> Even the full execution trace of Halts() correctly deciding H_Hat() is >> 297 pages long. This was greatly reduced to 297 pages by moving most >> operating system functions into emulator code. >> >> The local halt decider is entirely in emulated code so every single step >> of its execution can be seen. The global halt decider works best as an >> x86utm operating system function so that it can easily watch everything. >> > Except that you never do provide a 100% trace of the execution because > you omit some code that you classify as 'system' code. > The full execution trace becomes 297 pages of output. > Turing Machines have no 'System' Code, and for your axiom to be true, > (f) must include ALL code, AND the machine must not provide an interrupt > or trap capability the the program has access to. I am sure that Halts > fails to pass that test. > When a freaking halt decider is examining the simulation of a program under test it does not have to examine its own code (it already knows what it does) or the code of the simulator. Both of these are out-of-scope. In TM lingo this is a halt deciding UTM. -- 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-12 19:55 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <Sb6dnVbseZ6HzmPCnZ2dnUU7-cnNnZ2d@giganews.com> |
| In reply to | #2511 |
On 1/12/2021 7:20 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 1/10/2021 9:09 AM, Ben Bacarisse wrote: > <cut> >>> Yes, except that the question "Does the simulation of the input have to >>> be stopped to prevent its otherwise infinite execution" is, itself, the >>> classical halting problem. >> >> This is one of the very rare times that you have ever agreed with me >> on a material fact. > > Not a very useful agreement unless you also agree that you can't have > code that can make this determination in the general case. If we hypothetically assume that the conventional halting problem undecidability proofs have been refuted that would seem to make the halting problem an open question again. > Sometimes > you imply that you do, and sometimes you imply that you don't. We'll > never have a definitive claim because flip-flopping (and never posting > code that would settle the matter), is how you keep the chat going. > I do not have any definitive claim on any open question. > It is, however, a matter of fact that you can't have an algorithm that > can determine if the simulation of a TM (or TM-equivalent) computation > is infinite. Do you agree with me on that one as well? > My laser focus is only on the one single aspect of the conventional halting problem undecidability proofs correctly deciding the simplest possible case of the "do the opposite of whatever the halt decider decides" common basis of all these proofs. I am NOT willing to accept: OK you refuted these proofs but that does not count for anything at all until you totally solve the actual halting problem itself. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 5 of 6 — ← Prev page 1 2 3 4 [5] 6 Next page →
Back to top | Article view | comp.software-eng
csiph-web