Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.software-eng > #1940 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2020-11-27 13:20 -0600 |
| Last post | 2020-11-30 16:57 -0600 |
| Articles | 20 on this page of 412 — 6 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: Happy Thanksgiving to all olcott <NoOne@NoWhere.com> - 2020-11-27 13:20 -0600
Re: Happy Thanksgiving to all olcott <NoOne@NoWhere.com> - 2020-11-27 17:17 -0600
Re: Happy Thanksgiving to all olcott <NoOne@NoWhere.com> - 2020-11-27 17:57 -0600
Re: Happy Thanksgiving to all olcott <NoOne@NoWhere.com> - 2020-11-28 08:21 -0600
Re: Happy Thanksgiving to all olcott <NoOne@NoWhere.com> - 2020-11-28 08:40 -0600
Re: Happy Thanksgiving to all (over your head) olcott <NoOne@NoWhere.com> - 2020-11-28 12:23 -0600
Re: Happy Thanksgiving to all (Over your head) olcott <NoOne@NoWhere.com> - 2020-11-28 12:46 -0600
Re: Happy Thanksgiving to all (Over your head) olcott <NoOne@NoWhere.com> - 2020-11-28 13:27 -0600
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-28 16:00 -0600
Re: Happy Thanksgiving to all (logical necessity) Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk> - 2020-11-28 22:11 +0000
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-28 16:16 -0600
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-28 17:49 -0600
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-28 22:29 -0600
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-29 12:41 -0600
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-28 23:15 -0600
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-28 18:07 -0600
Re: Happy Thanksgiving to all (Over your head) Jeff Barnett <jbb@notatt.com> - 2020-11-28 12:27 -0700
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-28 13:40 -0600
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-28 17:06 -0600
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-28 17:39 -0600
Re: Happy Thanksgiving to all (logical necessity) Jeff Barnett <jbb@notatt.com> - 2020-11-28 17:45 -0700
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-28 19:08 -0600
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-29 08:56 -0600
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-29 09:12 -0600
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-29 09:40 -0600
Re: Happy Thanksgiving to all (logical necessity)(asleep at the switch) olcott <NoOne@NoWhere.com> - 2020-11-30 20:02 -0600
Re: Happy Thanksgiving to all (logical necessity)(asleep at the switch) olcott <NoOne@NoWhere.com> - 2020-11-30 22:39 -0600
Re: Happy Thanksgiving to all (logical necessity)(asleep at the switch) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-11-30 21:19 -0800
Re: Happy Thanksgiving to all (logical necessity)(asleep at the switch) Jeff Barnett <jbb@notatt.com> - 2020-12-01 10:58 -0700
Re: Happy Thanksgiving to all (logical necessity)(asleep at the switch) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-12-02 23:32 -0800
Re: Happy Thanksgiving to all (logical necessity)(asleep at the switch) olcott <NoOne@NoWhere.com> - 2020-12-01 09:12 -0600
Re: Happy Thanksgiving to all (logical necessity)(asleep at the switch) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-01 21:22 +0000
Re: Happy Thanksgiving to all (logical necessity)(asleep at the switch) olcott <NoOne@NoWhere.com> - 2020-12-01 15:40 -0600
Re: Happy Thanksgiving to all (logical necessity)(asleep at the switch) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-01 22:10 +0000
Re: Happy Thanksgiving to all (logical necessity)(asleep at the switch) olcott <NoOne@NoWhere.com> - 2020-12-01 16:26 -0600
Re: Happy Thanksgiving to all (logical necessity)(asleep at the switch) olcott <NoOne@NoWhere.com> - 2020-12-01 17:21 -0600
Re: Happy Thanksgiving to all (logical necessity)(Numbskull?) olcott <NoOne@NoWhere.com> - 2020-12-01 20:53 -0600
Re: Happy Thanksgiving to all (logical necessity)[ Ben is a Numbskull !!! ] olcott <NoOne@NoWhere.com> - 2020-12-02 20:28 -0600
Re: Happy Thanksgiving to all (logical necessity)[ Ben is a Numbskull !!! ] olcott <NoOne@NoWhere.com> - 2020-12-04 20:29 -0600
Re: Happy Thanksgiving to all (logical necessity)[ Ben is a Numbskull !!! ] olcott <NoOne@NoWhere.com> - 2020-12-05 10:05 -0600
Re: Happy Thanksgiving to all (logical necessity)(Numbskull?) olcott <NoOne@NoWhere.com> - 2020-12-02 20:39 -0600
Re: Refuting the Peter Linz HP proof olcott <NoOne@NoWhere.com> - 2020-12-03 12:42 -0600
Re: Refuting the Peter Linz HP proof olcott <NoOne@NoWhere.com> - 2020-12-04 08:40 -0600
Re: Refuting the Peter Linz HP proof olcott <NoOne@NoWhere.com> - 2020-12-04 10:06 -0600
Re: Refuting the Peter Linz HP proof olcott <NoOne@NoWhere.com> - 2020-12-04 13:34 -0600
Re: Happy Thanksgiving to all (logical necessity)[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-02 21:52 -0600
Re: Local halt decider enabled[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-03 08:46 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-03 08:53 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-03 10:49 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-04 08:24 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-04 08:28 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-04 09:46 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-04 10:57 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-04 13:55 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-05 10:22 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-05 13:22 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-05 10:59 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-05 12:52 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-05 13:24 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-05 14:15 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-05 15:21 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-05 16:23 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-05 16:25 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-05 22:40 -0600
Re: Refutation of Peter Linz HP proof [ Logical Necessity ] olcott <NoOne@NoWhere.com> - 2020-12-06 13:18 -0600
Re: Refutation of Peter Linz HP proof [ Logical Necessity ] Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-06 19:59 +0000
Re: Refutation of Peter Linz HP proof [ Logical Necessity ] olcott <NoOne@NoWhere.com> - 2020-12-06 14:07 -0600
Re: Refutation of Peter Linz HP proof [ Logical Necessity ] Jeff Barnett <jbb@notatt.com> - 2020-12-06 16:59 -0700
Re: Refutation of Peter Linz HP proof [ Logical Necessity ] olcott <NoOne@NoWhere.com> - 2020-12-06 14:29 -0600
Re: Refutation of Peter Linz HP proof [ Logical Necessity ] olcott <NoOne@NoWhere.com> - 2020-12-07 14:16 -0600
Re: Refutation of Peter Linz HP proof [ Logical Necessity ] Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-07 21:16 +0000
Re: Refutation of Peter Linz HP proof [ Logical Necessity ] olcott <NoOne@NoWhere.com> - 2020-12-07 15:21 -0600
Re: Refutation of Peter Linz HP proof [ Logical Necessity ] Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-07 22:10 +0000
Re: Refutation of Peter Linz HP proof [ Logical Necessity ] olcott <NoOne@NoWhere.com> - 2020-12-07 16:26 -0600
Re: Refutation of Peter Linz HP proof [ Logical Necessity ] Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-08 02:03 +0000
Re: Refutation of Peter Linz HP proof [ divide by zero error returns no value ] olcott <NoOne@NoWhere.com> - 2020-12-07 20:22 -0600
Re: Refutation of Peter Linz HP proof [ divide by zero error returns no value ] Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-08 03:09 +0000
Re: Refutation of Peter Linz HP proof [ divide by zero error returns no value ] olcott <NoOne@NoWhere.com> - 2020-12-07 21:37 -0600
Re: Refutation of Peter Linz HP proof [ Logical Necessity ] olcott <NoOne@NoWhere.com> - 2020-12-07 14:42 -0600
Re: Refutation of Peter Linz HP proof [ Recursion with TMs ] olcott <NoOne@NoWhere.com> - 2020-12-07 19:05 -0600
Re: Refutation of Peter Linz HP proof [ Recursion with TMs ] olcott <NoOne@NoWhere.com> - 2020-12-07 21:51 -0600
Re: Refutation of Peter Linz HP proof [ Recursion with TMs ] olcott <NoOne@NoWhere.com> - 2020-12-08 15:25 -0600
Re: Refutation of Peter Linz HP proof [ Recursion with TMs ] Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-08 21:44 +0000
Re: Refutation of Peter Linz HP proof [ Dishonest dodges ] olcott <NoOne@NoWhere.com> - 2020-12-06 14:47 -0600
Re: Renaming DebugTrace() to H or Halts[ Halts == Simulate ] olcott <NoOne@NoWhere.com> - 2020-12-06 08:31 -0600
Re: Renaming DebugTrace() to H or Halts[ Halts == Simulate ] olcott <NoOne@NoWhere.com> - 2020-12-07 13:32 -0600
Re: Renaming DebugTrace() to H or Halts[ Halts == Simulate ] olcott <NoOne@NoWhere.com> - 2020-12-08 08:42 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-04 11:10 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-04 09:50 -0600
Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ] olcott <NoOne@NoWhere.com> - 2020-12-04 11:20 -0600
Re: Happy Thanksgiving to all (logical necessity)(Numbskull?) olcott <NoOne@NoWhere.com> - 2020-12-04 20:44 -0600
Re: Happy Thanksgiving to all (logical necessity)(Numbskull?) olcott <NoOne@NoWhere.com> - 2020-12-05 19:55 -0600
Re: Both invocations of Confound_Halts() are decided consistently (Ben's ADD) olcott <NoOne@NoWhere.com> - 2020-12-07 20:13 -0600
Re: Happy Thanksgiving to all (logical necessity)(Over Ben's head) olcott <NoOne@NoWhere.com> - 2020-12-07 20:26 -0600
Re: Refuting the Peter Linz HP Proof (Ben is proven wrong by the actual facts) olcott <NoOne@NoWhere.com> - 2020-12-02 12:05 -0600
Re: Refuting the Peter Linz HP Proof (Ben is proven wrong by the actual facts) olcott <NoOne@NoWhere.com> - 2020-12-02 12:07 -0600
Re: Refuting the Peter Linz HP Proof (Ben is proven wrong by the actual facts) olcott <NoOne@NoWhere.com> - 2020-12-02 13:12 -0600
Re: Refuting the Peter Linz HP Proof (Ben is proven wrong by the actual facts) olcott <NoOne@NoWhere.com> - 2020-12-02 14:24 -0600
Re: Refuting the Peter Linz HP Proof (Ben is proven wrong by the actual facts) olcott <NoOne@NoWhere.com> - 2020-12-02 15:22 -0600
Re: Refuting the Peter Linz HP Proof (Ben is proven wrong by the actual facts)(nitwit) olcott <NoOne@NoWhere.com> - 2020-12-02 16:03 -0600
Re: Refuting the Peter Linz HP Proof (Ben is proven wrong by the actual facts) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-02 21:45 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-02 19:27 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-03 18:18 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-02 19:50 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-03 18:32 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-03 12:35 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-03 15:47 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-07 12:29 -0600
Re: Refuting the Peter Linz HP Proof (Ben still tries to dodge the truth) olcott <NoOne@NoWhere.com> - 2020-12-07 20:10 -0600
Re: Refuting the Peter Linz HP Proof (Ben still tries to dodge the truth) olcott <NoOne@NoWhere.com> - 2020-12-08 08:33 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-09 12:04 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-09 22:48 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-10 12:13 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-10 12:21 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 08:22 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 08:20 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 08:44 -0600
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] olcott <NoOne@NoWhere.com> - 2020-12-10 15:02 -0600
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-10 21:19 +0000
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] olcott <NoOne@NoWhere.com> - 2020-12-10 15:53 -0600
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-10 23:38 +0000
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] olcott <NoOne@NoWhere.com> - 2020-12-10 18:16 -0600
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-11 00:19 +0000
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] olcott <NoOne@NoWhere.com> - 2020-12-10 18:27 -0600
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-11 00:29 +0000
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] olcott <NoOne@NoWhere.com> - 2020-12-10 18:45 -0600
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 00:54 +0000
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] olcott <NoOne@NoWhere.com> - 2020-12-10 19:48 -0600
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-11 00:55 +0000
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] olcott <NoOne@NoWhere.com> - 2020-12-10 19:01 -0600
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-11 01:03 +0000
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 01:14 +0000
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] Jeff Barnett <jbb@notatt.com> - 2020-12-10 21:54 -0700
Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-10 23:10 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 18:58 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 01:13 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 19:33 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 19:13 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 20:53 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 19:18 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-11 18:20 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-12 00:34 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-11 18:47 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-11 18:48 -0600
Re: Refuting the Peter Linz HP Proof (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-12 09:31 -0600
Re: Refuting the Peter Linz HP Proof (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-12 10:24 -0600
Re: Refuting the Peter Linz HP Proof (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-12 11:38 -0600
Re: Refuting the Peter Linz HP Proof (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-12 11:45 -0600
Re: Refuting the Peter Linz HP Proof (deciders within infinite recursion) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-12 17:55 +0000
Re: Refuting the Peter Linz HP Proof (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-12 12:26 -0600
Re: Refuting the Peter Linz HP Proof (deciders within infinite recursion) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-12 19:01 +0000
Re: Refuting the Peter Linz HP Proof (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-12 14:01 -0600
Re: Refuting the Peter Linz HP Proof (deciders within infinite recursion) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-12 20:04 +0000
Re: Refuting the Peter Linz HP Proof (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-14 08:25 -0600
Re: Refuting the Peter Linz HP Proof (deciders within infinite recursion) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-14 17:45 +0000
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-14 12:50 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-14 15:42 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-14 19:34 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-15 09:36 +0000
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (Halts() as an exception handler) olcott <NoOne@NoWhere.com> - 2020-12-15 08:50 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (Halts() as an exception handler) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-15 17:18 +0000
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-15 08:28 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-15 09:21 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-15 10:28 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-15 17:38 +0000
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-15 12:13 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-17 08:24 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-17 09:16 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-17 10:55 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-17 17:05 +0000
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-17 12:13 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-17 19:03 +0000
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-18 11:54 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-17 11:07 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-17 12:21 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-17 19:08 +0000
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (as easy as 1,2,3) olcott <NoOne@NoWhere.com> - 2020-12-17 13:26 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (as easy as 1,2,3) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-17 20:20 +0000
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-17 16:27 +0000
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) olcott <NoOne@NoWhere.com> - 2020-12-17 18:35 -0600
Re: Refuting the {Linz, Sipser and Kozen} HP Proofs (deciders within infinite recursion) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-12-14 15:37 -0800
Re: Refuting the Peter Linz HP Proof [ infinitely recursive Turing machines ] olcott <NoOne@NoWhere.com> - 2020-12-12 10:13 -0600
Re: Refuting the Peter Linz HP Proof [ infinitely recursive Turing machines ] olcott <NoOne@NoWhere.com> - 2020-12-12 10:29 -0600
Re: Refuting the Peter Linz HP Proof [ infinitely recursive Turing machines ] Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-12 16:41 +0000
Re: Refuting the Peter Linz HP Proof [ infinitely recursive Turing machines ] olcott <NoOne@NoWhere.com> - 2020-12-12 10:44 -0600
Re: Refuting the Peter Linz HP Proof (Kaz most definitely has agreed with olcott) olcott <NoOne@NoWhere.com> - 2020-12-10 09:17 -0600
Re: Refuting the Peter Linz HP Proof (Kaz most definitely has agreed with olcott) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-10 15:20 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-09 19:46 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 08:37 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 09:21 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 10:16 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 14:34 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-10 22:23 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 17:30 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-10 23:37 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 18:12 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 00:51 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 19:12 -0600
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) Jeff Barnett <jbb@notatt.com> - 2020-12-10 21:50 -0700
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-10 23:03 -0600
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 08:15 -0600
Re: Refuting the Peter Linz HP Proof Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-11 14:34 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 08:39 -0600
Re: Refuting the Peter Linz HP Proof Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-11 14:52 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 09:07 -0600
Re: Refuting the Peter Linz HP Proof Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-11 15:10 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 09:15 -0600
Re: Refuting the Peter Linz HP Proof Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-11 15:23 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 09:29 -0600
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 10:23 -0600
Re: Refuting the Peter Linz HP Proof "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-12-11 16:59 -0800
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 19:08 -0600
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 19:10 -0600
Re: Refuting the Peter Linz HP Proof Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 18:52 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 12:59 -0600
Re: Refuting the Peter Linz HP Proof Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 18:35 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 13:45 -0600
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 09:14 -0600
Re: Refuting the Peter Linz HP Proof Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 19:04 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 13:17 -0600
Re: Refuting the Peter Linz HP Proof Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 19:44 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 13:58 -0600
Re: Refuting the Peter Linz HP Proof Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 20:07 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 14:20 -0600
Re: Refuting the Peter Linz HP Proof Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 23:20 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 17:31 -0600
Re: Refuting the Peter Linz HP Proof Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-12 00:19 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 18:46 -0600
Re: Refuting the Peter Linz HP Proof Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-12 01:00 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 19:16 -0600
Re: Refuting the Peter Linz HP Proof Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-12 02:13 +0000
Re: Refuting the Peter Linz HP Proof Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-12 02:18 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 10:22 -0600
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 12:38 -0600
Re: Refuting the Peter Linz HP Proof Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 18:31 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 12:55 -0600
Re: Refuting the Peter Linz HP Proof Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 19:17 +0000
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 17:45 -0600
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 15:58 -0600
Re: Refuting the Peter Linz HP Proof olcott <NoOne@NoWhere.com> - 2020-12-11 17:23 -0600
Re: Refuting the Peter Linz HP Proof Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 23:28 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-11 18:26 +0000
Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) olcott <NoOne@NoWhere.com> - 2020-12-11 12:48 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs olcott <NoOne@NoWhere.com> - 2020-12-15 10:09 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-16 13:23 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-16 14:04 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-16 20:21 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) Jeff Barnett <jbb@notatt.com> - 2020-12-16 13:33 -0700
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-16 20:44 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-16 15:00 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-16 21:09 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-16 16:49 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-17 00:21 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-16 16:37 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-16 17:43 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-17 00:28 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-16 20:46 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-17 04:24 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-17 10:49 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-17 19:15 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-17 15:06 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-17 17:29 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-18 18:02 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-18 12:24 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-17 21:18 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-12-17 20:20 -0800
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-16 18:44 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-17 01:55 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-16 22:59 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-17 05:36 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-17 10:37 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-17 16:46 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-19 09:38 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-19 09:43 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-19 10:20 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (universal versus partial decider) olcott <NoOne@NoWhere.com> - 2020-12-19 10:47 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-19 22:32 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-19 17:51 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-20 05:21 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Richard insists on acting stupidly) olcott <NoOne@NoWhere.com> - 2020-12-20 13:43 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Richard insists on acting stupidly) olcott <NoOne@NoWhere.com> - 2020-12-20 16:20 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Richard insists on acting stupidly) Jeff Barnett <jbb@notatt.com> - 2020-12-20 16:37 -0700
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Richard insists on acting stupidly) olcott <NoOne@NoWhere.com> - 2020-12-20 18:22 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-19 10:00 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-19 15:21 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-19 19:30 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-19 19:42 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Ben's example) olcott <NoOne@NoWhere.com> - 2020-12-19 20:01 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Mathematical Mapping) olcott <NoOne@NoWhere.com> - 2020-12-20 12:19 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-19 19:54 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-20 18:41 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-12-20 16:43 -0800
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-20 20:37 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-20 21:55 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-12-20 20:05 -0800
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-21 04:44 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-20 23:06 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-21 12:39 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-21 19:31 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-21 14:52 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-21 21:55 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-21 13:08 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-21 14:57 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-21 21:59 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-21 16:52 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-21 16:53 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-22 01:25 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-22 09:39 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-22 10:57 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-22 17:03 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-22 11:46 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-22 18:37 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-22 12:57 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-22 13:44 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-22 14:18 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-22 21:23 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-23 11:40 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-22 14:34 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-21 12:34 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (objections addressed) olcott <NoOne@NoWhere.com> - 2020-12-22 20:25 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) olcott <NoOne@NoWhere.com> - 2020-12-23 14:45 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-23 20:54 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) olcott <NoOne@NoWhere.com> - 2020-12-23 16:27 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-23 23:10 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) olcott <NoOne@NoWhere.com> - 2020-12-23 16:43 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) olcott <NoOne@NoWhere.com> - 2020-12-23 21:42 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) olcott <NoOne@NoWhere.com> - 2020-12-24 11:36 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-24 17:43 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) olcott <NoOne@NoWhere.com> - 2020-12-24 11:51 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Halt_Decider c++ class) olcott <NoOne@NoWhere.com> - 2020-12-24 13:20 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) olcott <NoOne@NoWhere.com> - 2020-12-24 22:27 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) olcott <NoOne@NoWhere.com> - 2020-12-26 14:10 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (HP decidability thesis) olcott <NoOne@NoWhere.com> - 2020-12-26 15:42 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Exercise) olcott <NoOne@NoWhere.com> - 2020-12-26 14:40 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Exercise) olcott <NoOne@NoWhere.com> - 2020-12-29 09:43 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-24 18:00 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) olcott <NoOne@NoWhere.com> - 2020-12-24 12:12 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-24 19:25 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) olcott <NoOne@NoWhere.com> - 2020-12-24 14:01 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) olcott <NoOne@NoWhere.com> - 2020-12-26 15:35 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-26 22:29 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (stupid dishonest or both) olcott <NoOne@NoWhere.com> - 2020-12-26 17:25 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (stupid dishonest or both) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-27 00:48 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (stupid dishonest or both) olcott <NoOne@NoWhere.com> - 2020-12-26 20:04 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (stupid dishonest or both) olcott <NoOne@NoWhere.com> - 2020-12-26 21:38 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (stupid dishonest or both) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-27 05:04 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (HP criteria) olcott <NoOne@NoWhere.com> - 2020-12-28 13:17 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (HP criteria) olcott <NoOne@NoWhere.com> - 2020-12-28 14:03 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (HP criteria) olcott <NoOne@NoWhere.com> - 2020-12-28 18:17 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider axioms) olcott <NoOne@NoWhere.com> - 2020-12-29 09:16 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider axioms) olcott <NoOne@NoWhere.com> - 2020-12-29 11:00 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider axiom has been validated) olcott <NoOne@NoWhere.com> - 2020-12-30 15:17 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider axiom has been validated) olcott <NoOne@NoWhere.com> - 2020-12-30 15:52 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider axiom has been validated) olcott <NoOne@NoWhere.com> - 2020-12-30 22:34 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider axiom has been validated) olcott <NoOne@NoWhere.com> - 2020-12-30 22:54 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider axiom has been validated) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-31 05:26 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider axiom has been validated) olcott <NoOne@NoWhere.com> - 2020-12-30 23:47 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider axiom has been validated) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-31 09:58 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider axiom has been validated) olcott <NoOne@NoWhere.com> - 2020-12-31 08:49 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider decides H_Hat() correctly) olcott <NoOne@NoWhere.com> - 2020-12-31 11:18 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider axiom has been validated) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-31 18:09 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider axiom has been validated) olcott <NoOne@NoWhere.com> - 2020-12-31 16:17 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [---Pathological self-reference(Olcott 2004)---] olcott <NoOne@NoWhere.com> - 2020-12-31 18:22 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [---Pathological self-reference(Olcott 2004)---] olcott <NoOne@NoWhere.com> - 2020-12-31 21:14 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [---Pathological self-reference(Olcott 2004)---] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-01 03:32 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [---Pathological self-reference(Olcott 2004)---] olcott <NoOne@NoWhere.com> - 2020-12-31 21:47 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [---Pathological self-reference(Olcott 2004)---] olcott <NoOne@NoWhere.com> - 2020-12-31 23:26 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [---Pathological self-reference(Olcott 2004)---] olcott <NoOne@NoWhere.com> - 2021-01-01 11:01 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [---Pathological self-reference(Olcott 2004)---] olcott <NoOne@NoWhere.com> - 2021-01-01 12:24 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [---Pathological self-reference(Olcott 2004)---] olcott <NoOne@NoWhere.com> - 2021-01-01 13:59 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [---Pathological self-reference(Olcott 2004)---] olcott <NoOne@NoWhere.com> - 2021-01-01 16:15 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [---Pathological self-reference(Olcott 2004)---] olcott <NoOne@NoWhere.com> - 2021-01-01 17:02 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [---Pathological self-reference(Olcott 2004)---] olcott <NoOne@NoWhere.com> - 2021-01-01 13:39 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [---Pathological self-reference(Olcott 2004)---] olcott <NoOne@NoWhere.com> - 2021-01-01 13:46 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [---Pathological self-reference(Olcott 2004)---] olcott <NoOne@NoWhere.com> - 2021-01-01 11:16 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [---Pathological self-reference(Olcott 2004)---] olcott <NoOne@NoWhere.com> - 2021-01-01 12:50 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ misinformation ] olcott <NoOne@NoWhere.com> - 2021-01-01 17:57 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ misinformation ] olcott <NoOne@NoWhere.com> - 2021-01-01 18:56 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ misinformation ] olcott <NoOne@NoWhere.com> - 2021-01-02 09:31 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ misinformation ] olcott <NoOne@NoWhere.com> - 2021-01-02 10:05 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ misinformation ] olcott <NoOne@NoWhere.com> - 2021-01-02 11:53 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ revised non-halting criteria is not pathological ] olcott <NoOne@NoWhere.com> - 2021-01-02 13:33 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider axiom has been validated) olcott <NoOne@NoWhere.com> - 2020-12-31 08:53 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (solving the HP is possible) olcott <NoOne@NoWhere.com> - 2020-12-31 11:29 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (solving the HP is possible) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-31 18:10 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (solving the HP is possible) olcott <NoOne@NoWhere.com> - 2020-12-31 15:48 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (solving the HP is possible) olcott <NoOne@NoWhere.com> - 2020-12-31 18:06 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (solving the HP is possible) olcott <NoOne@NoWhere.com> - 2020-12-31 20:35 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (HP criteria) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-29 03:15 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (pathological self-reference) olcott <NoOne@NoWhere.com> - 2020-12-29 10:45 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) Jeff Barnett <jbb@notatt.com> - 2020-12-26 17:35 -0700
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ double sqrt(X) ] olcott <NoOne@NoWhere.com> - 2020-12-26 21:20 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ double sqrt(X) ] olcott <NoOne@NoWhere.com> - 2020-12-28 13:00 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ double sqrt(X) ] olcott <NoOne@NoWhere.com> - 2020-12-28 13:35 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ double sqrt(X) ] olcott <NoOne@NoWhere.com> - 2020-12-28 17:59 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ double sqrt(X) ] Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-29 03:35 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ three modes ] olcott <NoOne@NoWhere.com> - 2020-12-29 10:17 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ three modes ] Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-29 17:17 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ three modes ] olcott <NoOne@NoWhere.com> - 2020-12-29 11:24 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ three modes ] Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-29 18:37 +0000
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (Functions do not always return values) olcott <NoOne@NoWhere.com> - 2020-12-28 12:44 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (essence of my solution) olcott <NoOne@NoWhere.com> - 2020-12-29 10:00 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (HP proof criteria is a cheap trick) olcott <NoOne@NoWhere.com> - 2020-12-29 11:08 -0600
Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (HP proof criteria is a cheap trick) Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-29 18:12 +0000
Re: Happy Thanksgiving to all (Ben is proven wrong by the actual facts) olcott <NoOne@NoWhere.com> - 2020-12-02 15:24 -0600
Re: Happy Thanksgiving to all (Ben is proven wrong by the actual facts) olcott <NoOne@NoWhere.com> - 2020-12-02 20:36 -0600
Re: Happy Thanksgiving to all (Ben is proven wrong by the actual facts) olcott <NoOne@NoWhere.com> - 2020-12-02 21:00 -0600
Re: Happy Thanksgiving to all (Ben is proven wrong by the actual facts) Jeff Barnett <jbb@notatt.com> - 2020-12-02 21:23 -0700
Re: Happy Thanksgiving to all (logical necessity) Jeff Barnett <jbb@notatt.com> - 2020-11-28 17:34 -0700
Re: Happy Thanksgiving to all (logical necessity) olcott <NoOne@NoWhere.com> - 2020-11-28 19:03 -0600
Re: Happy Thanksgiving to all Kaz Kylheku <563-365-8930@kylheku.com> - 2020-11-30 20:27 +0000
Re: Happy Thanksgiving to all (infinite recursion slaps them in the face) olcott <NoOne@NoWhere.com> - 2020-11-30 16:57 -0600
Page 20 of 21 — ← Prev page 1 … 18 19 [20] 21 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-02 11:53 -0600 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ misinformation ] |
| Message-ID | <rcednQjyHfaFLm3CnZ2dnUU7-XnNnZ2d@giganews.com> |
| In reply to | #2465 |
On 1/2/2021 11:31 AM, Richard Damon wrote:
> On 1/2/21 11:05 AM, olcott wrote:
>> On 1/2/2021 9:40 AM, Richard Damon wrote:
>>> On 1/2/21 10:31 AM, olcott wrote:
>>>> On 1/2/2021 9:20 AM, Richard Damon wrote:
>>>>> On 1/2/21 9:52 AM, olcott wrote:
>>>>>> On 1/1/2021 9:18 PM, Richard Damon wrote:
>>>>>>> On 1/1/21 7:56 PM, olcott wrote:
>>>>>>>> On 1/1/2021 6:31 PM, Richard Damon wrote:
>>>>>>>>> On 1/1/21 6:57 PM, olcott wrote:
>>>>>>>>>> On 1/1/2021 4:55 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/1/21 5:20 PM, olcott wrote:
>>>>>>>>>>>> On 1/1/2021 4:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 1/1/2021 10:47 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I have been studying pathological self-reference since 2004.
>>>>>>>>>>>>>>>> There is
>>>>>>>>>>>>>>>> nothing that can correctly handle it because it is a
>>>>>>>>>>>>>>>> semantic
>>>>>>>>>>>>>>>> error.
>>>>>>>>>>>>>>>> It is comparable to asking the question: What time is it
>>>>>>>>>>>>>>>> yes or
>>>>>>>>>>>>>>>> no?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Not this again. Repeat after me: "every instance of the
>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>> has a correct yes/no answer".
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u32 Input_Halts = Halts(P, P);
>>>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Neither value from the set of {true, false} returned by
>>>>>>>>>>>>>> Halts() to
>>>>>>>>>>>>>> H_Hat() is correct
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, this is wrong, though you probably did not mean to say
>>>>>>>>>>>>> exactly
>>>>>>>>>>>>> that.
>>>>>>>>>>>> Yes I did mean exactly that and you knew damned well that I did
>>>>>>>>>>>> mean
>>>>>>>>>>>> exactly that.
>>>>>>>>>>>>
>>>>>>>>>>>> If Halts returns true, that is the wrong answer because H_Hat()
>>>>>>>>>>>> loops.
>>>>>>>>>>>> If Halts returns false, that is the wrong answer because H_Hat()
>>>>>>>>>>>> halts.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Right. that means that Halts can't be right, not that there is no
>>>>>>>>>>> answer
>>>>>>>>>>> to the halting state of H_Hat.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It doesn't even mean that Halts() cannot be right. It does mean
>>>>>>>>>> that
>>>>>>>>>> Halts() must terminate its simulation of H_Hat() before making its
>>>>>>>>>> halting decision.
>>>>>>>>>>
>>>>>>>>>> As long as it is no longer possible to provide a counter example
>>>>>>>>>> that
>>>>>>>>>> cannot be determined to be placed in the category of inputs
>>>>>>>>>> with the
>>>>>>>>>> property of infinite execution or inputs without this property
>>>>>>>>>> then
>>>>>>>>>> the
>>>>>>>>>> halting problem undecidability proofs have been refuted.
>>>>>>>>>>
>>>>>>>>>> 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.
>>>>>>>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>>>>>>>
>>>>>>>>>> A decider is only required to make a decision for every input.
>>>>>>>>>> It typically does this at the end of its execution.
>>>>>>>>>>
>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>> {
>>>>>>>>>> u32 Input_Halts = Halts(P, P);
>>>>>>>>>> if (Input_Halts)
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> u32 Input_Halts = Halts((u32)H_Hat, (u32)H_Hat);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> When Halts() returns its correct decision in main() this proves
>>>>>>>>>> that it
>>>>>>>>>> is a decider, any opinion to the contrary is simply
>>>>>>>>>> misinformation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Except when you check the answer it gives, it doesn't match what
>>>>>>>>> H_Hat
>>>>>>>>> actually does. Thus it doesn't correctly decide.
>>>>>>>>>
>>>>>>>>
>>>>>>>> YOU MUST HAVE FREAKING BRAIN DAMAGE !!!
>>>>>>>>
>>>>>>>> As I have said far too many times it does not fricking answer the
>>>>>>>> question about what the freak that the input does.
>>>>>>>
>>>>>>> And, becuase we CAN run that input as a program, (assuming you fix
>>>>>>> your
>>>>>>> machine to have just a local working decider) we can see that with
>>>>>>> the
>>>>>>> answer you claim wiil be generated, the machine will HALT.
>>>>>>>
>>>>>>> Your attempt to change the question is basically answering the
>>>>>>> questions
>>>>>>> "Did the Dog Bark?" with "The Cat Purred a lot".
>>>>>>>
>>>>>>> It REALLY doesn't matter if the halt decider had problems and
>>>>>>> decided it
>>>>>>> needed to halt the simulation (in fact, as has been said, there is no
>>>>>>> requriremet that it do ANY simulation), the only answer that
>>>>>>> matters is
>>>>>>> what the program would do when run by itself.
>>>>>>>
>>>>>>> In fact, the fact that the machine does come to a halt is proof
>>>>>>> that if
>>>>>>> that level of the halt detector didn't abort the execution, and
>>>>>>> let the
>>>>>>> next layer do the abort, it would have seen that the execution did
>>>>>>> terminate, and it would have returned Halting, so the 'need to halt'
>>>>>>> clause wasn't actually met.
>>>>>>>>
>>>>>>>> THIS IS ALL THAT WE NEED FOR A UNIVERSAL HALT DECIDER
>>>>>>>> It answers the question about whether or not the input has the
>>>>>>>> property
>>>>>>>> of infinite execution.
>>>>>>>>
>>>>>>>
>>>>>>> It needs to CORRECTLY answer the question, which we just showed
>>>>>>> that it
>>>>>>> didn't (at least if Halt meets its requirement to provide an
>>>>>>> answer in
>>>>>>> finite time).
>>>>>>>
>>>>>>>> The point of my prior reply is that all the times that everyone said
>>>>>>>> that the halt decider must return a value to the caller that
>>>>>>>> invokes in
>>>>>>>> in infinite recursion IS PURE BULLSHIT.
>>>>>>>
>>>>>>> It seem that you have some problems with basic things like rules and
>>>>>>> definitions.
>>>>>>>>
>>>>>>>> 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.
>>>>>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>>>>>
>>>>>>>> As long as Halts eventually returns a result by any means
>>>>>>>> what-so-ever
>>>>>>>> then Halts <is> a freaking decider.
>>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Can you see that a program that divides all inputs into those with the
>>>>>> property of infinite execution and those that do not have this
>>>>>> property
>>>>>> would solve the halting problem, or are you a liar?
>>>>>
>>>>>
>>>>> A program that CORRECTLY divides all programs into Halting and
>>>>> Non-Halting will satisfy the requirement,
>>>> That was not the question.
>>>>
>>>
>>> Making a program to arbitrarily divide other programs into categories
>>> but not needing to be correct about it is trivial. That is NOT the
>>> Halting Problem.
>>>
>>> Also, the Halting Problem is about Halting, not some strange property
>>> that if the Halting Decider was just a UTM would the execution go on
>>> forever, That is a different question.
>>>
>>
>> A program that has the property of infinite execution is a program that
>> would execute infinitely if its simulation was never stopped.
>>
>
> The key point you KEEP on missing is that H_Hat calling Halts can NOT
> cause infinite execution with a working Halts because Halts must decide
> in finite time for ALL inputs.
>
The ONLY way that it can do this is to stop simulating the otherwise
infinite recursion of H_Hat().
Any and all programs that would never terminate unless their simulation
was stopped <are> programs with the property of infinite execution.
H_Hat() is a program that would never terminate unless its simulation
was stopped thus a program with the property of infinite execution.
Pathological self-reference (Olcott 2004) has been removed from the
halting problem criteria thus refuting the conventional HP
undecidability proofs.
comp.theory
Peter Olcott Sep 5, 2004, 11:21:57 AM
The Liar Paradox can be shown to be nothing more than
a incorrectly formed statement because of its pathological
self-reference. The Halting Problem can only exist because
of this same sort of pathological self-reference.
https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-02 13:33 -0600 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ revised non-halting criteria is not pathological ] |
| Message-ID | <foadnbSvI9cKV23CnZ2dnUU7-QfNnZ2d@giganews.com> |
| In reply to | #2466 |
On 1/2/2021 12:54 PM, Richard Damon wrote:
> On 1/2/21 12:53 PM, olcott wrote:
>> On 1/2/2021 11:31 AM, Richard Damon wrote:
>>> On 1/2/21 11:05 AM, olcott wrote:
>>>> On 1/2/2021 9:40 AM, Richard Damon wrote:
>>>>> On 1/2/21 10:31 AM, olcott wrote:
>>>>>> On 1/2/2021 9:20 AM, Richard Damon wrote:
>>>>>>> On 1/2/21 9:52 AM, olcott wrote:
>>>>>>>> On 1/1/2021 9:18 PM, Richard Damon wrote:
>>>>>>>>> On 1/1/21 7:56 PM, olcott wrote:
>>>>>>>>>> On 1/1/2021 6:31 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/1/21 6:57 PM, olcott wrote:
>>>>>>>>>>>> On 1/1/2021 4:55 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/1/21 5:20 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/1/2021 4:05 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 1/1/2021 10:47 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I have been studying pathological self-reference since
>>>>>>>>>>>>>>>>>> 2004.
>>>>>>>>>>>>>>>>>> There is
>>>>>>>>>>>>>>>>>> nothing that can correctly handle it because it is a
>>>>>>>>>>>>>>>>>> semantic
>>>>>>>>>>>>>>>>>> error.
>>>>>>>>>>>>>>>>>> It is comparable to asking the question: What time is it
>>>>>>>>>>>>>>>>>> yes or
>>>>>>>>>>>>>>>>>> no?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Not this again. Repeat after me: "every instance of the
>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>> has a correct yes/no answer".
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> u32 Input_Halts = Halts(P, P);
>>>>>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Neither value from the set of {true, false} returned by
>>>>>>>>>>>>>>>> Halts() to
>>>>>>>>>>>>>>>> H_Hat() is correct
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, this is wrong, though you probably did not mean to say
>>>>>>>>>>>>>>> exactly
>>>>>>>>>>>>>>> that.
>>>>>>>>>>>>>> Yes I did mean exactly that and you knew damned well that I
>>>>>>>>>>>>>> did
>>>>>>>>>>>>>> mean
>>>>>>>>>>>>>> exactly that.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If Halts returns true, that is the wrong answer because
>>>>>>>>>>>>>> H_Hat()
>>>>>>>>>>>>>> loops.
>>>>>>>>>>>>>> If Halts returns false, that is the wrong answer because
>>>>>>>>>>>>>> H_Hat()
>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right. that means that Halts can't be right, not that there
>>>>>>>>>>>>> is no
>>>>>>>>>>>>> answer
>>>>>>>>>>>>> to the halting state of H_Hat.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It doesn't even mean that Halts() cannot be right. It does mean
>>>>>>>>>>>> that
>>>>>>>>>>>> Halts() must terminate its simulation of H_Hat() before
>>>>>>>>>>>> making its
>>>>>>>>>>>> halting decision.
>>>>>>>>>>>>
>>>>>>>>>>>> As long as it is no longer possible to provide a counter example
>>>>>>>>>>>> that
>>>>>>>>>>>> cannot be determined to be placed in the category of inputs
>>>>>>>>>>>> with the
>>>>>>>>>>>> property of infinite execution or inputs without this property
>>>>>>>>>>>> then
>>>>>>>>>>>> the
>>>>>>>>>>>> halting problem undecidability proofs have been refuted.
>>>>>>>>>>>>
>>>>>>>>>>>> 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.
>>>>>>>>>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>>>>>>>>>
>>>>>>>>>>>> A decider is only required to make a decision for every input.
>>>>>>>>>>>> It typically does this at the end of its execution.
>>>>>>>>>>>>
>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>> {
>>>>>>>>>>>> u32 Input_Halts = Halts(P, P);
>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>> return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> u32 Input_Halts = Halts((u32)H_Hat, (u32)H_Hat);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> When Halts() returns its correct decision in main() this proves
>>>>>>>>>>>> that it
>>>>>>>>>>>> is a decider, any opinion to the contrary is simply
>>>>>>>>>>>> misinformation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Except when you check the answer it gives, it doesn't match what
>>>>>>>>>>> H_Hat
>>>>>>>>>>> actually does. Thus it doesn't correctly decide.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> YOU MUST HAVE FREAKING BRAIN DAMAGE !!!
>>>>>>>>>>
>>>>>>>>>> As I have said far too many times it does not fricking answer the
>>>>>>>>>> question about what the freak that the input does.
>>>>>>>>>
>>>>>>>>> And, becuase we CAN run that input as a program, (assuming you fix
>>>>>>>>> your
>>>>>>>>> machine to have just a local working decider) we can see that with
>>>>>>>>> the
>>>>>>>>> answer you claim wiil be generated, the machine will HALT.
>>>>>>>>>
>>>>>>>>> Your attempt to change the question is basically answering the
>>>>>>>>> questions
>>>>>>>>> "Did the Dog Bark?" with "The Cat Purred a lot".
>>>>>>>>>
>>>>>>>>> It REALLY doesn't matter if the halt decider had problems and
>>>>>>>>> decided it
>>>>>>>>> needed to halt the simulation (in fact, as has been said, there
>>>>>>>>> is no
>>>>>>>>> requriremet that it do ANY simulation), the only answer that
>>>>>>>>> matters is
>>>>>>>>> what the program would do when run by itself.
>>>>>>>>>
>>>>>>>>> In fact, the fact that the machine does come to a halt is proof
>>>>>>>>> that if
>>>>>>>>> that level of the halt detector didn't abort the execution, and
>>>>>>>>> let the
>>>>>>>>> next layer do the abort, it would have seen that the execution did
>>>>>>>>> terminate, and it would have returned Halting, so the 'need to
>>>>>>>>> halt'
>>>>>>>>> clause wasn't actually met.
>>>>>>>>>>
>>>>>>>>>> THIS IS ALL THAT WE NEED FOR A UNIVERSAL HALT DECIDER
>>>>>>>>>> It answers the question about whether or not the input has the
>>>>>>>>>> property
>>>>>>>>>> of infinite execution.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It needs to CORRECTLY answer the question, which we just showed
>>>>>>>>> that it
>>>>>>>>> didn't (at least if Halt meets its requirement to provide an
>>>>>>>>> answer in
>>>>>>>>> finite time).
>>>>>>>>>
>>>>>>>>>> The point of my prior reply is that all the times that everyone
>>>>>>>>>> said
>>>>>>>>>> that the halt decider must return a value to the caller that
>>>>>>>>>> invokes in
>>>>>>>>>> in infinite recursion IS PURE BULLSHIT.
>>>>>>>>>
>>>>>>>>> It seem that you have some problems with basic things like rules
>>>>>>>>> and
>>>>>>>>> definitions.
>>>>>>>>>>
>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>>>>>>>>>
>>>>>>>>>> As long as Halts eventually returns a result by any means
>>>>>>>>>> what-so-ever
>>>>>>>>>> then Halts <is> a freaking decider.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Can you see that a program that divides all inputs into those
>>>>>>>> with the
>>>>>>>> property of infinite execution and those that do not have this
>>>>>>>> property
>>>>>>>> would solve the halting problem, or are you a liar?
>>>>>>>
>>>>>>>
>>>>>>> A program that CORRECTLY divides all programs into Halting and
>>>>>>> Non-Halting will satisfy the requirement,
>>>>>> That was not the question.
>>>>>>
>>>>>
>>>>> Making a program to arbitrarily divide other programs into categories
>>>>> but not needing to be correct about it is trivial. That is NOT the
>>>>> Halting Problem.
>>>>>
>>>>> Also, the Halting Problem is about Halting, not some strange property
>>>>> that if the Halting Decider was just a UTM would the execution go on
>>>>> forever, That is a different question.
>>>>>
>>>>
>>>> A program that has the property of infinite execution is a program that
>>>> would execute infinitely if its simulation was never stopped.
>>>>
>>>
>>> The key point you KEEP on missing is that H_Hat calling Halts can NOT
>>> cause infinite execution with a working Halts because Halts must decide
>>> in finite time for ALL inputs.
>>>
>>
>> The ONLY way that it can do this is to stop simulating the otherwise
>> infinite recursion of H_Hat().
>
> The ultimate question isn't wether H_Hat has infinite execution, but if
> Halts(), as a proper Turing Machine Equivalent, can predict it.
>
If we simply hypothsize that the Church-Turing thesis is true then
within this assumption if any damn program what-so-ever can detect that
any input has the property of infinite execution then within this
assumption we know damn well that a TM can do the same.
> If Halts DOES stop the execution and return the answer, then H_Hat can
> have finite execution BECAUSE Halts terminated it. If Halts doesn't stop
> the execution to return the answer, then Halts is unable to become a
> Halting Decider, and thus fails.
The is why the freaking halting criteria has to be:
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.
On Saturday, November 28, 2020 at 2:00:28 PM UTC-8, olcott wrote:
> Every computation that would not halt if its simulation
> were not halted is by logical necessity a non-halting computation.
>>
>> Any and all programs that would never terminate unless their simulation
>> was stopped <are> programs with the property of infinite execution.
>>
>> H_Hat() is a program that would never terminate unless its simulation
>> was stopped thus a program with the property of infinite execution.
>
> But, if Halts is able to decide and indicate this, then H_Hat doesn't
> need to be stopped, and thus doesn't have infinite execution.
We are maintaining a strict wall of separation between the program under
test and the halt decider so that the halt decider does not taint its
halting decision by its own actions.
As long as the halting criteria models the pathological self-reference
(Olcott 2004) of the liar paradox a universal halt decider cannot be
defined. We must remove the AFU criteria and replace it with criteria
that does not have the pathological self-reference (Olcott 2004) of the
liar paradox.
>>
>> Pathological self-reference (Olcott 2004) has been removed from the
>> halting problem criteria thus refuting the conventional HP
>> undecidability proofs.
>>
>> comp.theory
>> Peter Olcott Sep 5, 2004, 11:21:57 AM
>>
>> The Liar Paradox can be shown to be nothing more than
>> a incorrectly formed statement because of its pathological
>> self-reference. The Halting Problem can only exist because
>> of this same sort of pathological self-reference.
>>
>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>
>
> The Halting Problem DOES allow for this 'pathological' self-reference,
The big mistake of the HP undecidability proofs is that they all assume
that the pathological halt deciding criteria is the only criteria. Once
we get rid of that false assumption their otherwise pathological inputs
become decidable.
> so therefore you seem to admit that the Halting Problem, as classically
> stated has the proper conclusion of the thesis that there can not exist
> a Turing Machine that can decide the Halting/Non-Halting status of every
> machine/input combination.
>
This criteria <does> correctly decide non-halting:
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.
On Saturday, November 28, 2020 at 2:00:28 PM UTC-8, olcott wrote:
> Every computation that would not halt if its simulation
> were not halted is by logical necessity a non-halting computation.
> THe key point is that if you want to change the criteria of the
> decision, you make it a different problem.
It revised non-halting criteria still divides inputs into halting and
non-halting, thus does directly address the actual halting problem.
It measures non-halting in a non-pathological rather than the
conventional pathological way.
> Which is fine, you just then
> can not say you have disproved Linz et all, because you have shown a
> solution to a different problem.
>
> The Rules are The Rules,
>
--
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 | 2020-12-31 08:53 -0600 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (halt decider axiom has been validated) |
| Message-ID | <kM2dnehIRoSee3DCnZ2dnUU7-QHNnZ2d@giganews.com> |
| In reply to | #2433 |
On 12/31/2020 7:28 AM, Richard Damon wrote:
> On 12/30/20 11:54 PM, olcott wrote:
>> On 12/30/2020 7:45 PM, Richard Damon wrote:
>>> On 12/30/20 8:34 PM, olcott wrote:
>>>> On 12/30/2020 7:17 PM, Richard Damon wrote:
>>>>> On 12/30/20 6:00 PM, olcott wrote:
>>>>>> On 12/30/2020 4:12 PM, Richard Damon wrote:
>>>>>>> On 12/30/20 4:52 PM, olcott wrote:
>>>>>>>> On 12/30/2020 3:36 PM, Richard Damon wrote:
>>>>>>>>> On 12/30/20 4:17 PM, olcott wrote:
>>>>>>>>>> On 12/30/2020 2:46 PM, Richard Damon wrote:
>>>>>>>>>>> On 12/30/20 3:37 PM, olcott wrote:
>>>>>>>>>>>> On 12/30/2020 12:53 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 12/29/20 12:00 PM, olcott wrote:
>>>>>>>>>>>>>> On 12/29/2020 10:20 AM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void halter(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void tester2(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> Halts(P, P);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void tester(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u32 PP = (u32) tester2;
>>>>>>>>>>>>>> Halts(PP, P);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void halt_tester(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u32 PP = (u32)tester;
>>>>>>>>>>>>>> u32 II = (u32)halter;
>>>>>>>>>>>>>> Halts(PP, II);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u32 P = (u32)tester;
>>>>>>>>>>>>>> u32 I = (u32)halt_tester;
>>>>>>>>>>>>>> Halts(P, I);
>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I had to correct your code. I did not analyze it. I had to
>>>>>>>>>>>>>> manually
>>>>>>>>>>>>>> terminate it because global halt deciding has not be
>>>>>>>>>>>>>> re-enabled
>>>>>>>>>>>>>> yet.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Interesting code problem then, since the code should absolutely
>>>>>>>>>>>>> halt
>>>>>>>>>>>>> and
>>>>>>>>>>>>> not need the global halt decider to stop it.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> void halter(u32 P)
>>>>>>>>>>>> {
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> void tester2(u32 P)
>>>>>>>>>>>> {
>>>>>>>>>>>> //((int(*)(int))P)(P);
>>>>>>>>>>>> ((int(*)(int))P)(P);
>>>>>>>>>>>> // Halts(P, P);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> void tester(u32 P)
>>>>>>>>>>>> {
>>>>>>>>>>>> u32 PP = (u32) tester2;
>>>>>>>>>>>> ((int(*)(int))PP)(P);
>>>>>>>>>>>> // Halts(PP, P);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> void halt_tester(u32 P)
>>>>>>>>>>>> {
>>>>>>>>>>>> u32 PP = (u32)tester;
>>>>>>>>>>>> u32 II = (u32)halter;
>>>>>>>>>>>> ((int(*)(int))PP)(II);
>>>>>>>>>>>> // Halts(PP, II);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> u32 P = (u32)tester;
>>>>>>>>>>>> u32 I = (u32)halt_tester;
>>>>>>>>>>>> // Halts(P, I);
>>>>>>>>>>>> ((int(*)(int))P)(I);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> This code does halt.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Boy are you being perveres. Of course if main doesn't call
>>>>>>>>>>> anything
>>>>>>>>>>> (and
>>>>>>>>>>> doesn't have a loop) it will halt.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> (1) Apparently you are unfamiliar with function pointer syntax.
>>>>>>>>>> main() <is> calling P(I).
>>>>>>>>>
>>>>>>>>> Ok, I missed the added code.
>>>>>>>>>>
>>>>>>>>>>> I am going to take the subterfuge as admission that you see that
>>>>>>>>>>> you
>>>>>>>>>>> logic and code is flawed,
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> (2) This has been validated against your corrected code:
>>>>>>>>>>
>>>>>>>>>> Every time the same function is called from the same machine
>>>>>>>>>> address a
>>>>>>>>>> second time (within an execution trace of user-code) without any
>>>>>>>>>> CONTROL
>>>>>>>>>> FLOW INSTRUCTIONS in-between is a case of infinite recursion.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> What control flow instruction is there?
>>>>>>>>>
>>>>>>>>> Note, if you are calling the function call a control flow, then you
>>>>>>>>> need
>>>>>>>>> to consider calls to Halts or Debug_Step as control flow too.
>>>>>>>>>
>>>>>>>>> That or explain why with the call to Halts the answer changes.
>>>>>>>>>
>>>>>>>>> This code exactly matches your criteria of why you declare tha
>>>>>>>>> H_Hat
>>>>>>>>> has
>>>>>>>>> infinite recursion.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If there are two calls to Halts() (within an execution trace of user
>>>>>>>> code) from the same machine address and there are no other control
>>>>>>>> flow
>>>>>>>> instructions of any kind (including function calls) in-between
>>>>>>>> then we
>>>>>>>> definitely have infinite invocation of Halts():
>>>>>>>>
>>>>>>>> void H_Hat(u32 P)
>>>>>>>> {
>>>>>>>> u32 Input_Halts = Halts(P, P);
>>>>>>>> if (Input_Halts)
>>>>>>>> HERE: goto HERE;
>>>>>>>> else
>>>>>>>> HALT
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> So my provide program, that DID call Halts in a number of places had
>>>>>>> two
>>>>>>> calls to Halts, at the same address (because it was the same call to
>>>>>>> Halts in the code) that were nested,
>>>>>>>
>>>>>>> These occurred in both tester and tester2.
>>>>>>>
>>>>>>> Or, are you saying that even unconditional calls count as control
>>>>>>> flow?
>>>>>>> That would be a very strange and limiting addition to the rule.
>>>>>>
>>>>>> Anything that changes the EIP to some other address than the
>>>>>> address of
>>>>>> the next instruction <is> control flow.
>>>>>
>>>>> So a GOTO is enough? NEVER heard of anyone using that sort of
>>>>> definition. Got a reference that says that?
>>>>
>>>> I designed the halt detector just smart enough to decide the
>>>> conventional halting problem counter-examples, thus proving that they
>>>> are decidable.
>>>>
>>>>
>>>>>>
>>>>>>> Does that mean you machine can't handle this version of H_Hat:?
>>>>>>>
>>>>>>> u32 H_Hat2(u32 P){
>>>>>>> return Halts(P, P);
>>>>>>> }
>>>>>>>
>>>>>>
>>>>>> It looks like it handles this.
>>>>>>
>>>>>>> void H_Hat(u32 P){
>>>>>>> U32 halting = H_Hat(P);
>>>>>>> if(halting)
>>>>>>> while(1);
>>>>>>> HALT;
>>>>>>> }
>>>>>>>
>>>>>>> when called as H_Hat(H_Hat).
>>>>>>>
>>>>>>> The mere insertion of an unconditional call breaks your ability to
>>>>>>> detect an 'infinite recursion'?
>>>>>>
>>>>>> I didn't think that it did yet a preliminary analysis of your code
>>>>>> indicates that it might.
>>>>>>
>>>>>> I still have a key bug that I have to fix before I can test this.
>>>>>> When user code calls an operating system function this is supposed to
>>>>>> show up in user code as a a function call and nothing else.
>>>>>>
>>>>>
>>>>> Here is another that should give even with this tight definition a
>>>>> determination of non-Halting even though it is halting:
>>>>>
>>>>>
>>>>> void halter(u32 P) {
>>>>> HALT;
>>>>> }
>>>>>
>>>>> void tester(u32 P) {
>>>>> u32 table[2] = {(u32)tester, (u32)halter};
>>>>> Halts(table[P], P+1);
>>>>> }
>>>>>
>>>>> int main() {
>>>>> Halts((u32) tester, 0);
>>>>> }
>>>>>
>>>>>
>>>>> This should trace:
>>>>>
>>>>> main
>>>>> Halts
>>>>> tester
>>>>> Halts
>>>>> tester
>>>>> Halts
>>>>> halter
>>>>> HALT
>>>>>
>>>>> This has the same call structure of H_Hat, with the
>>>>> tester -> Halts -> tester -> Halts
>>>>> pattern. It has NO conditional exection, or even branches of any sort
>>>>> other than calls to Halts. It can also be trivially changed to have an
>>>>> arbitrary number cycles before it terminates.
>>>>>
>>>>
>>>> It does not match the halt detector pattern in that it has a function
>>>> call between function calls to Halts().
>>>>
>>>> I made the pattern to be just smart enough to decide the conventional
>>>> halting problem counter-examples, thus proving that they are decidable.
>>>>
>>>
>>> That is EXACTLY the same call tree as H_Hat:
>>>
>>> void H_Hat(u32 P){
>>> u32 halting = Halts(P, P);
>>> if(halting)
>>> while(1);
>>> else
>>> HALT;
>>> }
>>>
>>> int main(){
>>> u32 P = (u32)H_Hat;
>>> Halts(P, P);
>>> HALT;
>>> }
>>>
>>> Trace:
>>>
>>> main
>>> Halts
>>> H_Hat
>>> Halts
>>> H_Hat
>>> and by here you tend to mark that infinite recursion has been seen.
>>>
>>> There is NO difference in the call tree.
>>>
>>> Tester has a few extra instructions in the trace, but nothing that
>>> qualifies as a conditional execution. There is NO function call, the
>>> code builds a table that takes the address of some functions (but that
>>> can actually be a static table), and a few data loads.
>>>
>>> Again, I will ask for some reference that says that unconditional calls
>>> or gotos are considered as conditional execution for this sort of
>>> recursion test. I think you are just making that up.
>>>
>>
>> Yes, I get it now. You found a case of false positive.
>>
>> None-the-less for all of the simplest possible encodings of the
>> conventional halting problem counter-examples the halt decider does
>> decide correctly. This is all that is needed to refute the proofs.
>>
>>
>
> No, it doesnt. ONE example where your decision rule is wrong is enough
> to show that it is not a Truthful Rule, and can not be taken as a axiom.
That is not the way that it works. False positives and false negatives
do not prove that the rule never works correctly they only prove that
the rule does not always work correctly. Since you know this it is a
little dishonest of you to imply otherwise.
Halts() does decide this function correctly:
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
else
HALT
}
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-31 11:29 -0600 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (solving the HP is possible) |
| Message-ID | <7Midncbkj_QRl3PCnZ2dnUU7-QPNnZ2d@giganews.com> |
| In reply to | #2433 |
On 12/31/2020 10:52 AM, Richard Damon wrote:
> On 12/30/20 11:54 PM, olcott wrote:
>> On 12/30/2020 7:45 PM, Richard Damon wrote:
>>> On 12/30/20 8:34 PM, olcott wrote:
>>>> On 12/30/2020 7:17 PM, Richard Damon wrote:
>>>>> On 12/30/20 6:00 PM, olcott wrote:
>>>>>> On 12/30/2020 4:12 PM, Richard Damon wrote:
>>>>>>> On 12/30/20 4:52 PM, olcott wrote:
>>>>>>>> On 12/30/2020 3:36 PM, Richard Damon wrote:
>>>>>>>>> On 12/30/20 4:17 PM, olcott wrote:
>>>>>>>>>> On 12/30/2020 2:46 PM, Richard Damon wrote:
>>>>>>>>>>> On 12/30/20 3:37 PM, olcott wrote:
>>>>>>>>>>>> On 12/30/2020 12:53 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 12/29/20 12:00 PM, olcott wrote:
>>>>>>>>>>>>>> On 12/29/2020 10:20 AM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void halter(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void tester2(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> Halts(P, P);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void tester(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u32 PP = (u32) tester2;
>>>>>>>>>>>>>> Halts(PP, P);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void halt_tester(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u32 PP = (u32)tester;
>>>>>>>>>>>>>> u32 II = (u32)halter;
>>>>>>>>>>>>>> Halts(PP, II);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u32 P = (u32)tester;
>>>>>>>>>>>>>> u32 I = (u32)halt_tester;
>>>>>>>>>>>>>> Halts(P, I);
>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I had to correct your code. I did not analyze it. I had to
>>>>>>>>>>>>>> manually
>>>>>>>>>>>>>> terminate it because global halt deciding has not be
>>>>>>>>>>>>>> re-enabled
>>>>>>>>>>>>>> yet.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Interesting code problem then, since the code should absolutely
>>>>>>>>>>>>> halt
>>>>>>>>>>>>> and
>>>>>>>>>>>>> not need the global halt decider to stop it.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> void halter(u32 P)
>>>>>>>>>>>> {
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> void tester2(u32 P)
>>>>>>>>>>>> {
>>>>>>>>>>>> //((int(*)(int))P)(P);
>>>>>>>>>>>> ((int(*)(int))P)(P);
>>>>>>>>>>>> // Halts(P, P);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> void tester(u32 P)
>>>>>>>>>>>> {
>>>>>>>>>>>> u32 PP = (u32) tester2;
>>>>>>>>>>>> ((int(*)(int))PP)(P);
>>>>>>>>>>>> // Halts(PP, P);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> void halt_tester(u32 P)
>>>>>>>>>>>> {
>>>>>>>>>>>> u32 PP = (u32)tester;
>>>>>>>>>>>> u32 II = (u32)halter;
>>>>>>>>>>>> ((int(*)(int))PP)(II);
>>>>>>>>>>>> // Halts(PP, II);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> u32 P = (u32)tester;
>>>>>>>>>>>> u32 I = (u32)halt_tester;
>>>>>>>>>>>> // Halts(P, I);
>>>>>>>>>>>> ((int(*)(int))P)(I);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> This code does halt.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Boy are you being perveres. Of course if main doesn't call
>>>>>>>>>>> anything
>>>>>>>>>>> (and
>>>>>>>>>>> doesn't have a loop) it will halt.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> (1) Apparently you are unfamiliar with function pointer syntax.
>>>>>>>>>> main() <is> calling P(I).
>>>>>>>>>
>>>>>>>>> Ok, I missed the added code.
>>>>>>>>>>
>>>>>>>>>>> I am going to take the subterfuge as admission that you see that
>>>>>>>>>>> you
>>>>>>>>>>> logic and code is flawed,
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> (2) This has been validated against your corrected code:
>>>>>>>>>>
>>>>>>>>>> Every time the same function is called from the same machine
>>>>>>>>>> address a
>>>>>>>>>> second time (within an execution trace of user-code) without any
>>>>>>>>>> CONTROL
>>>>>>>>>> FLOW INSTRUCTIONS in-between is a case of infinite recursion.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> What control flow instruction is there?
>>>>>>>>>
>>>>>>>>> Note, if you are calling the function call a control flow, then you
>>>>>>>>> need
>>>>>>>>> to consider calls to Halts or Debug_Step as control flow too.
>>>>>>>>>
>>>>>>>>> That or explain why with the call to Halts the answer changes.
>>>>>>>>>
>>>>>>>>> This code exactly matches your criteria of why you declare tha
>>>>>>>>> H_Hat
>>>>>>>>> has
>>>>>>>>> infinite recursion.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If there are two calls to Halts() (within an execution trace of user
>>>>>>>> code) from the same machine address and there are no other control
>>>>>>>> flow
>>>>>>>> instructions of any kind (including function calls) in-between
>>>>>>>> then we
>>>>>>>> definitely have infinite invocation of Halts():
>>>>>>>>
>>>>>>>> void H_Hat(u32 P)
>>>>>>>> {
>>>>>>>> u32 Input_Halts = Halts(P, P);
>>>>>>>> if (Input_Halts)
>>>>>>>> HERE: goto HERE;
>>>>>>>> else
>>>>>>>> HALT
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> So my provide program, that DID call Halts in a number of places had
>>>>>>> two
>>>>>>> calls to Halts, at the same address (because it was the same call to
>>>>>>> Halts in the code) that were nested,
>>>>>>>
>>>>>>> These occurred in both tester and tester2.
>>>>>>>
>>>>>>> Or, are you saying that even unconditional calls count as control
>>>>>>> flow?
>>>>>>> That would be a very strange and limiting addition to the rule.
>>>>>>
>>>>>> Anything that changes the EIP to some other address than the
>>>>>> address of
>>>>>> the next instruction <is> control flow.
>>>>>
>>>>> So a GOTO is enough? NEVER heard of anyone using that sort of
>>>>> definition. Got a reference that says that?
>>>>
>>>> I designed the halt detector just smart enough to decide the
>>>> conventional halting problem counter-examples, thus proving that they
>>>> are decidable.
>>>>
>>>>
>>>>>>
>>>>>>> Does that mean you machine can't handle this version of H_Hat:?
>>>>>>>
>>>>>>> u32 H_Hat2(u32 P){
>>>>>>> return Halts(P, P);
>>>>>>> }
>>>>>>>
>>>>>>
>>>>>> It looks like it handles this.
>>>>>>
>>>>>>> void H_Hat(u32 P){
>>>>>>> U32 halting = H_Hat(P);
>>>>>>> if(halting)
>>>>>>> while(1);
>>>>>>> HALT;
>>>>>>> }
>>>>>>>
>>>>>>> when called as H_Hat(H_Hat).
>>>>>>>
>>>>>>> The mere insertion of an unconditional call breaks your ability to
>>>>>>> detect an 'infinite recursion'?
>>>>>>
>>>>>> I didn't think that it did yet a preliminary analysis of your code
>>>>>> indicates that it might.
>>>>>>
>>>>>> I still have a key bug that I have to fix before I can test this.
>>>>>> When user code calls an operating system function this is supposed to
>>>>>> show up in user code as a a function call and nothing else.
>>>>>>
>>>>>
>>>>> Here is another that should give even with this tight definition a
>>>>> determination of non-Halting even though it is halting:
>>>>>
>>>>>
>>>>> void halter(u32 P) {
>>>>> HALT;
>>>>> }
>>>>>
>>>>> void tester(u32 P) {
>>>>> u32 table[2] = {(u32)tester, (u32)halter};
>>>>> Halts(table[P], P+1);
>>>>> }
>>>>>
>>>>> int main() {
>>>>> Halts((u32) tester, 0);
>>>>> }
>>>>>
>>>>>
>>>>> This should trace:
>>>>>
>>>>> main
>>>>> Halts
>>>>> tester
>>>>> Halts
>>>>> tester
>>>>> Halts
>>>>> halter
>>>>> HALT
>>>>>
>>>>> This has the same call structure of H_Hat, with the
>>>>> tester -> Halts -> tester -> Halts
>>>>> pattern. It has NO conditional exection, or even branches of any sort
>>>>> other than calls to Halts. It can also be trivially changed to have an
>>>>> arbitrary number cycles before it terminates.
>>>>>
>>>>
>>>> It does not match the halt detector pattern in that it has a function
>>>> call between function calls to Halts().
>>>>
>>>> I made the pattern to be just smart enough to decide the conventional
>>>> halting problem counter-examples, thus proving that they are decidable.
>>>>
>>>
>>> That is EXACTLY the same call tree as H_Hat:
>>>
>>> void H_Hat(u32 P){
>>> u32 halting = Halts(P, P);
>>> if(halting)
>>> while(1);
>>> else
>>> HALT;
>>> }
>>>
>>> int main(){
>>> u32 P = (u32)H_Hat;
>>> Halts(P, P);
>>> HALT;
>>> }
>>>
>>> Trace:
>>>
>>> main
>>> Halts
>>> H_Hat
>>> Halts
>>> H_Hat
>>> and by here you tend to mark that infinite recursion has been seen.
>>>
>>> There is NO difference in the call tree.
>>>
>>> Tester has a few extra instructions in the trace, but nothing that
>>> qualifies as a conditional execution. There is NO function call, the
>>> code builds a table that takes the address of some functions (but that
>>> can actually be a static table), and a few data loads.
>>>
>>> Again, I will ask for some reference that says that unconditional calls
>>> or gotos are considered as conditional execution for this sort of
>>> recursion test. I think you are just making that up.
>>>
>>
>> Yes, I get it now. You found a case of false positive.
>>
>> None-the-less for all of the simplest possible encodings of the
>> conventional halting problem counter-examples the halt decider does
>> decide correctly. This is all that is needed to refute the proofs.
>>
>
> You can not base a proof on a false axiom.
>
> You need to PROVE that your assumption you are using is a correct
> principle.
>
> Yes, there IS a correct rule with wording similar to what you are
> saying, but you have redefined some of the meanings that make the rule
> no longer valid. Since it has been disproven, you need to atually PROVE
> what you want to use or accept that your logic is unsound.
>
It is always possible to define increasingly complex instances of inputs
that Halts() will decide incorrectly up until the point that Halts() is
all knowing and the halting problem has been fully solved.
That I have shown that the simplest case of the conventional halting
problem counter-examples can be decided correctly refutes the proofs,
by showing that halting deciding is no longer shown to be impossible,
merely increasingly more difficult.
--
Copyright 2020 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 | 2020-12-31 18:10 +0000 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (solving the HP is possible) |
| Message-ID | <20201231100948.245@kylheku.com> |
| In reply to | #2441 |
On 2020-12-31, olcott <NoOne@NoWhere.com> wrote: > It is always possible to define increasingly complex instances of inputs > that Halts() will decide incorrectly up until the point that Halts() is > all knowing and the halting problem has been fully solved. There is no highest level of complexity, like there is no highest integer. Are you offering this statement as evidence of how you are a great thinker? -- TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-31 15:48 -0600 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (solving the HP is possible) |
| Message-ID | <T_SdnWrYed692nPCnZ2dnUU7-XPNnZ2d@giganews.com> |
| In reply to | #2441 |
On 12/31/2020 12:17 PM, Richard Damon wrote:
> On 12/31/20 12:29 PM, olcott wrote:
>> On 12/31/2020 10:52 AM, Richard Damon wrote:
>>> On 12/30/20 11:54 PM, olcott wrote:
>>>> On 12/30/2020 7:45 PM, Richard Damon wrote:
>>>>> On 12/30/20 8:34 PM, olcott wrote:
>>>>>> On 12/30/2020 7:17 PM, Richard Damon wrote:
>>>>>>> On 12/30/20 6:00 PM, olcott wrote:
>>>>>>>> On 12/30/2020 4:12 PM, Richard Damon wrote:
>>>>>>>>> On 12/30/20 4:52 PM, olcott wrote:
>>>>>>>>>> On 12/30/2020 3:36 PM, Richard Damon wrote:
>>>>>>>>>>> On 12/30/20 4:17 PM, olcott wrote:
>>>>>>>>>>>> On 12/30/2020 2:46 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 12/30/20 3:37 PM, olcott wrote:
>>>>>>>>>>>>>> On 12/30/2020 12:53 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 12/29/20 12:00 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 12/29/2020 10:20 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void halter(u32 P)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void tester2(u32 P)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> Halts(P, P);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void tester(u32 P)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> u32 PP = (u32) tester2;
>>>>>>>>>>>>>>>> Halts(PP, P);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void halt_tester(u32 P)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> u32 PP = (u32)tester;
>>>>>>>>>>>>>>>> u32 II = (u32)halter;
>>>>>>>>>>>>>>>> Halts(PP, II);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> u32 P = (u32)tester;
>>>>>>>>>>>>>>>> u32 I = (u32)halt_tester;
>>>>>>>>>>>>>>>> Halts(P, I);
>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I had to correct your code. I did not analyze it. I had to
>>>>>>>>>>>>>>>> manually
>>>>>>>>>>>>>>>> terminate it because global halt deciding has not be
>>>>>>>>>>>>>>>> re-enabled
>>>>>>>>>>>>>>>> yet.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Interesting code problem then, since the code should
>>>>>>>>>>>>>>> absolutely
>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>> not need the global halt decider to stop it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void halter(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void tester2(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> //((int(*)(int))P)(P);
>>>>>>>>>>>>>> ((int(*)(int))P)(P);
>>>>>>>>>>>>>> // Halts(P, P);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void tester(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u32 PP = (u32) tester2;
>>>>>>>>>>>>>> ((int(*)(int))PP)(P);
>>>>>>>>>>>>>> // Halts(PP, P);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void halt_tester(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u32 PP = (u32)tester;
>>>>>>>>>>>>>> u32 II = (u32)halter;
>>>>>>>>>>>>>> ((int(*)(int))PP)(II);
>>>>>>>>>>>>>> // Halts(PP, II);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u32 P = (u32)tester;
>>>>>>>>>>>>>> u32 I = (u32)halt_tester;
>>>>>>>>>>>>>> // Halts(P, I);
>>>>>>>>>>>>>> ((int(*)(int))P)(I);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This code does halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Boy are you being perveres. Of course if main doesn't call
>>>>>>>>>>>>> anything
>>>>>>>>>>>>> (and
>>>>>>>>>>>>> doesn't have a loop) it will halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> (1) Apparently you are unfamiliar with function pointer syntax.
>>>>>>>>>>>> main() <is> calling P(I).
>>>>>>>>>>>
>>>>>>>>>>> Ok, I missed the added code.
>>>>>>>>>>>>
>>>>>>>>>>>>> I am going to take the subterfuge as admission that you see
>>>>>>>>>>>>> that
>>>>>>>>>>>>> you
>>>>>>>>>>>>> logic and code is flawed,
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> (2) This has been validated against your corrected code:
>>>>>>>>>>>>
>>>>>>>>>>>> Every time the same function is called from the same machine
>>>>>>>>>>>> address a
>>>>>>>>>>>> second time (within an execution trace of user-code) without any
>>>>>>>>>>>> CONTROL
>>>>>>>>>>>> FLOW INSTRUCTIONS in-between is a case of infinite recursion.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> What control flow instruction is there?
>>>>>>>>>>>
>>>>>>>>>>> Note, if you are calling the function call a control flow,
>>>>>>>>>>> then you
>>>>>>>>>>> need
>>>>>>>>>>> to consider calls to Halts or Debug_Step as control flow too.
>>>>>>>>>>>
>>>>>>>>>>> That or explain why with the call to Halts the answer changes.
>>>>>>>>>>>
>>>>>>>>>>> This code exactly matches your criteria of why you declare tha
>>>>>>>>>>> H_Hat
>>>>>>>>>>> has
>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If there are two calls to Halts() (within an execution trace of
>>>>>>>>>> user
>>>>>>>>>> code) from the same machine address and there are no other control
>>>>>>>>>> flow
>>>>>>>>>> instructions of any kind (including function calls) in-between
>>>>>>>>>> then we
>>>>>>>>>> definitely have infinite invocation of Halts():
>>>>>>>>>>
>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>> {
>>>>>>>>>> u32 Input_Halts = Halts(P, P);
>>>>>>>>>> if (Input_Halts)
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> else
>>>>>>>>>> HALT
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So my provide program, that DID call Halts in a number of places
>>>>>>>>> had
>>>>>>>>> two
>>>>>>>>> calls to Halts, at the same address (because it was the same
>>>>>>>>> call to
>>>>>>>>> Halts in the code) that were nested,
>>>>>>>>>
>>>>>>>>> These occurred in both tester and tester2.
>>>>>>>>>
>>>>>>>>> Or, are you saying that even unconditional calls count as control
>>>>>>>>> flow?
>>>>>>>>> That would be a very strange and limiting addition to the rule.
>>>>>>>>
>>>>>>>> Anything that changes the EIP to some other address than the
>>>>>>>> address of
>>>>>>>> the next instruction <is> control flow.
>>>>>>>
>>>>>>> So a GOTO is enough? NEVER heard of anyone using that sort of
>>>>>>> definition. Got a reference that says that?
>>>>>>
>>>>>> I designed the halt detector just smart enough to decide the
>>>>>> conventional halting problem counter-examples, thus proving that they
>>>>>> are decidable.
>>>>>>
>>>>>>
>>>>>>>>
>>>>>>>>> Does that mean you machine can't handle this version of H_Hat:?
>>>>>>>>>
>>>>>>>>> u32 H_Hat2(u32 P){
>>>>>>>>> return Halts(P, P);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>
>>>>>>>> It looks like it handles this.
>>>>>>>>
>>>>>>>>> void H_Hat(u32 P){
>>>>>>>>> U32 halting = H_Hat(P);
>>>>>>>>> if(halting)
>>>>>>>>> while(1);
>>>>>>>>> HALT;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> when called as H_Hat(H_Hat).
>>>>>>>>>
>>>>>>>>> The mere insertion of an unconditional call breaks your ability to
>>>>>>>>> detect an 'infinite recursion'?
>>>>>>>>
>>>>>>>> I didn't think that it did yet a preliminary analysis of your code
>>>>>>>> indicates that it might.
>>>>>>>>
>>>>>>>> I still have a key bug that I have to fix before I can test this.
>>>>>>>> When user code calls an operating system function this is
>>>>>>>> supposed to
>>>>>>>> show up in user code as a a function call and nothing else.
>>>>>>>>
>>>>>>>
>>>>>>> Here is another that should give even with this tight definition a
>>>>>>> determination of non-Halting even though it is halting:
>>>>>>>
>>>>>>>
>>>>>>> void halter(u32 P) {
>>>>>>> HALT;
>>>>>>> }
>>>>>>>
>>>>>>> void tester(u32 P) {
>>>>>>> u32 table[2] = {(u32)tester, (u32)halter};
>>>>>>> Halts(table[P], P+1);
>>>>>>> }
>>>>>>>
>>>>>>> int main() {
>>>>>>> Halts((u32) tester, 0);
>>>>>>> }
>>>>>>>
>>>>>>>
>>>>>>> This should trace:
>>>>>>>
>>>>>>> main
>>>>>>> Halts
>>>>>>> tester
>>>>>>> Halts
>>>>>>> tester
>>>>>>> Halts
>>>>>>> halter
>>>>>>> HALT
>>>>>>>
>>>>>>> This has the same call structure of H_Hat, with the
>>>>>>> tester -> Halts -> tester -> Halts
>>>>>>> pattern. It has NO conditional exection, or even branches of any sort
>>>>>>> other than calls to Halts. It can also be trivially changed to
>>>>>>> have an
>>>>>>> arbitrary number cycles before it terminates.
>>>>>>>
>>>>>>
>>>>>> It does not match the halt detector pattern in that it has a function
>>>>>> call between function calls to Halts().
>>>>>>
>>>>>> I made the pattern to be just smart enough to decide the conventional
>>>>>> halting problem counter-examples, thus proving that they are
>>>>>> decidable.
>>>>>>
>>>>>
>>>>> That is EXACTLY the same call tree as H_Hat:
>>>>>
>>>>> void H_Hat(u32 P){
>>>>> u32 halting = Halts(P, P);
>>>>> if(halting)
>>>>> while(1);
>>>>> else
>>>>> HALT;
>>>>> }
>>>>>
>>>>> int main(){
>>>>> u32 P = (u32)H_Hat;
>>>>> Halts(P, P);
>>>>> HALT;
>>>>> }
>>>>>
>>>>> Trace:
>>>>>
>>>>> main
>>>>> Halts
>>>>> H_Hat
>>>>> Halts
>>>>> H_Hat
>>>>> and by here you tend to mark that infinite recursion has been seen.
>>>>>
>>>>> There is NO difference in the call tree.
>>>>>
>>>>> Tester has a few extra instructions in the trace, but nothing that
>>>>> qualifies as a conditional execution. There is NO function call, the
>>>>> code builds a table that takes the address of some functions (but that
>>>>> can actually be a static table), and a few data loads.
>>>>>
>>>>> Again, I will ask for some reference that says that unconditional calls
>>>>> or gotos are considered as conditional execution for this sort of
>>>>> recursion test. I think you are just making that up.
>>>>>
>>>>
>>>> Yes, I get it now. You found a case of false positive.
>>>>
>>>> None-the-less for all of the simplest possible encodings of the
>>>> conventional halting problem counter-examples the halt decider does
>>>> decide correctly. This is all that is needed to refute the proofs.
>>>>
>>>
>>> You can not base a proof on a false axiom.
>>>
>>> You need to PROVE that your assumption you are using is a correct
>>> principle.
>>>
>>> Yes, there IS a correct rule with wording similar to what you are
>>> saying, but you have redefined some of the meanings that make the rule
>>> no longer valid. Since it has been disproven, you need to atually PROVE
>>> what you want to use or accept that your logic is unsound.
>>>
>>
>> It is always possible to define increasingly complex instances of inputs
>> that Halts() will decide incorrectly up until the point that Halts() is
>> all knowing and the halting problem has been fully solved.
>>
>> That I have shown that the simplest case of the conventional halting
>> problem counter-examples can be decided correctly refutes the proofs,
>> by showing that halting deciding is no longer shown to be impossible,
>> merely increasingly more difficult.
>>
>
> The problem isn't essentially that your halt decider doesn't work for
> this case, but that the RULE that you are ASSUMING to work isn't valid.
>
The rule that I use in this case is sufficient to correctly decide this
case. A thousand years of additional development work may not be
sufficiently elaborated to correctly decide all cases.
> The ONLY justification you have for calling the execution of H_Hat
> non-halting is the application of a rule, that has been shown that when
> you use the definitions you are using, gives false positives.
>
The same function called with the same data from the same machine
address a second time is necessarily guaranteed to have the same
execution trace.
> What PROOF do you have that the results you are getting for H_Hat isn't
> another false positive.
>
A human can examine the execution trace of all of the user code and see
that there is nothing that can possibly break the cycle of infinite
recursion.
The code could do this too. It only has to also verify that the inputs
are identical. A human can already see this.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-31 18:06 -0600 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (solving the HP is possible) |
| Message-ID | <PK-dndI9NJQB-nPCnZ2dnUU7-W_NnZ2d@giganews.com> |
| In reply to | #2444 |
On 12/31/2020 4:22 PM, Richard Damon wrote:
> On 12/31/20 4:48 PM, olcott wrote:
>> On 12/31/2020 12:17 PM, Richard Damon wrote:
>>> On 12/31/20 12:29 PM, olcott wrote:
>>>> On 12/31/2020 10:52 AM, Richard Damon wrote:
>>>>> On 12/30/20 11:54 PM, olcott wrote:
>>>>>> On 12/30/2020 7:45 PM, Richard Damon wrote:
>>>>>>> On 12/30/20 8:34 PM, olcott wrote:
>>>>>>>> On 12/30/2020 7:17 PM, Richard Damon wrote:
>>>>>>>>> On 12/30/20 6:00 PM, olcott wrote:
>>>>>>>>>> On 12/30/2020 4:12 PM, Richard Damon wrote:
>>>>>>>>>>> On 12/30/20 4:52 PM, olcott wrote:
>>>>>>>>>>>> On 12/30/2020 3:36 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 12/30/20 4:17 PM, olcott wrote:
>>>>>>>>>>>>>> On 12/30/2020 2:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 12/30/20 3:37 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 12/30/2020 12:53 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 12/29/20 12:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 12/29/2020 10:20 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void halter(u32 P)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void tester2(u32 P)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> Halts(P, P);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void tester(u32 P)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> u32 PP = (u32) tester2;
>>>>>>>>>>>>>>>>>> Halts(PP, P);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void halt_tester(u32 P)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> u32 PP = (u32)tester;
>>>>>>>>>>>>>>>>>> u32 II = (u32)halter;
>>>>>>>>>>>>>>>>>> Halts(PP, II);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> u32 P = (u32)tester;
>>>>>>>>>>>>>>>>>> u32 I = (u32)halt_tester;
>>>>>>>>>>>>>>>>>> Halts(P, I);
>>>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I had to correct your code. I did not analyze it. I had to
>>>>>>>>>>>>>>>>>> manually
>>>>>>>>>>>>>>>>>> terminate it because global halt deciding has not be
>>>>>>>>>>>>>>>>>> re-enabled
>>>>>>>>>>>>>>>>>> yet.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Interesting code problem then, since the code should
>>>>>>>>>>>>>>>>> absolutely
>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>> not need the global halt decider to stop it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void halter(u32 P)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void tester2(u32 P)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> //((int(*)(int))P)(P);
>>>>>>>>>>>>>>>> ((int(*)(int))P)(P);
>>>>>>>>>>>>>>>> // Halts(P, P);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void tester(u32 P)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> u32 PP = (u32) tester2;
>>>>>>>>>>>>>>>> ((int(*)(int))PP)(P);
>>>>>>>>>>>>>>>> // Halts(PP, P);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void halt_tester(u32 P)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> u32 PP = (u32)tester;
>>>>>>>>>>>>>>>> u32 II = (u32)halter;
>>>>>>>>>>>>>>>> ((int(*)(int))PP)(II);
>>>>>>>>>>>>>>>> // Halts(PP, II);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> u32 P = (u32)tester;
>>>>>>>>>>>>>>>> u32 I = (u32)halt_tester;
>>>>>>>>>>>>>>>> // Halts(P, I);
>>>>>>>>>>>>>>>> ((int(*)(int))P)(I);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This code does halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Boy are you being perveres. Of course if main doesn't call
>>>>>>>>>>>>>>> anything
>>>>>>>>>>>>>>> (and
>>>>>>>>>>>>>>> doesn't have a loop) it will halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (1) Apparently you are unfamiliar with function pointer
>>>>>>>>>>>>>> syntax.
>>>>>>>>>>>>>> main() <is> calling P(I).
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ok, I missed the added code.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I am going to take the subterfuge as admission that you see
>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>> you
>>>>>>>>>>>>>>> logic and code is flawed,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (2) This has been validated against your corrected code:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Every time the same function is called from the same machine
>>>>>>>>>>>>>> address a
>>>>>>>>>>>>>> second time (within an execution trace of user-code)
>>>>>>>>>>>>>> without any
>>>>>>>>>>>>>> CONTROL
>>>>>>>>>>>>>> FLOW INSTRUCTIONS in-between is a case of infinite recursion.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> What control flow instruction is there?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Note, if you are calling the function call a control flow,
>>>>>>>>>>>>> then you
>>>>>>>>>>>>> need
>>>>>>>>>>>>> to consider calls to Halts or Debug_Step as control flow too.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That or explain why with the call to Halts the answer changes.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This code exactly matches your criteria of why you declare tha
>>>>>>>>>>>>> H_Hat
>>>>>>>>>>>>> has
>>>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If there are two calls to Halts() (within an execution trace of
>>>>>>>>>>>> user
>>>>>>>>>>>> code) from the same machine address and there are no other
>>>>>>>>>>>> control
>>>>>>>>>>>> flow
>>>>>>>>>>>> instructions of any kind (including function calls) in-between
>>>>>>>>>>>> then we
>>>>>>>>>>>> definitely have infinite invocation of Halts():
>>>>>>>>>>>>
>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>> {
>>>>>>>>>>>> u32 Input_Halts = Halts(P, P);
>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>> else
>>>>>>>>>>>> HALT
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So my provide program, that DID call Halts in a number of places
>>>>>>>>>>> had
>>>>>>>>>>> two
>>>>>>>>>>> calls to Halts, at the same address (because it was the same
>>>>>>>>>>> call to
>>>>>>>>>>> Halts in the code) that were nested,
>>>>>>>>>>>
>>>>>>>>>>> These occurred in both tester and tester2.
>>>>>>>>>>>
>>>>>>>>>>> Or, are you saying that even unconditional calls count as control
>>>>>>>>>>> flow?
>>>>>>>>>>> That would be a very strange and limiting addition to the rule.
>>>>>>>>>>
>>>>>>>>>> Anything that changes the EIP to some other address than the
>>>>>>>>>> address of
>>>>>>>>>> the next instruction <is> control flow.
>>>>>>>>>
>>>>>>>>> So a GOTO is enough? NEVER heard of anyone using that sort of
>>>>>>>>> definition. Got a reference that says that?
>>>>>>>>
>>>>>>>> I designed the halt detector just smart enough to decide the
>>>>>>>> conventional halting problem counter-examples, thus proving that
>>>>>>>> they
>>>>>>>> are decidable.
>>>>>>>>
>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> Does that mean you machine can't handle this version of H_Hat:?
>>>>>>>>>>>
>>>>>>>>>>> u32 H_Hat2(u32 P){
>>>>>>>>>>> return Halts(P, P);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It looks like it handles this.
>>>>>>>>>>
>>>>>>>>>>> void H_Hat(u32 P){
>>>>>>>>>>> U32 halting = H_Hat(P);
>>>>>>>>>>> if(halting)
>>>>>>>>>>> while(1);
>>>>>>>>>>> HALT;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> when called as H_Hat(H_Hat).
>>>>>>>>>>>
>>>>>>>>>>> The mere insertion of an unconditional call breaks your
>>>>>>>>>>> ability to
>>>>>>>>>>> detect an 'infinite recursion'?
>>>>>>>>>>
>>>>>>>>>> I didn't think that it did yet a preliminary analysis of your code
>>>>>>>>>> indicates that it might.
>>>>>>>>>>
>>>>>>>>>> I still have a key bug that I have to fix before I can test this.
>>>>>>>>>> When user code calls an operating system function this is
>>>>>>>>>> supposed to
>>>>>>>>>> show up in user code as a a function call and nothing else.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Here is another that should give even with this tight definition a
>>>>>>>>> determination of non-Halting even though it is halting:
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> void halter(u32 P) {
>>>>>>>>> HALT;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> void tester(u32 P) {
>>>>>>>>> u32 table[2] = {(u32)tester, (u32)halter};
>>>>>>>>> Halts(table[P], P+1);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main() {
>>>>>>>>> Halts((u32) tester, 0);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> This should trace:
>>>>>>>>>
>>>>>>>>> main
>>>>>>>>> Halts
>>>>>>>>> tester
>>>>>>>>> Halts
>>>>>>>>> tester
>>>>>>>>> Halts
>>>>>>>>> halter
>>>>>>>>> HALT
>>>>>>>>>
>>>>>>>>> This has the same call structure of H_Hat, with the
>>>>>>>>> tester -> Halts -> tester -> Halts
>>>>>>>>> pattern. It has NO conditional exection, or even branches of any
>>>>>>>>> sort
>>>>>>>>> other than calls to Halts. It can also be trivially changed to
>>>>>>>>> have an
>>>>>>>>> arbitrary number cycles before it terminates.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It does not match the halt detector pattern in that it has a
>>>>>>>> function
>>>>>>>> call between function calls to Halts().
>>>>>>>>
>>>>>>>> I made the pattern to be just smart enough to decide the
>>>>>>>> conventional
>>>>>>>> halting problem counter-examples, thus proving that they are
>>>>>>>> decidable.
>>>>>>>>
>>>>>>>
>>>>>>> That is EXACTLY the same call tree as H_Hat:
>>>>>>>
>>>>>>> void H_Hat(u32 P){
>>>>>>> u32 halting = Halts(P, P);
>>>>>>> if(halting)
>>>>>>> while(1);
>>>>>>> else
>>>>>>> HALT;
>>>>>>> }
>>>>>>>
>>>>>>> int main(){
>>>>>>> u32 P = (u32)H_Hat;
>>>>>>> Halts(P, P);
>>>>>>> HALT;
>>>>>>> }
>>>>>>>
>>>>>>> Trace:
>>>>>>>
>>>>>>> main
>>>>>>> Halts
>>>>>>> H_Hat
>>>>>>> Halts
>>>>>>> H_Hat
>>>>>>> and by here you tend to mark that infinite recursion has been seen.
>>>>>>>
>>>>>>> There is NO difference in the call tree.
>>>>>>>
>>>>>>> Tester has a few extra instructions in the trace, but nothing that
>>>>>>> qualifies as a conditional execution. There is NO function call, the
>>>>>>> code builds a table that takes the address of some functions (but
>>>>>>> that
>>>>>>> can actually be a static table), and a few data loads.
>>>>>>>
>>>>>>> Again, I will ask for some reference that says that unconditional
>>>>>>> calls
>>>>>>> or gotos are considered as conditional execution for this sort of
>>>>>>> recursion test. I think you are just making that up.
>>>>>>>
>>>>>>
>>>>>> Yes, I get it now. You found a case of false positive.
>>>>>>
>>>>>> None-the-less for all of the simplest possible encodings of the
>>>>>> conventional halting problem counter-examples the halt decider does
>>>>>> decide correctly. This is all that is needed to refute the proofs.
>>>>>>
>>>>>
>>>>> You can not base a proof on a false axiom.
>>>>>
>>>>> You need to PROVE that your assumption you are using is a correct
>>>>> principle.
>>>>>
>>>>> Yes, there IS a correct rule with wording similar to what you are
>>>>> saying, but you have redefined some of the meanings that make the rule
>>>>> no longer valid. Since it has been disproven, you need to atually PROVE
>>>>> what you want to use or accept that your logic is unsound.
>>>>>
>>>>
>>>> It is always possible to define increasingly complex instances of inputs
>>>> that Halts() will decide incorrectly up until the point that Halts() is
>>>> all knowing and the halting problem has been fully solved.
>>>>
>>>> That I have shown that the simplest case of the conventional halting
>>>> problem counter-examples can be decided correctly refutes the proofs,
>>>> by showing that halting deciding is no longer shown to be impossible,
>>>> merely increasingly more difficult.
>>>>
>>>
>>> The problem isn't essentially that your halt decider doesn't work for
>>> this case, but that the RULE that you are ASSUMING to work isn't valid.
>>>
>>
>> The rule that I use in this case is sufficient to correctly decide this
>> case. A thousand years of additional development work may not be
>> sufficiently elaborated to correctly decide all cases.
>
> Not, because it is incorrect for this case!! Do you have ANY proof to
> show that it IS correct, or is this just you taking it on Gut Feeling.
>
> It can be shown to be incorrect, by looking at what H_Hat does after it
> gets the answer (and if it doesn't, then Halts has already failed to
> meet the requirements).
>
>
>>> The ONLY justification you have for calling the execution of H_Hat
>>> non-halting is the application of a rule, that has been shown that when
>>> you use the definitions you are using, gives false positives.
>>>
>>
>> The same function called with the same data from the same machine
>> address a second time is necessarily guaranteed to have the same
>> execution trace.
>>
>
> Yes, but the Halt Decider has the requirement to interrupt the cycle to
> give an answer. Maybe you can argue that this is the reason you return
> non-halting, but when you do you find out that you were wrong.
When we use this as the halt deciding criteria then it can no longer be
proven that all inputs cannot be divided into those having the property
of infinite execution and those that do not:
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.
On Saturday, November 28, 2020 at 2:00:28 PM UTC-8, olcott wrote:
> Every computation that would not halt if its simulation
> were not halted is by logical necessity a non-halting computation.
You must be much dumber than a box of rocks because I have had to repeat
that fifty times.
>>> What PROOF do you have that the results you are getting for H_Hat isn't
>>> another false positive.
>>>
>>
>> A human can examine the execution trace of all of the user code and see
>> that there is nothing that can possibly break the cycle of infinite
>> recursion.
>
>
> Except that Halts MUST break it or it fails to meet its requirement.!!!
> (and it is easy to see that it can)
>
The only real requirement is that it can no longer be proved that all
inputs cannot be divided into those with the property of infinite
execution and those not having this property.
All the other "requirements" are bullshit double talk dishonesty.
> Yes, if H_Hat just invoked a UTM on H_Hat, it is clear that the
> execution is infinite, but Halts is NOT 'just' a UTM, it is a Halt
> Decider, so it is REQUIRED to figure out how to answer the question.
>
> Your fundamental issue is you presume that the Halt Decider can be just
> a simple UTM that figures out if it sees infinite execution. Self
> Referential Turing Machines, like Linx H^ show that such a design is
> insufficient. There are also a class of similar self referential
> machines that it is possible with a slightly smarter decider to figure out.
I have shown how the simplest encoding of the conventional halting
problem counter-examples can be correctly decided.
All the other "requirements" are bullshit double talk dishonesty.
> It is NOT H_Hats 'fault' that we hit a recursion that your Halts doesn't
> know how to handle, Halt NEEDS to be designed to figure out how to
> handle the self-referential machines, as they ARE allowed by the problem
> definition and the basic rules for Turing Machines
>
>>
>> The code could do this too. It only has to also verify that the inputs
>> are identical. A human can already see this.
>>
>
> And a human can easily see that if Halts meets its requirement to make
> the decision, then it will interrupt the infinite cycle that IT created
> and return an answer, which will be wrong.
>
You can baselessly claim that it is wrong only in terms of
bullshit double talk dishonesty.
What you cannot do is show that it did not decide its input based on
this necessarily correct halt deciding criteria:
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.
On Saturday, November 28, 2020 at 2:00:28 PM UTC-8, olcott wrote:
> Every computation that would not halt if its simulation
> were not halted is by logical necessity a non-halting computation.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-31 20:35 -0600 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (solving the HP is possible) |
| Message-ID | <SO2dnU_m6cTFF3PCnZ2dnUU7-TvNnZ2d@giganews.com> |
| In reply to | #2446 |
On 12/31/2020 6:24 PM, Richard Damon wrote:
> On 12/31/20 7:06 PM, olcott wrote:
>> On 12/31/2020 4:22 PM, Richard Damon wrote:
>>> On 12/31/20 4:48 PM, olcott wrote:
>>>> On 12/31/2020 12:17 PM, Richard Damon wrote:
>>>>> On 12/31/20 12:29 PM, olcott wrote:
>>>>>> On 12/31/2020 10:52 AM, Richard Damon wrote:
>>>>>>> On 12/30/20 11:54 PM, olcott wrote:
>>>>>>>> On 12/30/2020 7:45 PM, Richard Damon wrote:
>>>>>>>>> On 12/30/20 8:34 PM, olcott wrote:
>>>>>>>>>> On 12/30/2020 7:17 PM, Richard Damon wrote:
>>>>>>>>>>> On 12/30/20 6:00 PM, olcott wrote:
>>>>>>>>>>>> On 12/30/2020 4:12 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 12/30/20 4:52 PM, olcott wrote:
>>>>>>>>>>>>>> On 12/30/2020 3:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 12/30/20 4:17 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 12/30/2020 2:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 12/30/20 3:37 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 12/30/2020 12:53 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 12/29/20 12:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 12/29/2020 10:20 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void halter(u32 P)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void tester2(u32 P)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> Halts(P, P);
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void tester(u32 P)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> u32 PP = (u32) tester2;
>>>>>>>>>>>>>>>>>>>> Halts(PP, P);
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void halt_tester(u32 P)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> u32 PP = (u32)tester;
>>>>>>>>>>>>>>>>>>>> u32 II = (u32)halter;
>>>>>>>>>>>>>>>>>>>> Halts(PP, II);
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> u32 P = (u32)tester;
>>>>>>>>>>>>>>>>>>>> u32 I = (u32)halt_tester;
>>>>>>>>>>>>>>>>>>>> Halts(P, I);
>>>>>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I had to correct your code. I did not analyze it. I
>>>>>>>>>>>>>>>>>>>> had to
>>>>>>>>>>>>>>>>>>>> manually
>>>>>>>>>>>>>>>>>>>> terminate it because global halt deciding has not be
>>>>>>>>>>>>>>>>>>>> re-enabled
>>>>>>>>>>>>>>>>>>>> yet.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Interesting code problem then, since the code should
>>>>>>>>>>>>>>>>>>> absolutely
>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>>> not need the global halt decider to stop it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void halter(u32 P)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void tester2(u32 P)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> //((int(*)(int))P)(P);
>>>>>>>>>>>>>>>>>> ((int(*)(int))P)(P);
>>>>>>>>>>>>>>>>>> // Halts(P, P);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void tester(u32 P)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> u32 PP = (u32) tester2;
>>>>>>>>>>>>>>>>>> ((int(*)(int))PP)(P);
>>>>>>>>>>>>>>>>>> // Halts(PP, P);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void halt_tester(u32 P)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> u32 PP = (u32)tester;
>>>>>>>>>>>>>>>>>> u32 II = (u32)halter;
>>>>>>>>>>>>>>>>>> ((int(*)(int))PP)(II);
>>>>>>>>>>>>>>>>>> // Halts(PP, II);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> u32 P = (u32)tester;
>>>>>>>>>>>>>>>>>> u32 I = (u32)halt_tester;
>>>>>>>>>>>>>>>>>> // Halts(P, I);
>>>>>>>>>>>>>>>>>> ((int(*)(int))P)(I);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This code does halt.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Boy are you being perveres. Of course if main doesn't call
>>>>>>>>>>>>>>>>> anything
>>>>>>>>>>>>>>>>> (and
>>>>>>>>>>>>>>>>> doesn't have a loop) it will halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (1) Apparently you are unfamiliar with function pointer
>>>>>>>>>>>>>>>> syntax.
>>>>>>>>>>>>>>>> main() <is> calling P(I).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ok, I missed the added code.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I am going to take the subterfuge as admission that you see
>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>> you
>>>>>>>>>>>>>>>>> logic and code is flawed,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (2) This has been validated against your corrected code:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Every time the same function is called from the same machine
>>>>>>>>>>>>>>>> address a
>>>>>>>>>>>>>>>> second time (within an execution trace of user-code)
>>>>>>>>>>>>>>>> without any
>>>>>>>>>>>>>>>> CONTROL
>>>>>>>>>>>>>>>> FLOW INSTRUCTIONS in-between is a case of infinite
>>>>>>>>>>>>>>>> recursion.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What control flow instruction is there?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Note, if you are calling the function call a control flow,
>>>>>>>>>>>>>>> then you
>>>>>>>>>>>>>>> need
>>>>>>>>>>>>>>> to consider calls to Halts or Debug_Step as control flow too.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That or explain why with the call to Halts the answer
>>>>>>>>>>>>>>> changes.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This code exactly matches your criteria of why you declare
>>>>>>>>>>>>>>> tha
>>>>>>>>>>>>>>> H_Hat
>>>>>>>>>>>>>>> has
>>>>>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If there are two calls to Halts() (within an execution
>>>>>>>>>>>>>> trace of
>>>>>>>>>>>>>> user
>>>>>>>>>>>>>> code) from the same machine address and there are no other
>>>>>>>>>>>>>> control
>>>>>>>>>>>>>> flow
>>>>>>>>>>>>>> instructions of any kind (including function calls) in-between
>>>>>>>>>>>>>> then we
>>>>>>>>>>>>>> definitely have infinite invocation of Halts():
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u32 Input_Halts = Halts(P, P);
>>>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>> else
>>>>>>>>>>>>>> HALT
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> So my provide program, that DID call Halts in a number of
>>>>>>>>>>>>> places
>>>>>>>>>>>>> had
>>>>>>>>>>>>> two
>>>>>>>>>>>>> calls to Halts, at the same address (because it was the same
>>>>>>>>>>>>> call to
>>>>>>>>>>>>> Halts in the code) that were nested,
>>>>>>>>>>>>>
>>>>>>>>>>>>> These occurred in both tester and tester2.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Or, are you saying that even unconditional calls count as
>>>>>>>>>>>>> control
>>>>>>>>>>>>> flow?
>>>>>>>>>>>>> That would be a very strange and limiting addition to the rule.
>>>>>>>>>>>>
>>>>>>>>>>>> Anything that changes the EIP to some other address than the
>>>>>>>>>>>> address of
>>>>>>>>>>>> the next instruction <is> control flow.
>>>>>>>>>>>
>>>>>>>>>>> So a GOTO is enough? NEVER heard of anyone using that sort of
>>>>>>>>>>> definition. Got a reference that says that?
>>>>>>>>>>
>>>>>>>>>> I designed the halt detector just smart enough to decide the
>>>>>>>>>> conventional halting problem counter-examples, thus proving that
>>>>>>>>>> they
>>>>>>>>>> are decidable.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>> Does that mean you machine can't handle this version of H_Hat:?
>>>>>>>>>>>>>
>>>>>>>>>>>>> u32 H_Hat2(u32 P){
>>>>>>>>>>>>> return Halts(P, P);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It looks like it handles this.
>>>>>>>>>>>>
>>>>>>>>>>>>> void H_Hat(u32 P){
>>>>>>>>>>>>> U32 halting = H_Hat(P);
>>>>>>>>>>>>> if(halting)
>>>>>>>>>>>>> while(1);
>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> when called as H_Hat(H_Hat).
>>>>>>>>>>>>>
>>>>>>>>>>>>> The mere insertion of an unconditional call breaks your
>>>>>>>>>>>>> ability to
>>>>>>>>>>>>> detect an 'infinite recursion'?
>>>>>>>>>>>>
>>>>>>>>>>>> I didn't think that it did yet a preliminary analysis of your
>>>>>>>>>>>> code
>>>>>>>>>>>> indicates that it might.
>>>>>>>>>>>>
>>>>>>>>>>>> I still have a key bug that I have to fix before I can test
>>>>>>>>>>>> this.
>>>>>>>>>>>> When user code calls an operating system function this is
>>>>>>>>>>>> supposed to
>>>>>>>>>>>> show up in user code as a a function call and nothing else.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Here is another that should give even with this tight
>>>>>>>>>>> definition a
>>>>>>>>>>> determination of non-Halting even though it is halting:
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> void halter(u32 P) {
>>>>>>>>>>> HALT;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> void tester(u32 P) {
>>>>>>>>>>> u32 table[2] = {(u32)tester, (u32)halter};
>>>>>>>>>>> Halts(table[P], P+1);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main() {
>>>>>>>>>>> Halts((u32) tester, 0);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> This should trace:
>>>>>>>>>>>
>>>>>>>>>>> main
>>>>>>>>>>> Halts
>>>>>>>>>>> tester
>>>>>>>>>>> Halts
>>>>>>>>>>> tester
>>>>>>>>>>> Halts
>>>>>>>>>>> halter
>>>>>>>>>>> HALT
>>>>>>>>>>>
>>>>>>>>>>> This has the same call structure of H_Hat, with the
>>>>>>>>>>> tester -> Halts -> tester -> Halts
>>>>>>>>>>> pattern. It has NO conditional exection, or even branches of any
>>>>>>>>>>> sort
>>>>>>>>>>> other than calls to Halts. It can also be trivially changed to
>>>>>>>>>>> have an
>>>>>>>>>>> arbitrary number cycles before it terminates.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It does not match the halt detector pattern in that it has a
>>>>>>>>>> function
>>>>>>>>>> call between function calls to Halts().
>>>>>>>>>>
>>>>>>>>>> I made the pattern to be just smart enough to decide the
>>>>>>>>>> conventional
>>>>>>>>>> halting problem counter-examples, thus proving that they are
>>>>>>>>>> decidable.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> That is EXACTLY the same call tree as H_Hat:
>>>>>>>>>
>>>>>>>>> void H_Hat(u32 P){
>>>>>>>>> u32 halting = Halts(P, P);
>>>>>>>>> if(halting)
>>>>>>>>> while(1);
>>>>>>>>> else
>>>>>>>>> HALT;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main(){
>>>>>>>>> u32 P = (u32)H_Hat;
>>>>>>>>> Halts(P, P);
>>>>>>>>> HALT;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Trace:
>>>>>>>>>
>>>>>>>>> main
>>>>>>>>> Halts
>>>>>>>>> H_Hat
>>>>>>>>> Halts
>>>>>>>>> H_Hat
>>>>>>>>> and by here you tend to mark that infinite recursion has been seen.
>>>>>>>>>
>>>>>>>>> There is NO difference in the call tree.
>>>>>>>>>
>>>>>>>>> Tester has a few extra instructions in the trace, but nothing that
>>>>>>>>> qualifies as a conditional execution. There is NO function call,
>>>>>>>>> the
>>>>>>>>> code builds a table that takes the address of some functions (but
>>>>>>>>> that
>>>>>>>>> can actually be a static table), and a few data loads.
>>>>>>>>>
>>>>>>>>> Again, I will ask for some reference that says that unconditional
>>>>>>>>> calls
>>>>>>>>> or gotos are considered as conditional execution for this sort of
>>>>>>>>> recursion test. I think you are just making that up.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, I get it now. You found a case of false positive.
>>>>>>>>
>>>>>>>> None-the-less for all of the simplest possible encodings of the
>>>>>>>> conventional halting problem counter-examples the halt decider does
>>>>>>>> decide correctly. This is all that is needed to refute the proofs.
>>>>>>>>
>>>>>>>
>>>>>>> You can not base a proof on a false axiom.
>>>>>>>
>>>>>>> You need to PROVE that your assumption you are using is a correct
>>>>>>> principle.
>>>>>>>
>>>>>>> Yes, there IS a correct rule with wording similar to what you are
>>>>>>> saying, but you have redefined some of the meanings that make the
>>>>>>> rule
>>>>>>> no longer valid. Since it has been disproven, you need to atually
>>>>>>> PROVE
>>>>>>> what you want to use or accept that your logic is unsound.
>>>>>>>
>>>>>>
>>>>>> It is always possible to define increasingly complex instances of
>>>>>> inputs
>>>>>> that Halts() will decide incorrectly up until the point that
>>>>>> Halts() is
>>>>>> all knowing and the halting problem has been fully solved.
>>>>>>
>>>>>> That I have shown that the simplest case of the conventional halting
>>>>>> problem counter-examples can be decided correctly refutes the proofs,
>>>>>> by showing that halting deciding is no longer shown to be impossible,
>>>>>> merely increasingly more difficult.
>>>>>>
>>>>>
>>>>> The problem isn't essentially that your halt decider doesn't work for
>>>>> this case, but that the RULE that you are ASSUMING to work isn't valid.
>>>>>
>>>>
>>>> The rule that I use in this case is sufficient to correctly decide this
>>>> case. A thousand years of additional development work may not be
>>>> sufficiently elaborated to correctly decide all cases.
>>>
>>> Not, because it is incorrect for this case!! Do you have ANY proof to
>>> show that it IS correct, or is this just you taking it on Gut Feeling.
>>>
>>> It can be shown to be incorrect, by looking at what H_Hat does after it
>>> gets the answer (and if it doesn't, then Halts has already failed to
>>> meet the requirements).
>>>
>>>
>>>>> The ONLY justification you have for calling the execution of H_Hat
>>>>> non-halting is the application of a rule, that has been shown that when
>>>>> you use the definitions you are using, gives false positives.
>>>>>
>>>>
>>>> The same function called with the same data from the same machine
>>>> address a second time is necessarily guaranteed to have the same
>>>> execution trace.
>>>>
>>>
>>> Yes, but the Halt Decider has the requirement to interrupt the cycle to
>>> give an answer. Maybe you can argue that this is the reason you return
>>> non-halting, but when you do you find out that you were wrong.
>>
>> When we use this as the halt deciding criteria then it can no longer be
>> proven that all inputs cannot be divided into those having the property
>> of infinite execution and those that do not:
>>
>> 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.
>>
>> On Saturday, November 28, 2020 at 2:00:28 PM UTC-8, olcott wrote:
>>> Every computation that would not halt if its simulation
>>> were not halted is by logical necessity a non-halting computation.
>>
>> You must be much dumber than a box of rocks because I have had to repeat
>> that fifty times.
>>
>>>>> What PROOF do you have that the results you are getting for H_Hat isn't
>>>>> another false positive.
>>>>>
>>>>
>>>> A human can examine the execution trace of all of the user code and see
>>>> that there is nothing that can possibly break the cycle of infinite
>>>> recursion.
>>>
>>>
>>> Except that Halts MUST break it or it fails to meet its requirement.!!!
>>> (and it is easy to see that it can)
>>>
>>
>> The only real requirement is that it can no longer be proved that all
>> inputs cannot be divided into those with the property of infinite
>> execution and those not having this property.
>>
>> All the other "requirements" are bullshit double talk dishonesty.
>>
>>> Yes, if H_Hat just invoked a UTM on H_Hat, it is clear that the
>>> execution is infinite, but Halts is NOT 'just' a UTM, it is a Halt
>>> Decider, so it is REQUIRED to figure out how to answer the question.
>>>
>>> Your fundamental issue is you presume that the Halt Decider can be just
>>> a simple UTM that figures out if it sees infinite execution. Self
>>> Referential Turing Machines, like Linx H^ show that such a design is
>>> insufficient. There are also a class of similar self referential
>>> machines that it is possible with a slightly smarter decider to figure
>>> out.
>>
>> I have shown how the simplest encoding of the conventional halting
>> problem counter-examples can be correctly decided.
>>
>> All the other "requirements" are bullshit double talk dishonesty.
>
> To talk about having a meaning for Linz et all, you need to use the same
> definition of the problem at they do.
>>
>>> It is NOT H_Hats 'fault' that we hit a recursion that your Halts doesn't
>>> know how to handle, Halt NEEDS to be designed to figure out how to
>>> handle the self-referential machines, as they ARE allowed by the problem
>>> definition and the basic rules for Turing Machines
>>>
>>>>
>>>> The code could do this too. It only has to also verify that the inputs
>>>> are identical. A human can already see this.
>>>>
>>>
>>> And a human can easily see that if Halts meets its requirement to make
>>> the decision, then it will interrupt the infinite cycle that IT created
>>> and return an answer, which will be wrong.
>>>
>>
>> You can baselessly claim that it is wrong only in terms of
>> bullshit double talk dishonesty.
>>
>> What you cannot do is show that it did not decide its input based on
>> this necessarily correct halt deciding criteria:
>>
>> 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.
>>
>> On Saturday, November 28, 2020 at 2:00:28 PM UTC-8, olcott wrote:
>>> Every computation that would not halt if its simulation
>>> were not halted is by logical necessity a non-halting computation.
>>
>>
>
> The ONE and ONLY criteria for Halting Decisions is does the machine Halt.
>
People were fooled into believing that since 1936.
A universal halt decider merely needs to divide all inputs input those
having the property of infinite execution and those not having this
property.
With my system that involves inputs that halt on their own and inputs
that have been forced to halt by the halt decider.
> A simple inspection of H_Hat shows that if Halts returns non-Halting,
> then H_Hat will Halt.
>
> The only other possibility is that Halts does not return an answer, in
> which case it also Fails.
>
Yes of course we know that every function invoked in infinite recursion
always returns a value to its caller and all infinite loops only loop
ten times. (nitwit).
> When you get your simulation to work right, you will see that to be
> true. Eight Halts never returns its answer, so it fails to meet its
> requirements or it returns and H_Hat stop properly.
>
> Only by having your global decider (which isn't allowed by the formation
> of Linz) stop in the middle of the run can you use your incorrect
> critera (which you have even admitted it not a true axiom) to try to
> claim your wrong answer.
>
> If you want to use a different criteria, STOP CALLING IT THE HALTING
> PROBLEM, as it isn't.
>
--
Copyright 2020 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 | 2020-12-29 03:15 +0000 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (HP criteria) |
| Message-ID | <20201228120105.382@kylheku.com> |
| In reply to | #2408 |
["Followup-To:" header set to comp.theory.]
On 2020-12-28, olcott <NoOne@NoWhere.com> wrote:
> On 12/26/2020 10:50 PM, Kaz Kylheku wrote:
>> On 2020-12-27, olcott <NoOne@NoWhere.com> wrote:
>>> On 12/26/2020 6:48 PM, Kaz Kylheku wrote:
>>>>> int main()
>>>>> {
>>>>> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>>>>> Output("Input_Would_Halt =", Input_Would_Halt);
>>>>> HALT;
>>>>> }
>>>>
>>>> If the output is "Input_Would_Halt = 0", it says that H_Hat(H_Hat)
>>>> doesn't halt.
>>>>
>>>
>>> It is answering a slightly different question.
>>
>> If he goal is to use that implementation of Halts to refute a proof,
>> then it has to correctly answer the above question.
>>
>
> Not really, Not at all.
Yes really. Moreover, until a few days ago, you wrongly believed that
your program was answering the right above correctly.
You had so much faith in your contraption that you neglected to
add the one-liner to actually test whether its result is true.
Now, having been confronted with the truth, you've reverted to
sputtering in your auto-pilot ranting mode.
> Not in the least little bit.
> The entire proof can be utterly ignored as long as the conclusion of the
> proof is refuted the proof is refuted.
That's not how logic works, you have to show that the conclusion is
reached by some wrong step of inference (the proof is invalid) or that
the conclusion is reached from premises that do not have true
interpretations in the relevant domain of discourse (the
argument is not sound).
Your program is simply wrong. Its Halts function decides that that
H_Hat(H_Hat) doesn't halt, yet if you actually make that call in place
of calling the decider, it screws up.
The proof says that this happens; your program is a testament to its
validity.
> As long as a halt decider divides all inputs into:
> (1) Halts without being forced to halt.
> (2) Does not halt without being forced to halt.
> The halting problem has been solved.
That's not the universal halting problem; it's a strawman version.
Point (2) doesn't even make rational sense; did you read it over before
posting?
You're trying to impose rules that prevent a decider program from being
given itself as input.
Any such rules mean you don't have universality.
It is known that halting is decidable non-universally; that is not a new
result you can attach your name to.
There is no good reason not to allow a decider program to be given
a test case based on itself as input.
There is no paradox in a program operating on itself. In fact, it is
useful to do so. Examples:
- Compilers compile themselves.
- File copying programs copy themselves.
- Version control systems are used for tracking their own sources.
--
TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-29 10:45 -0600 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (pathological self-reference) |
| Message-ID | <MamdnVynoJKMwHbCnZ2dnUU7-RHNnZ2d@giganews.com> |
| In reply to | #2413 |
On 12/28/2020 9:15 PM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2020-12-28, olcott <NoOne@NoWhere.com> wrote:
>> On 12/26/2020 10:50 PM, Kaz Kylheku wrote:
>>> On 2020-12-27, olcott <NoOne@NoWhere.com> wrote:
>>>> On 12/26/2020 6:48 PM, Kaz Kylheku wrote:
>>>>>> int main()
>>>>>> {
>>>>>> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>>>>>> Output("Input_Would_Halt =", Input_Would_Halt);
>>>>>> HALT;
>>>>>> }
>>>>>
>>>>> If the output is "Input_Would_Halt = 0", it says that H_Hat(H_Hat)
>>>>> doesn't halt.
>>>>>
>>>>
>>>> It is answering a slightly different question.
>>>
>>> If he goal is to use that implementation of Halts to refute a proof,
>>> then it has to correctly answer the above question.
>>>
>>
>> Not really, Not at all.
>
> Yes really. Moreover, until a few days ago, you wrongly believed that
> your program was answering the right above correctly.
>
> You had so much faith in your contraption that you neglected to
> add the one-liner to actually test whether its result is true.
>
> Now, having been confronted with the truth, you've reverted to
> sputtering in your auto-pilot ranting mode.
>
>> Not in the least little bit.
>> The entire proof can be utterly ignored as long as the conclusion of the
>> proof is refuted the proof is refuted.
>
> That's not how logic works, you have to show that the conclusion is
> reached by some wrong step of inference (the proof is invalid) or that
> the conclusion is reached from premises that do not have true
> interpretations in the relevant domain of discourse (the
> argument is not sound).
>
> Your program is simply wrong. Its Halts function decides that that
> H_Hat(H_Hat) doesn't halt, yet if you actually make that call in place
> of calling the decider, it screws up.
>
> The proof says that this happens; your program is a testament to its
> validity.
>
>> As long as a halt decider divides all inputs into:
>> (1) Halts without being forced to halt.
>> (2) Does not halt without being forced to halt.
>> The halting problem has been solved.
>
> That's not the universal halting problem; it's a strawman version.
>
> Point (2) doesn't even make rational sense; did you read it over before
> posting?
>
> You're trying to impose rules that prevent a decider program from being
> given itself as input.
>
> Any such rules mean you don't have universality.
>
> It is known that halting is decidable non-universally; that is not a new
> result you can attach your name to.
>
> There is no good reason not to allow a decider program to be given
> a test case based on itself as input.
>
> There is no paradox in a program operating on itself. In fact, it is
> useful to do so. Examples:
>
> - Compilers compile themselves.
>
> - File copying programs copy themselves.
>
> - Version control systems are used for tracking their own sources.
>
The original halting problem undecidability proof basis is a mere trick
with no practical consequence.
It is just like this trick that "proves" that it is impossible for
people to always correctly answer simple (yes or no) questions:
"Will your answer to this question be no?"
(Both yes and no are the wrong answer).
Since we can divide inputs into those having the property of infinite
execution and those not having this property then the halting problem
undecidability proofs have been refuted.
The test for the presence of this property must be specified without the
pathological self-reference of the original test:
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.
On Saturday, November 28, 2020 at 2:00:28 PM UTC-8, olcott wrote:
> Every computation that would not halt if its simulation
> were not halted is by logical necessity a non-halting computation.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Jeff Barnett <jbb@notatt.com> |
|---|---|
| Date | 2020-12-26 17:35 -0700 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs (numbskull mistake) |
| Message-ID | <rs8ks1$7fn$1@dont-email.me> |
| In reply to | #2396 |
On 12/26/2020 2:35 PM, olcott wrote:
> On 12/25/2020 12:19 PM, Jeff Barnett wrote:
>> On 12/24/2020 3:40 PM, Richard Damon wrote:
>>> On 12/23/20 10:17 PM, olcott wrote:
>>>> On 12/23/2020 8:01 PM, Kaz Kylheku wrote:
>>>>> On 2020-12-24, olcott <NoOne@NoWhere.com> wrote:
>>>>>> The halting theorem says that a universal halt decider is utterly
>>>>>> uncomputable.
>>>>>
>>>>> It says no such thing; it says that an algorithm doesn't exist for
>>>>> deciding whether any TM will halt or not.
>>>>>
>>>>>> If the halt decider consistently gets the correct answer by
>>>>>> simulating a
>>>>>> https://en.wikipedia.org/wiki/Ouija board, then this answer counts.
>>>>>
>>>>> No, because the theorem says there is no *algorithm* (== Turing
>>>>> process)
>>>>> which decides the halting of all TMs.
>>>>>
>>>>
>>>> Right so when my C program does, as we know from the Church-Turing
>>>> thesis C programs are much more powerful than Turing machines, so this
>>>> doesn't count.
>>>>
>>> Really, you read Church-Turing that way?
>>>
>>> From what I read, the thesis says (in part) that all Random Access
>>> Machines (and thus all C programs) could be simulated by a Turing
>>> Machine with at most a polynomial time (and constant space) penalty.
>>>
>>> Yes, perhaps you can say that C programs are 'more powerful' in that
>>> they are faster, but they can compute no more calculations than a Turing
>>> Machine.
>>
>> First there is no concept of time in a TM computation: you simply have
>> a very abstract state transition function that either ends in one of
>> the halting states or it does not. Talking about time for a TM is like
>> talking about time for convergence of a Taylor series: the series at a
>> point either converges to a value or it does not. Some series converge
>> faster if you use them for computation then others but that doesn't
>> factor in the time (your time) to evaluate a term and that can be
>> radically different. Best to not try to compare a TM abstraction to a
>> real machine.
>>
>> As to relative power. Let's review some facts about TM power. Let's
>> let the TM abstraction be nondeterministic. I'm almost sure that Linz
>> covers this concept where in a state with a particular symbol under
>> the read head, you may transition to zero or more states; the
>> computation is "halting" if any path reaches a halting state. Then
>> there are random TM formalisms where a TM behavior is select from many
>> possibilities using a distribution function and halting is defined in
>> the usual way - so whether the machine reaches a halting state and the
>> tape contents are probabilistic concepts. None of these reformulations
>> make the class of TM computations any larger, i.e., if one of the
>> reformulations can achieve a result so can some regular ordinary old
>> TM do it too.
>>
>> In other words any thing a hunk of time can can calculated can be done
>> by a TM. In particular, there is absolutely nothing in the X86
>> behavior that is not TM computable. Even with unlimited memory,
>> randomizing interrupts, halting instructions, SVC's or whatever they
>> are called now a days, etc, etc, etc. If you want more power, I
>> suggest an oracle.
>>
>> There is nothing novel here in computer theory. These ludicrous
>> attempts to defeat basic reasoning are just that: ludicrous. The
>> concept that PO is the little drummer boy marching with strange
>> gesticulations and appearing an uncoordinated fool whose reputation is
>> redeemed when we see he is marching with the band of heaven that only
>> he could see and hear is also ludicrous. He is might be a decades
>> long, award winning troll marching all of us through these never
>> ending threads of nonsense. Most likely is just a little drummer boy
>> who is uncoordinated and lost. And it is we who have read too many
>> Christmas stories.
>
>
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> else
> HALT
> }
>
> The proofs are correct in that there exists no correct value that
> Halts() can return to H_Hat().
>
> The proofs are incorrect in their assumption that a value must be
> returned to H_Hat().
>
> The essence of my refution is as simple as that.
The only thing that refutes is the premise that you are rationale. Refer
to at least a 1000 other messages this month for specific reasons why.
Also note that my post was for Richard, not you. But it is, of course,
okay to put your oar in the wrong place. As usual.
--
Jeff Barnett
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-26 21:20 -0600 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ double sqrt(X) ] |
| Message-ID | <R8SdnVf7SdX5YHrCnZ2dnUU7-dXNnZ2d@giganews.com> |
| In reply to | #2382 |
On 12/26/2020 8:06 PM, Richard Damon wrote:
> On 12/26/20 8:50 PM, olcott wrote:
>> On 12/26/2020 6:40 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 12/24/2020 6:20 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 12/23/2020 8:53 PM, Ben Bacarisse wrote:
>>>>> <cut>
>>>>>>> That specification requires that the function must always return a
>>>>>>> value
>>>>>>> (in the usual sense of the word for the programming language being
>>>>>>> used)
>>>>>>> and that that value accurately reflect whether the computation
>>>>>>> represented by the function call arguments is or is not a finite one.
>>>>>>> Not returning a value, in any situation or context, is not
>>>>>>> permissible.
>>>>>>> Every call must return, and it must return the correct true/false
>>>>>>> value.
>>>>>>
>>>>>> There is one invocation of Halts() in main() that is not infintely
>>>>>> recursive and does return a value to its caller.
>>>>>>
>>>>>> There is also an infinitely recursive invocation of Halts() from
>>>>>> H_Hat().
>>>>>
>>>>> Which is why Halts does not meet the specification for the function I
>>>>> asked for.
>>>>
>>>> To prove that your requirement is not simply jackass stupid please
>>>> provide one example of a function that return a result to it caller
>>>> when its caller invoked this function in infinte recursion.
>>>
>>> At least you now agree that your function does not meet the
>>> specification. Why did you post it? Did you not know it was a fail
>>> right from the start?
>>>
>>> The requirement that some function always return a value is a common
>>> one, but you can call it "jackass stupid" if you like. Your name for it
>>> is neither here nor there.
>>>
>>
>> Then the standard C function: double sqrt(X) is <not>
>> a function because it can be called in infinite recursion, thus
>> preventing it from ever returning any value to its caller.
>>
>> double Infinite_Recursion(double X)
>> {
>> Infinite_Recursion( sqrt(X) );
>> }
>>
>> int main(int argc, char *argv[])
>> {
>> double X = Infinite_Recursion(1.0);
>> printf("%8.4f", X);
>> }
>>
>>
>
> And each version of sqrt(x) that is called in that recursion will return
> to ITS caller the value of the square root of its parameter. Step
> through the code in your debugger to verify.
>
> Yes, Infinite_Recursion won't return, and if it has as a requirement
> that it must return a value it would fail to meet that requirement, and
> a requirement to recurse infinitely AND return a value would be a
> conflict in requirements.
>
> Note that Halts is different. Halts is NOT required to recurse
> infinitely. It isn't even required to execute the machine it is asked to
> decide on. It IS required to return an answer in finite time. When it
> detects the recursion it has some choices:
>
> 1) It can just recurse and let that go for ever and fail to meet the
> requirements to return a value.
>
> 2) It can stop the recursion and try to figure an answer some way
> besides just emulating the code to get an answer (you seem to have
> decided to just label it as non-halting), in which case since you do NOT
> now have infinite recursion (because you stopped it) you can now return
> the answer.
>
u32 sqrtX(u32 X)
{
return 1.0;
}
u32 Infinite_Recursion(u32 X)
{
Infinite_Recursion( sqrtX(X) );
}
_sqrtX()
[000008ee](01) 55 push ebp
[000008ef](02) 8bec mov ebp,esp
[000008f1](05) b801000000 mov eax,00000001
[000008f6](01) 5d pop ebp
[000008f7](01) c3 ret
_Infinite_Recursion()
[000008fe](01) 55 push ebp
[000008ff](02) 8bec mov ebp,esp
[00000901](03) 8b4508 mov eax,[ebp+08]
[00000904](01) 50 push eax
[00000905](05) e8e4ffffff call 000008ee
[0000090a](03) 83c404 add esp,+04
[0000090d](01) 50 push eax
[0000090e](05) e8ebffffff call 000008fe
[00000913](03) 83c404 add esp,+04
[00000916](01) 5d pop ebp
[00000917](01) c3 ret
It can't accurately be said that _sqrtX() returns a value to its caller,
_sqrtX() merely calls the next (and not prior) _Infinite_Recursion()
with a value. This value never actually gets back to the caller.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-28 13:00 -0600 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ double sqrt(X) ] |
| Message-ID | <xbmdnX7J5ZvFtnfCnZ2dnUU7-TfNnZ2d@giganews.com> |
| In reply to | #2403 |
On 12/27/2020 8:08 AM, Richard Damon wrote:
> On 12/26/20 10:20 PM, olcott wrote:
>> On 12/26/2020 8:06 PM, Richard Damon wrote:
>>> On 12/26/20 8:50 PM, olcott wrote:
>>>> On 12/26/2020 6:40 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 12/24/2020 6:20 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 12/23/2020 8:53 PM, Ben Bacarisse wrote:
>>>>>>> <cut>
>>>>>>>>> That specification requires that the function must always return a
>>>>>>>>> value
>>>>>>>>> (in the usual sense of the word for the programming language being
>>>>>>>>> used)
>>>>>>>>> and that that value accurately reflect whether the computation
>>>>>>>>> represented by the function call arguments is or is not a finite
>>>>>>>>> one.
>>>>>>>>> Not returning a value, in any situation or context, is not
>>>>>>>>> permissible.
>>>>>>>>> Every call must return, and it must return the correct true/false
>>>>>>>>> value.
>>>>>>>>
>>>>>>>> There is one invocation of Halts() in main() that is not infintely
>>>>>>>> recursive and does return a value to its caller.
>>>>>>>>
>>>>>>>> There is also an infinitely recursive invocation of Halts() from
>>>>>>>> H_Hat().
>>>>>>>
>>>>>>> Which is why Halts does not meet the specification for the function I
>>>>>>> asked for.
>>>>>>
>>>>>> To prove that your requirement is not simply jackass stupid please
>>>>>> provide one example of a function that return a result to it caller
>>>>>> when its caller invoked this function in infinte recursion.
>>>>>
>>>>> At least you now agree that your function does not meet the
>>>>> specification. Why did you post it? Did you not know it was a fail
>>>>> right from the start?
>>>>>
>>>>> The requirement that some function always return a value is a common
>>>>> one, but you can call it "jackass stupid" if you like. Your name
>>>>> for it
>>>>> is neither here nor there.
>>>>>
>>>>
>>>> Then the standard C function: double sqrt(X) is <not>
>>>> a function because it can be called in infinite recursion, thus
>>>> preventing it from ever returning any value to its caller.
>>>>
>>>> double Infinite_Recursion(double X)
>>>> {
>>>> Infinite_Recursion( sqrt(X) );
>>>> }
>>>>
>>>> int main(int argc, char *argv[])
>>>> {
>>>> double X = Infinite_Recursion(1.0);
>>>> printf("%8.4f", X);
>>>> }
>>>>
>>>>
>>>
>>> And each version of sqrt(x) that is called in that recursion will return
>>> to ITS caller the value of the square root of its parameter. Step
>>> through the code in your debugger to verify.
>>>
>>> Yes, Infinite_Recursion won't return, and if it has as a requirement
>>> that it must return a value it would fail to meet that requirement, and
>>> a requirement to recurse infinitely AND return a value would be a
>>> conflict in requirements.
>>>
>>> Note that Halts is different. Halts is NOT required to recurse
>>> infinitely. It isn't even required to execute the machine it is asked to
>>> decide on. It IS required to return an answer in finite time. When it
>>> detects the recursion it has some choices:
>>>
>>> 1) It can just recurse and let that go for ever and fail to meet the
>>> requirements to return a value.
>>>
>>> 2) It can stop the recursion and try to figure an answer some way
>>> besides just emulating the code to get an answer (you seem to have
>>> decided to just label it as non-halting), in which case since you do NOT
>>> now have infinite recursion (because you stopped it) you can now return
>>> the answer.
>>>
>>
>> u32 sqrtX(u32 X)
>> {
>> return 1.0;
>> }
>>
>>
>> u32 Infinite_Recursion(u32 X)
>> {
>> Infinite_Recursion( sqrtX(X) );
>> }
>>
>> _sqrtX()
>> [000008ee](01) 55 push ebp
>> [000008ef](02) 8bec mov ebp,esp
>> [000008f1](05) b801000000 mov eax,00000001
>> [000008f6](01) 5d pop ebp
>> [000008f7](01) c3 ret
>>
>> _Infinite_Recursion()
>> [000008fe](01) 55 push ebp
>> [000008ff](02) 8bec mov ebp,esp
>> [00000901](03) 8b4508 mov eax,[ebp+08]
>> [00000904](01) 50 push eax
>> [00000905](05) e8e4ffffff call 000008ee
>> [0000090a](03) 83c404 add esp,+04
>> [0000090d](01) 50 push eax
>> [0000090e](05) e8ebffffff call 000008fe
>> [00000913](03) 83c404 add esp,+04
>> [00000916](01) 5d pop ebp
>> [00000917](01) c3 ret
>>
>> It can't accurately be said that _sqrtX() returns a value to its caller,
>> _sqrtX() merely calls the next (and not prior) _Infinite_Recursion()
>> with a value. This value never actually gets back to the caller.
>>
>>
>
> Lets look at a trace of the run.
>
> Main calls Infintite_Recursion(1)
> Infinite_Recursion(1) calls sqrt(1)
> Sqrt(1) computes the sqrt and RETURNS that value
> Infinite_Recursion then calls Infinite_Recursion() with the result
> That nested recursion calls Sqrt, which return a value
> Infinite_Recursion then call Infinite_Recursion ...
>
>
> So the execution goes from 8FE (the start of Infinite_Recursion) to 905
> where it calls sqrtX at 8EE and runs to 8F7 where sqrtX RETURNS to the
> caller to 90A where Infinite_Recursion continues to the call of
> Infinite_Recursion at 90E where it makes the call to Infinite_Recursion
> at 8FE, and the cycle continues.
>
> EVERY call to sqrtX has been quickly returned from, even though it is
> called from a function with infinite recursion.
>
> No where does sqrtX actually call any version of Infinite_Recursion, it
> is called by one level of recursion of Infinite_Recursion and returns
> back to that exact same level of recursion.
>
> Where do you see sqrtX actually going directly to the next level of
> Infinite_Recursion, as you single steping through the code in C
> statement mode and not assembly mode?
>
I rewrote it to be perfectly analogous with my code. The simulation of a
function by a simulator is computationally equivalent to executing this
function. Recursive simulations of a function by a simulator is
computationally equivalent to recursive invocations of this function.
Many of the functions of the standard C library can be invoked such that
they fail to return any result to their caller:
None of these functions return a result to their caller.
double H_Hat(double P)
{
double Input_Halts = sqrt(H_Hat(P));
}
void H_Hat(u32 P)
{
u32 Input_Halts = Simulate(P, P); // Where P = (u32)H_Hat
}
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P); // Where P = (u32)H_Hat
} // and Halts is based on Simulate
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-28 13:35 -0600 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ double sqrt(X) ] |
| Message-ID | <i8idnYoJvqEOrnfCnZ2dnUU7-K_NnZ2d@giganews.com> |
| In reply to | #2407 |
On 12/28/2020 1:20 PM, Richard Damon wrote:
> On 12/28/20 2:00 PM, olcott wrote:
>> On 12/27/2020 8:08 AM, Richard Damon wrote:
>>> On 12/26/20 10:20 PM, olcott wrote:
>>>> On 12/26/2020 8:06 PM, Richard Damon wrote:
>>>>> On 12/26/20 8:50 PM, olcott wrote:
>>>>>> On 12/26/2020 6:40 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 12/24/2020 6:20 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 12/23/2020 8:53 PM, Ben Bacarisse wrote:
>>>>>>>>> <cut>
>>>>>>>>>>> That specification requires that the function must always
>>>>>>>>>>> return a
>>>>>>>>>>> value
>>>>>>>>>>> (in the usual sense of the word for the programming language
>>>>>>>>>>> being
>>>>>>>>>>> used)
>>>>>>>>>>> and that that value accurately reflect whether the computation
>>>>>>>>>>> represented by the function call arguments is or is not a finite
>>>>>>>>>>> one.
>>>>>>>>>>> Not returning a value, in any situation or context, is not
>>>>>>>>>>> permissible.
>>>>>>>>>>> Every call must return, and it must return the correct true/false
>>>>>>>>>>> value.
>>>>>>>>>>
>>>>>>>>>> There is one invocation of Halts() in main() that is not infintely
>>>>>>>>>> recursive and does return a value to its caller.
>>>>>>>>>>
>>>>>>>>>> There is also an infinitely recursive invocation of Halts() from
>>>>>>>>>> H_Hat().
>>>>>>>>>
>>>>>>>>> Which is why Halts does not meet the specification for the
>>>>>>>>> function I
>>>>>>>>> asked for.
>>>>>>>>
>>>>>>>> To prove that your requirement is not simply jackass stupid please
>>>>>>>> provide one example of a function that return a result to it caller
>>>>>>>> when its caller invoked this function in infinte recursion.
>>>>>>>
>>>>>>> At least you now agree that your function does not meet the
>>>>>>> specification. Why did you post it? Did you not know it was a fail
>>>>>>> right from the start?
>>>>>>>
>>>>>>> The requirement that some function always return a value is a common
>>>>>>> one, but you can call it "jackass stupid" if you like. Your name
>>>>>>> for it
>>>>>>> is neither here nor there.
>>>>>>>
>>>>>>
>>>>>> Then the standard C function: double sqrt(X) is <not>
>>>>>> a function because it can be called in infinite recursion, thus
>>>>>> preventing it from ever returning any value to its caller.
>>>>>>
>>>>>> double Infinite_Recursion(double X)
>>>>>> {
>>>>>> Infinite_Recursion( sqrt(X) );
>>>>>> }
>>>>>>
>>>>>> int main(int argc, char *argv[])
>>>>>> {
>>>>>> double X = Infinite_Recursion(1.0);
>>>>>> printf("%8.4f", X);
>>>>>> }
>>>>>>
>>>>>>
>>>>>
>>>>> And each version of sqrt(x) that is called in that recursion will
>>>>> return
>>>>> to ITS caller the value of the square root of its parameter. Step
>>>>> through the code in your debugger to verify.
>>>>>
>>>>> Yes, Infinite_Recursion won't return, and if it has as a requirement
>>>>> that it must return a value it would fail to meet that requirement, and
>>>>> a requirement to recurse infinitely AND return a value would be a
>>>>> conflict in requirements.
>>>>>
>>>>> Note that Halts is different. Halts is NOT required to recurse
>>>>> infinitely. It isn't even required to execute the machine it is
>>>>> asked to
>>>>> decide on. It IS required to return an answer in finite time. When it
>>>>> detects the recursion it has some choices:
>>>>>
>>>>> 1) It can just recurse and let that go for ever and fail to meet the
>>>>> requirements to return a value.
>>>>>
>>>>> 2) It can stop the recursion and try to figure an answer some way
>>>>> besides just emulating the code to get an answer (you seem to have
>>>>> decided to just label it as non-halting), in which case since you do
>>>>> NOT
>>>>> now have infinite recursion (because you stopped it) you can now return
>>>>> the answer.
>>>>>
>>>>
>>>> u32 sqrtX(u32 X)
>>>> {
>>>> return 1.0;
>>>> }
>>>>
>>>>
>>>> u32 Infinite_Recursion(u32 X)
>>>> {
>>>> Infinite_Recursion( sqrtX(X) );
>>>> }
>>>>
>>>> _sqrtX()
>>>> [000008ee](01) 55 push ebp
>>>> [000008ef](02) 8bec mov ebp,esp
>>>> [000008f1](05) b801000000 mov eax,00000001
>>>> [000008f6](01) 5d pop ebp
>>>> [000008f7](01) c3 ret
>>>>
>>>> _Infinite_Recursion()
>>>> [000008fe](01) 55 push ebp
>>>> [000008ff](02) 8bec mov ebp,esp
>>>> [00000901](03) 8b4508 mov eax,[ebp+08]
>>>> [00000904](01) 50 push eax
>>>> [00000905](05) e8e4ffffff call 000008ee
>>>> [0000090a](03) 83c404 add esp,+04
>>>> [0000090d](01) 50 push eax
>>>> [0000090e](05) e8ebffffff call 000008fe
>>>> [00000913](03) 83c404 add esp,+04
>>>> [00000916](01) 5d pop ebp
>>>> [00000917](01) c3 ret
>>>>
>>>> It can't accurately be said that _sqrtX() returns a value to its caller,
>>>> _sqrtX() merely calls the next (and not prior) _Infinite_Recursion()
>>>> with a value. This value never actually gets back to the caller.
>>>>
>>>>
>>>
>>> Lets look at a trace of the run.
>>>
>>> Main calls Infintite_Recursion(1)
>>> Infinite_Recursion(1) calls sqrt(1)
>>> Sqrt(1) computes the sqrt and RETURNS that value
>>> Infinite_Recursion then calls Infinite_Recursion() with the result
>>> That nested recursion calls Sqrt, which return a value
>>> Infinite_Recursion then call Infinite_Recursion ...
>>>
>>>
>>> So the execution goes from 8FE (the start of Infinite_Recursion) to 905
>>> where it calls sqrtX at 8EE and runs to 8F7 where sqrtX RETURNS to the
>>> caller to 90A where Infinite_Recursion continues to the call of
>>> Infinite_Recursion at 90E where it makes the call to Infinite_Recursion
>>> at 8FE, and the cycle continues.
>>>
>>> EVERY call to sqrtX has been quickly returned from, even though it is
>>> called from a function with infinite recursion.
>>>
>>> No where does sqrtX actually call any version of Infinite_Recursion, it
>>> is called by one level of recursion of Infinite_Recursion and returns
>>> back to that exact same level of recursion.
>>>
>>> Where do you see sqrtX actually going directly to the next level of
>>> Infinite_Recursion, as you single steping through the code in C
>>> statement mode and not assembly mode?
>>>
>>
>> I rewrote it to be perfectly analogous with my code. The simulation of a
>> function by a simulator is computationally equivalent to executing this
>> function. Recursive simulations of a function by a simulator is
>> computationally equivalent to recursive invocations of this function.
>>
>> Many of the functions of the standard C library can be invoked such that
>> they fail to return any result to their caller:
>>
>> None of these functions return a result to their caller.
>>
>> double H_Hat(double P)
>> {
>> double Input_Halts = sqrt(H_Hat(P));
>> }
>>
>
> In this case, the SQRT function will never get called, so yes, you can
> say an uncalled function will never return to its caller. Doesn't do
> much to prove your point. Note also, you have changed the function from
> your first example.
>
>> void H_Hat(u32 P)
>> {
>> u32 Input_Halts = Simulate(P, P); // Where P = (u32)H_Hat
>> }
>>
>
> Yes, it is expected to not return due to infinite recursion with nothing
> to stop the recursion
>
It <is> still a function though because it does return 1 when its input
halts.
>> void H_Hat(u32 P)
>> {
>> u32 Input_Halts = Halts(P, P); // Where P = (u32)H_Hat
>> } // and Halts is based on Simulate
>>
>
> And here is the difference. If we assume that Halts is supposed to be a
> Halting Decider, then yes, it is possible that Halts might not return if
> it get trapped in infinite recursion, but then halts can be shown to
> fail to be a Halting Decider (as a Halting Decider needs to return its
> answer in finite time).
>
> If Halts is a WORKING halting decider, then it will detect the problem
> of infinite recursion, and do something to let it return its answer in
> the finite time.
>
int main()
{
u32 Input_Halts = ((u32)H_Hat, (u32)H_Hat);
Output("Input_Halts =", Input_Halts);
}
Output:Input_Halts = 0
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-28 17:59 -0600 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ double sqrt(X) ] |
| Message-ID | <7fKdnZ-lovLj7HfCnZ2dnUU7-XfNnZ2d@giganews.com> |
| In reply to | #2409 |
On 12/28/2020 2:11 PM, Richard Damon wrote:
> On 12/28/20 2:35 PM, olcott wrote:
>> On 12/28/2020 1:20 PM, Richard Damon wrote:
>>> On 12/28/20 2:00 PM, olcott wrote:
>>>> On 12/27/2020 8:08 AM, Richard Damon wrote:
>>>>> On 12/26/20 10:20 PM, olcott wrote:
>>>>>> On 12/26/2020 8:06 PM, Richard Damon wrote:
>>>>>>> On 12/26/20 8:50 PM, olcott wrote:
>>>>>>>> On 12/26/2020 6:40 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 12/24/2020 6:20 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 12/23/2020 8:53 PM, Ben Bacarisse wrote:
>>>>>>>>>>> <cut>
>>>>>>>>>>>>> That specification requires that the function must always
>>>>>>>>>>>>> return a
>>>>>>>>>>>>> value
>>>>>>>>>>>>> (in the usual sense of the word for the programming language
>>>>>>>>>>>>> being
>>>>>>>>>>>>> used)
>>>>>>>>>>>>> and that that value accurately reflect whether the computation
>>>>>>>>>>>>> represented by the function call arguments is or is not a
>>>>>>>>>>>>> finite
>>>>>>>>>>>>> one.
>>>>>>>>>>>>> Not returning a value, in any situation or context, is not
>>>>>>>>>>>>> permissible.
>>>>>>>>>>>>> Every call must return, and it must return the correct
>>>>>>>>>>>>> true/false
>>>>>>>>>>>>> value.
>>>>>>>>>>>>
>>>>>>>>>>>> There is one invocation of Halts() in main() that is not
>>>>>>>>>>>> infintely
>>>>>>>>>>>> recursive and does return a value to its caller.
>>>>>>>>>>>>
>>>>>>>>>>>> There is also an infinitely recursive invocation of Halts() from
>>>>>>>>>>>> H_Hat().
>>>>>>>>>>>
>>>>>>>>>>> Which is why Halts does not meet the specification for the
>>>>>>>>>>> function I
>>>>>>>>>>> asked for.
>>>>>>>>>>
>>>>>>>>>> To prove that your requirement is not simply jackass stupid please
>>>>>>>>>> provide one example of a function that return a result to it
>>>>>>>>>> caller
>>>>>>>>>> when its caller invoked this function in infinte recursion.
>>>>>>>>>
>>>>>>>>> At least you now agree that your function does not meet the
>>>>>>>>> specification. Why did you post it? Did you not know it was a
>>>>>>>>> fail
>>>>>>>>> right from the start?
>>>>>>>>>
>>>>>>>>> The requirement that some function always return a value is a
>>>>>>>>> common
>>>>>>>>> one, but you can call it "jackass stupid" if you like. Your name
>>>>>>>>> for it
>>>>>>>>> is neither here nor there.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Then the standard C function: double sqrt(X) is <not>
>>>>>>>> a function because it can be called in infinite recursion, thus
>>>>>>>> preventing it from ever returning any value to its caller.
>>>>>>>>
>>>>>>>> double Infinite_Recursion(double X)
>>>>>>>> {
>>>>>>>> Infinite_Recursion( sqrt(X) );
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main(int argc, char *argv[])
>>>>>>>> {
>>>>>>>> double X = Infinite_Recursion(1.0);
>>>>>>>> printf("%8.4f", X);
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> And each version of sqrt(x) that is called in that recursion will
>>>>>>> return
>>>>>>> to ITS caller the value of the square root of its parameter. Step
>>>>>>> through the code in your debugger to verify.
>>>>>>>
>>>>>>> Yes, Infinite_Recursion won't return, and if it has as a requirement
>>>>>>> that it must return a value it would fail to meet that
>>>>>>> requirement, and
>>>>>>> a requirement to recurse infinitely AND return a value would be a
>>>>>>> conflict in requirements.
>>>>>>>
>>>>>>> Note that Halts is different. Halts is NOT required to recurse
>>>>>>> infinitely. It isn't even required to execute the machine it is
>>>>>>> asked to
>>>>>>> decide on. It IS required to return an answer in finite time. When it
>>>>>>> detects the recursion it has some choices:
>>>>>>>
>>>>>>> 1) It can just recurse and let that go for ever and fail to meet the
>>>>>>> requirements to return a value.
>>>>>>>
>>>>>>> 2) It can stop the recursion and try to figure an answer some way
>>>>>>> besides just emulating the code to get an answer (you seem to have
>>>>>>> decided to just label it as non-halting), in which case since you do
>>>>>>> NOT
>>>>>>> now have infinite recursion (because you stopped it) you can now
>>>>>>> return
>>>>>>> the answer.
>>>>>>>
>>>>>>
>>>>>> u32 sqrtX(u32 X)
>>>>>> {
>>>>>> return 1.0;
>>>>>> }
>>>>>>
>>>>>>
>>>>>> u32 Infinite_Recursion(u32 X)
>>>>>> {
>>>>>> Infinite_Recursion( sqrtX(X) );
>>>>>> }
>>>>>>
>>>>>> _sqrtX()
>>>>>> [000008ee](01) 55 push ebp
>>>>>> [000008ef](02) 8bec mov ebp,esp
>>>>>> [000008f1](05) b801000000 mov eax,00000001
>>>>>> [000008f6](01) 5d pop ebp
>>>>>> [000008f7](01) c3 ret
>>>>>>
>>>>>> _Infinite_Recursion()
>>>>>> [000008fe](01) 55 push ebp
>>>>>> [000008ff](02) 8bec mov ebp,esp
>>>>>> [00000901](03) 8b4508 mov eax,[ebp+08]
>>>>>> [00000904](01) 50 push eax
>>>>>> [00000905](05) e8e4ffffff call 000008ee
>>>>>> [0000090a](03) 83c404 add esp,+04
>>>>>> [0000090d](01) 50 push eax
>>>>>> [0000090e](05) e8ebffffff call 000008fe
>>>>>> [00000913](03) 83c404 add esp,+04
>>>>>> [00000916](01) 5d pop ebp
>>>>>> [00000917](01) c3 ret
>>>>>>
>>>>>> It can't accurately be said that _sqrtX() returns a value to its
>>>>>> caller,
>>>>>> _sqrtX() merely calls the next (and not prior) _Infinite_Recursion()
>>>>>> with a value. This value never actually gets back to the caller.
>>>>>>
>>>>>>
>>>>>
>>>>> Lets look at a trace of the run.
>>>>>
>>>>> Main calls Infintite_Recursion(1)
>>>>> Infinite_Recursion(1) calls sqrt(1)
>>>>> Sqrt(1) computes the sqrt and RETURNS that value
>>>>> Infinite_Recursion then calls Infinite_Recursion() with the
>>>>> result
>>>>> That nested recursion calls Sqrt, which return a value
>>>>> Infinite_Recursion then call Infinite_Recursion ...
>>>>>
>>>>>
>>>>> So the execution goes from 8FE (the start of Infinite_Recursion) to 905
>>>>> where it calls sqrtX at 8EE and runs to 8F7 where sqrtX RETURNS to the
>>>>> caller to 90A where Infinite_Recursion continues to the call of
>>>>> Infinite_Recursion at 90E where it makes the call to Infinite_Recursion
>>>>> at 8FE, and the cycle continues.
>>>>>
>>>>> EVERY call to sqrtX has been quickly returned from, even though it is
>>>>> called from a function with infinite recursion.
>>>>>
>>>>> No where does sqrtX actually call any version of Infinite_Recursion, it
>>>>> is called by one level of recursion of Infinite_Recursion and returns
>>>>> back to that exact same level of recursion.
>>>>>
>>>>> Where do you see sqrtX actually going directly to the next level of
>>>>> Infinite_Recursion, as you single steping through the code in C
>>>>> statement mode and not assembly mode?
>>>>>
>>>>
>>>> I rewrote it to be perfectly analogous with my code. The simulation of a
>>>> function by a simulator is computationally equivalent to executing this
>>>> function. Recursive simulations of a function by a simulator is
>>>> computationally equivalent to recursive invocations of this function.
>>>>
>>>> Many of the functions of the standard C library can be invoked such that
>>>> they fail to return any result to their caller:
>>>>
>>>> None of these functions return a result to their caller.
>>>>
>>>> double H_Hat(double P)
>>>> {
>>>> double Input_Halts = sqrt(H_Hat(P));
>>>> }
>>>>
>>>
>>> In this case, the SQRT function will never get called, so yes, you can
>>> say an uncalled function will never return to its caller. Doesn't do
>>> much to prove your point. Note also, you have changed the function from
>>> your first example.
>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>> u32 Input_Halts = Simulate(P, P); // Where P = (u32)H_Hat
>>>> }
>>>>
>>>
>>> Yes, it is expected to not return due to infinite recursion with nothing
>>> to stop the recursion
>>>
>>
>> It <is> still a function though because it does return 1 when its input
>> halts.
>
> Yes, a 'function' that is asked to do an infinte computation might not
> return. That generally is defined as the input is outside the range of
> definition of the function.
>
> Note, a Universal Halt Decider has no input that is outsides its range
> of definition, or it isn't Universal.
>
>>
>>>> void H_Hat(u32 P)
>>>> {
>>>> u32 Input_Halts = Halts(P, P); // Where P = (u32)H_Hat
>>>> } // and Halts is based on Simulate
>>>>
>>>
>>> And here is the difference. If we assume that Halts is supposed to be a
>>> Halting Decider, then yes, it is possible that Halts might not return if
>>> it get trapped in infinite recursion, but then halts can be shown to
>>> fail to be a Halting Decider (as a Halting Decider needs to return its
>>> answer in finite time).
>>>
>>> If Halts is a WORKING halting decider, then it will detect the problem
>>> of infinite recursion, and do something to let it return its answer in
>>> the finite time.
>>>
>>
>> int main()
>> {
>> u32 Input_Halts = ((u32)H_Hat, (u32)H_Hat);
>> Output("Input_Halts =", Input_Halts);
>> }
>>
>> Output:Input_Halts = 0
>>
>
> Please read your example again. That answer is wrong.
>
> I presume you meant u32 Input_Halts = Halts((u32)H_Hat, (u32)H_Hat);
>
> This does NOT prove that H_Hat(H_Hat) actually doesn't halt.
>
> Please run
>
> int main()
> {
> H_Hat((u32)H_Hat);
> }
>
> with the global halt decider disabled, but the local halt decider working.
>
> Halts MUST return an answer to H_Hat, or it fails to be a decider.
>
> You will see that the answer Halts return will be the wrong
> determination of what H_Hat(H_Hat) actually does.
>
> This is clear as per the definition of H_Hat, when Halts returns the 0
> value, then H_Hat will immediately halt.
>
No amount of human intuition can possibly overcome this verifiable fact:
The execution trace of Halts() under local, global, and disabled
conditions proves that it does make the correct decision at its
decision point.
--
Copyright 2020 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 | 2020-12-29 03:35 +0000 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ double sqrt(X) ] |
| Message-ID | <20201228193137.5@kylheku.com> |
| In reply to | #2411 |
On 2020-12-28, olcott <NoOne@NoWhere.com> wrote: > The execution trace of Halts() under local, global, and disabled > conditions proves that it does make the correct decision at its > decision point. You're only guessing! You're not testing the execution of H_Hat((u32) H_hat) under exactly thes ame conditions. For each call to the decider under these "local, global and disabled" conditions, you must also demonstrate that the call to H_Hat under the same "local, global and disabled" condition jibes with what the decider says. You can't say that, say, the decider run against the disabled conditions is actually making a satement about H_Hat(H_Hat) running under global conditions, or any other mismatched combination. Whenever you change the conditions under which Halts or H_Hat execute, you are changing he definitions of those functions. Their source code and machjine code may look the same, but the semantics of he machine on which they execute has changed, so they are not the same TMs. -- TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-29 10:17 -0600 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ three modes ] |
| Message-ID | <PL-dnWjxIvYRy3bCnZ2dnUU7-XHNnZ2d@giganews.com> |
| In reply to | #2411 |
On 12/28/2020 8:36 PM, Richard Damon wrote:
> On 12/28/20 6:59 PM, olcott wrote:
>> On 12/28/2020 2:11 PM, Richard Damon wrote:
>>>
>>> Please read your example again. That answer is wrong.
>>>
>>> I presume you meant u32 Input_Halts = Halts((u32)H_Hat, (u32)H_Hat);
>>>
>>> This does NOT prove that H_Hat(H_Hat) actually doesn't halt.
>>>
>>> Please run
>>>
>>> int main()
>>> {
>>> H_Hat((u32)H_Hat);
>>> }
>>>
>>> with the global halt decider disabled, but the local halt decider
>>> working.
>>>
>>> Halts MUST return an answer to H_Hat, or it fails to be a decider.
>>>
>>> You will see that the answer Halts return will be the wrong
>>> determination of what H_Hat(H_Hat) actually does.
>>>
>>> This is clear as per the definition of H_Hat, when Halts returns the 0
>>> value, then H_Hat will immediately halt.
>>>
>>
>> No amount of human intuition can possibly overcome this verifiable fact:
>>
>> The execution trace of Halts() under local, global, and disabled
>> conditions proves that it does make the correct decision at its
>> decision point.
>>
>>
>
> Show the trace with just local halt detection.
>
> Note, this should (must) show that H_Hat calls Halts(H_Hat, H_Hat), and
> then Halts returning the value to H_Hat, and then what happens to H_Hat
> after that.
>
> If Halts does not return, then it has failed to meet its requirement to
> decide to its caller in finite time.
>
>
>
int main()
{
H_Hat((u32)H_Hat);
u32 Input_Halts = Halts((u32)H_Hat, (u32)H_Hat);
Output("Input_Halts =", Input_Halts);
}
I haven't got this working yet, however, the above would output:
Input_Halts = 0
and halt when it is in local mode.
When it is in disabled mode the first line would be infinitely recursive.
When it is in global mode the first line would be decided to be
infinitely recursive.
Here is the key part of all of this:
Each halting decision can be verified as correct at its decision point.
Even though this may seem counter-intuitive actual analysis of the
decision at its decision point proves that this decision is correct.
When these axioms are applied they derive consistently correct results:
AXIOMS
Every time (within an execution trace of user-code) there is an
unconditional branch to a target <= the current address and there are no
control flow** instructions inbetween is an infinite loop.
Every time the same function is called from the same machine address a
second time (within an execution trace of user-code) without any control
flow** instructions in-between is a case of infinite recursion.
** This can probably be limited to conditional branch instructions.
--
Copyright 2020 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 | 2020-12-29 17:17 +0000 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ three modes ] |
| Message-ID | <20201229091534.759@kylheku.com> |
| In reply to | #2418 |
On 2020-12-29, olcott <NoOne@NoWhere.com> wrote:
> int main()
> {
> H_Hat((u32)H_Hat);
> u32 Input_Halts = Halts((u32)H_Hat, (u32)H_Hat);
> Output("Input_Halts =", Input_Halts);
> }
>
> I haven't got this working yet.
Claims of having that working don't happen until the weekend
of December 19, 2020, so you still have -10 days.
--
TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-29 11:24 -0600 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ three modes ] |
| Message-ID | <MKednfpHV9Ty-3bCnZ2dnUU7-SXNnZ2d@giganews.com> |
| In reply to | #2418 |
On 12/29/2020 10:57 AM, Richard Damon wrote:
> On 12/29/20 11:17 AM, olcott wrote:
>> On 12/28/2020 8:36 PM, Richard Damon wrote:
>>> On 12/28/20 6:59 PM, olcott wrote:
>>>> On 12/28/2020 2:11 PM, Richard Damon wrote:
>>>>>
>>>>> Please read your example again. That answer is wrong.
>>>>>
>>>>> I presume you meant u32 Input_Halts = Halts((u32)H_Hat, (u32)H_Hat);
>>>>>
>>>>> This does NOT prove that H_Hat(H_Hat) actually doesn't halt.
>>>>>
>>>>> Please run
>>>>>
>>>>> int main()
>>>>> {
>>>>> H_Hat((u32)H_Hat);
>>>>> }
>>>>>
>>>>> with the global halt decider disabled, but the local halt decider
>>>>> working.
>>>>>
>>>>> Halts MUST return an answer to H_Hat, or it fails to be a decider.
>>>>>
>>>>> You will see that the answer Halts return will be the wrong
>>>>> determination of what H_Hat(H_Hat) actually does.
>>>>>
>>>>> This is clear as per the definition of H_Hat, when Halts returns the 0
>>>>> value, then H_Hat will immediately halt.
>>>>>
>>>>
>>>> No amount of human intuition can possibly overcome this verifiable fact:
>>>>
>>>> The execution trace of Halts() under local, global, and disabled
>>>> conditions proves that it does make the correct decision at its
>>>> decision point.
>>>>
>>>>
>>>
>>> Show the trace with just local halt detection.
>>>
>>> Note, this should (must) show that H_Hat calls Halts(H_Hat, H_Hat), and
>>> then Halts returning the value to H_Hat, and then what happens to H_Hat
>>> after that.
>>>
>>> If Halts does not return, then it has failed to meet its requirement to
>>> decide to its caller in finite time.
>>>
>>>
>>>
>>
>> int main()
>> {
>> H_Hat((u32)H_Hat);
>> u32 Input_Halts = Halts((u32)H_Hat, (u32)H_Hat);
>> Output("Input_Halts =", Input_Halts);
>> }
>>
>> I haven't got this working yet, however, the above would output:
>> Input_Halts = 0
>> and halt when it is in local mode.
>
> I don't understand why this part is so hard, since I thought you HAD
> that part working before you messed everything up by moving the decider
> to be global.
It isn't that this part is hard it is that rewriting everything from
scratch takes time. I wanted to change it so that every step of the
halting decision could be directly seen in the execution trace.
Previously most of the key steps were done by the operating system.
>>
>> When it is in disabled mode the first line would be infinitely recursive.
>>
>> When it is in global mode the first line would be decided to be
>> infinitely recursive.
>>
>> Here is the key part of all of this:
>> Each halting decision can be verified as correct at its decision point.
>
> Note, a Decision isn't really a Decision until it can be given to the asker.
The global halt decider gives its decision to the human user through a
fatal error message in the same way that a divide by zero error is handled.
>>
>> Even though this may seem counter-intuitive actual analysis of the
>> decision at its decision point proves that this decision is correct.
>
> But if it doesn't prove that it really is a decision.
Sure it does.
(a) The axioms are correct
AXIOMS
Every time (within an execution trace of user-code)
there is an unconditional branch to a target <=
the current address and there are no control flow**
instructions inbetween is an infinite loop.
Every time the same function is called from the same
machine address a second time (within an execution
trace of user-code) without any control flow**
instructions in-between is a case of infinite recursion.
** This can probably be limited to conditional branch instructions.
(b) The execution trace meets the criteria of the axioms.
> Also, you need to PROVE that it is correct, and it needs to stand up to
> counter example.
This aspect seems to be over the heads of everyone here.
That the lack of understanding is on the part of my reviewers and not my
own misunderstanding is proven by the fact that not a single actual
material error can be shown in any aspect of my work.
The closest that anyone has come to pointing out any material error in
any of my work are empty assertions that are utterly bereft of any
supporting reasoning what-so-ever.
--
Copyright 2020 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 | 2020-12-29 18:37 +0000 |
| Subject | Re: Refuting the {Linz, Sipser, Kozen} HP Proofs [ three modes ] |
| Message-ID | <rsft1t$5ft$1@dont-email.me> |
| In reply to | #2423 |
On 2020-12-29, olcott <NoOne@NoWhere.com> wrote: > It isn't that this part is hard it is that rewriting everything from > scratch takes time. I wanted to change it so that every step of the > halting decision could be directly seen in the execution trace. > Previously most of the key steps were done by the operating system. That's a good idea; moving your smash-in-the-face incorrect calculation from operating system to user space may help you see how wrong it is. Then again, you're not convinced even by actually running H_Hat(H_Hat) and seeing that it reaches the HALT intruction, in spite of your Halt(H_Hat, H_Hat) returning zero, claiming that H_Hat(H_Hat) does no such thing. >> Note, a Decision isn't really a Decision until it can be given to the asker. > > The global halt decider gives its decision to the human user through a > fatal error message in the same way that a divide by zero error is handled. A termination with a fatal error message confirms that nothing has been decided: the decider has failed. A failed decider is deemed as having calculated the wrong answer. > (a) The axioms are correct ... just the return value fromn Halts((u32) H_Hat, (u32) H_Hat) is garbage, that's all, oops! -- TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
Page 20 of 21 — ← Prev page 1 … 18 19 [20] 21 Next page →
Back to top | Article view | comp.software-eng
csiph-web