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 7 of 21 — ← Prev page 1 … 5 6 [7] 8 9 … 21 Next page →
| From | Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> |
|---|---|
| Date | 2020-12-10 23:38 +0000 |
| Subject | Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] |
| Message-ID | <7kyAH.443026$OEna.140097@fx49.ams4> |
| In reply to | #2181 |
On 10/12/2020 21:53, olcott wrote:
> On 12/10/2020 3:19 PM, Mr Flibble wrote:
>> On 10/12/2020 21:02, olcott wrote:
>>> On 12/10/2020 1:32 PM, André G. Isaak wrote:
>>>> On 2020-12-10 09:11, olcott wrote:
>>>>> On 12/10/2020 9:55 AM, André G. Isaak wrote:
>>>>>> On 2020-12-10 08:35, olcott wrote:
>>>>>>> On 12/10/2020 9:18 AM, André G. Isaak wrote:
>>>>>>>> On 2020-12-10 07:44, olcott wrote:
>>>>>>>>> On 12/10/2020 12:54 AM, André G. Isaak wrote:
>>>>>>>>>> On 2020-12-09 21:48, olcott wrote:
>>>>>>>>>>> On 12/9/2020 10:36 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2020-12-09 11:04, olcott wrote:
>>>>>>>>>>>>> On 12/9/2020 10:52 AM, Kaz Kylheku wrote:
>>>>>>>>>>>>>> On 2020-12-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>> On 12/9/2020 5:43 AM, Anton Shepelev wrote:
>>>>>>>>>>>>>>>> Ben Bacarisse to Anton Shepelev about Pete Olcott:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That prompts an experiment: Pete Olcott provides a halt
>>>>>>>>>>>>>>>>>> decider, and you provide a program that will fool it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I've presented that challenge to him and he did in fact
>>>>>>>>>>>>>>>>> respond.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> OK, let us make a bargain: that sometime in 2021 Pete has
>>>>>>>>>>>>>>>> his groundbreaking reasearch published in one of the three
>>>>>>>>>>>>>>>> or five respectable computer-science magazines that we
>>>>>>>>>>>>>>>> offer. The losing side sends the winner a book that he
>>>>>>>>>>>>>>>> wants. If Pete wins, he will get about 15 books for free.
>>>>>>>>>>>>>>>> If he loses, he shall have to buy a book for each of us :-)
>>>>>>>>>>>>>>>> He has more than a year, so I think it a fair bargain.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I would be happy with a fair and honest review based on paying close
>>>>>>>>>>>>>>> attention to what I say and staying sharply focused on the point at hand.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The problem you're going to run into is getting a correct
>>>>>>>>>>>>>> return value out of the Halts function.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You've built a system which can tell that the overall situation his
>>>>>>>>>>>>>> runaway recursion. Somehow you hope that this can inform Halts
>>>>>>>>>>>>>> so that Halts can return the correct value, thereby refuting proofs
>>>>>>>>>>>>>> which rely on the impossibility of that event.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> However, in a nutshell, the issue is this:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Even if Halts has access to a "magic oracle" which knows
>>>>>>>>>>>>>> the halting answer for every <P, I> pair, Halts still cannot
>>>>>>>>>>>>>> return the right answer for <H_Hat, H_Hat>.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If Halts asks the magic oracle, "does H_Hat(H_Hat) halt?",
>>>>>>>>>>>>>> the oracle will give it the correct answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> However, how can Halts return that answer? Halts is itself embedded in
>>>>>>>>>>>>>> H_Hat, which intercepts the answer and behaves in a contradicting
>>>>>>>>>>>>>> manner. That is inescapable.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Even when Halts is embedded within H_Hat the master UTM based halt decider sees this and decides halting correctly anyway. To do this it must stop simulating its infinitely recursive input of H_Hat() calling its embedded Halts().
>>>>>>>>>>>>
>>>>>>>>>>>> Linz's proof states that for every putative halt decider H, one can derive a program H_Hat such that H(H_Hat, H_Hat) cannot be correctly decided.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Yes and I prove {Linz, Sipser, and Kozen} are wrong about this.
>>>>>>>>>>>
>>>>>>>>>>>> Don't you see that your "Master UTM" isn't even attempting to perform the computation equivalent to H(H_Hat, H_Hat); it is performing the computation H(main, NULL) which is something entirely different.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>
>>>>>>>>>>> Actual debug trace of H() deciding halting on H_Hat()
>>>>>>>>>>>
>>>>>>>>>>> Input to Microsoft C compiler, output is from generated COFF object file. Execution trace is from an x86 emulator.
>>>>>>>>>>>
>>>>>>>>>>> #define HALT __asm hlt
>>>>>>>>>>>
>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>> {
>>>>>>>>>>> u32 Input_Halts = H(P, P);
>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>> else
>>>>>>>>>>> HALT
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>> H((u32)H_Hat, (u32)H_Hat);
>>>>>>>>>>> HALT;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> _H_Hat()
>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>> [000005f1](03) 83c408 add esp,+08
>>>>>>>>>>> [000005f4](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>> [000005f7](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>>>>>>> [000005fb](02) 7404 jz 00000601
>>>>>>>>>>> [000005fd](02) ebfe jmp 000005fd
>>>>>>>>>>> [000005ff](02) eb01 jmp 00000602
>>>>>>>>>>> [00000601](01) f4 hlt
>>>>>>>>>>> [00000602](02) 8be5 mov esp,ebp
>>>>>>>>>>> [00000604](01) 5d pop ebp
>>>>>>>>>>> [00000605](01) c3 ret
>>>>>>>>>>>
>>>>>>>>>>> _main()
>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370
>>>>>>>>>>> [00000622](03) 83c408 add esp,+08
>>>>>>>>>>> [00000625](01) f4 hlt
>>>>>>>>>>> [00000626](01) 5d pop ebp
>>>>>>>>>>> [00000627](01) c3 ret
>>>>>>>>>>>
>>>>>>>>>>> Output_Debug_Trace() Trace_List.size(20)
>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>>>>>>>>>> Number of Instructions Executed(2777)
>>>>>>>>>>>
>>>>>>>>>>> Every time that the same function is called from the same machine address a second time without any control flow instructions in-between is a case of infinite recursion. This is shown at execution trace lines 13-21 above.
>>>>>>>>>>
>>>>>>>>>> Except, as has been noted by others, your trace is incomplete.
>>>>>>>>> I could provide 142 more pages of detail and this extra detail would not change a thing.
>>>>>>>>>
>>>>>>>>>>>> When you add this "master UTM" to your system and claim that this is your actual halt detector, your H_Hat needs to be derived from that master UTM. It would need to do everything that your master UTM does (including your weird automatic invocation of Halts(main) etc), but at the point where your master UTM returns 'halts', it would need to enter an infinite loop.
>>>>>>>>>>>
>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>
>>>>>>>>>> I don't think you grasp how proofs work. Proofs have premises and conclusions. Code traces do not. Your "fully operational code" doesn't even remotely address my objection above.
>>>>>>>>>
>>>>>>>>> A code trace <is> a formal proof of the execution of the x86 language.
>>>>>>>>
>>>>>>>> No, a code trace is not a formal proof of anything.
>>>>>>>
>>>>>>> A code trace is a totally complete proof of what the code actually does on its input.
>>>>>>
>>>>>> It isn't a proof of anything. It illustrates what a particular run of a piece of software does. It doesn't in any way demonstrate that the results it produces are correct (i.e. produce the correct result for the problem the software purports to solve).
>>>>>
>>>>> The execution trace does prove that it applied its criteria to its input correctly.
>>>>
>>>> No it doesn't. It shows that your global Halts() decided to abort its input. Nothing about that trace demonstrates that this was the correct decision to make,
>>>
>>> If you absolutely make sure to ignore what I say then when I prove my point you will not see that I proved my point.
>>>
>>> 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.
>>>
>>> On the other hand when we apply the above criteria to this case
>>>
>>> int main()
>>> {
>>> H_Halt(u32) H_Hat);
>>> }
>>>
>>> and Halts always reports infinite recursion the first chance that it gets, then it does correctly abort the above as infinite execution according to the above criteria.
>>>
>>>
>>> Actual debug trace of Halts() deciding halting on main()
>>>
>>> Input to Microsoft C compiler, output is from generated COFF object file.
>>> Execution trace is from an x86 emulator.
>>>
>>> #define HALT __asm hlt
>>>
>>> void H_Hat(u32 P)
>>> {
>>> u32 Input_Halts = DebugTrace(P, P);
>>> if (Input_Halts)
>>> HERE: goto HERE;
>>> else
>>> HALT
>>> }
>>>
>>>
>>> int main()
>>> {
>>> H_Hat((u32)H_Hat);
>>> HALT;
>>> }
>>>
>>>
>>> _H_Hat()
>>> [0000051c](01) 55 push ebp
>>> [0000051d](02) 8bec mov ebp,esp
>>> [0000051f](01) 51 push ecx
>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>> [00000523](01) 50 push eax
>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>> [00000527](01) 51 push ecx
>>> [00000528](05) e83ffeffff call 0000036c
>>> [0000052d](03) 83c408 add esp,+08
>>> [00000530](03) 8945fc mov [ebp-04],eax
>>> [00000533](04) 837dfc00 cmp dword [ebp-04],+00
>>> [00000537](02) 7404 jz 0000053d
>>> [00000539](02) ebfe jmp 00000539
>>> [0000053b](02) eb01 jmp 0000053e
>>> [0000053d](01) f4 hlt
>>> [0000053e](02) 8be5 mov esp,ebp
>>> [00000540](01) 5d pop ebp
>>> [00000541](01) c3 ret
>>>
>>> _main()
>>> [0000054c](01) 55 push ebp
>>> [0000054d](02) 8bec mov ebp,esp
>>> [0000054f](05) 681c050000 push 0000051c
>>> [00000554](05) e8c3ffffff call 0000051c
>>> [00000559](03) 83c404 add esp,+04
>>> [0000055c](01) f4 hlt
>>> [0000055d](01) 5d pop ebp
>>> [0000055e](01) c3 ret
>>>
>>> Output_Debug_Trace() Trace_List.size(19)
>>> [0000054c](01) 55 push ebp
>>> [0000054d](02) 8bec mov ebp,esp
>>> [0000054f](05) 681c050000 push 0000051c
>>> [00000554](05) e8c3ffffff call 0000051c ----CALL [0000051c]
>>> [0000051c](01) 55 push ebp
>>> [0000051d](02) 8bec mov ebp,esp
>>> [0000051f](01) 51 push ecx
>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>> [00000523](01) 50 push eax
>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>> [00000527](01) 51 push ecx
>>> [00000528](05) e83ffeffff call 0000036c ----CALL [0000036c]
>>> [0000051c](01) 55 push ebp
>>> [0000051d](02) 8bec mov ebp,esp
>>> [0000051f](01) 51 push ecx
>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>> [00000523](01) 50 push eax
>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>> [00000527](01) 51 push ecx
>>> [00000528](05) e83ffeffff call 0000036c ----CALL [0000036c]
>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>>
>>> Every time that the same function is called from the same machine address a second time without any control flow instructions in-between is a case of infinite recursion. This is shown at execution trace lines 12-20 above.
>>
>> Is this one of your "canned" replies?
>>
>> Again: you need to be able to detect infinite recursion that does have control flow instructions in-between.
>>
>> /Flibble
>>
>
> I do not need this to refute {Linz, Sipser and Kozen}.
> The infinite recursion in these cases has no control flow in-between.
You have claimed in the past to great fanfare that you have refuted Alan Turing's proof; do you now accept that you haven't?
/Flibble
--
😎
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-10 18:16 -0600 |
| Subject | Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] |
| Message-ID | <Zt6dnXNZwc7ZJ0_CnZ2dnUU7-fPNnZ2d@giganews.com> |
| In reply to | #2186 |
On 12/10/2020 5:38 PM, Mr Flibble wrote:
> On 10/12/2020 21:53, olcott wrote:
>> On 12/10/2020 3:19 PM, Mr Flibble wrote:
>>> On 10/12/2020 21:02, olcott wrote:
>>>> On 12/10/2020 1:32 PM, André G. Isaak wrote:
>>>>> On 2020-12-10 09:11, olcott wrote:
>>>>>> On 12/10/2020 9:55 AM, André G. Isaak wrote:
>>>>>>> On 2020-12-10 08:35, olcott wrote:
>>>>>>>> On 12/10/2020 9:18 AM, André G. Isaak wrote:
>>>>>>>>> On 2020-12-10 07:44, olcott wrote:
>>>>>>>>>> On 12/10/2020 12:54 AM, André G. Isaak wrote:
>>>>>>>>>>> On 2020-12-09 21:48, olcott wrote:
>>>>>>>>>>>> On 12/9/2020 10:36 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2020-12-09 11:04, olcott wrote:
>>>>>>>>>>>>>> On 12/9/2020 10:52 AM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>> On 2020-12-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>> On 12/9/2020 5:43 AM, Anton Shepelev wrote:
>>>>>>>>>>>>>>>>> Ben Bacarisse to Anton Shepelev about Pete Olcott:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That prompts an experiment: Pete Olcott provides a halt
>>>>>>>>>>>>>>>>>>> decider, and you provide a program that will fool it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I've presented that challenge to him and he did in fact
>>>>>>>>>>>>>>>>>> respond.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> OK, let us make a bargain: that sometime in 2021 Pete has
>>>>>>>>>>>>>>>>> his groundbreaking reasearch published in one of the three
>>>>>>>>>>>>>>>>> or five respectable computer-science magazines that we
>>>>>>>>>>>>>>>>> offer. The losing side sends the winner a book that he
>>>>>>>>>>>>>>>>> wants. If Pete wins, he will get about 15 books for free.
>>>>>>>>>>>>>>>>> If he loses, he shall have to buy a book for each of us
>>>>>>>>>>>>>>>>> :-)
>>>>>>>>>>>>>>>>> He has more than a year, so I think it a fair bargain.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I would be happy with a fair and honest review based on
>>>>>>>>>>>>>>>> paying close
>>>>>>>>>>>>>>>> attention to what I say and staying sharply focused on
>>>>>>>>>>>>>>>> the point at hand.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The problem you're going to run into is getting a correct
>>>>>>>>>>>>>>> return value out of the Halts function.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You've built a system which can tell that the overall
>>>>>>>>>>>>>>> situation his
>>>>>>>>>>>>>>> runaway recursion. Somehow you hope that this can inform
>>>>>>>>>>>>>>> Halts
>>>>>>>>>>>>>>> so that Halts can return the correct value, thereby
>>>>>>>>>>>>>>> refuting proofs
>>>>>>>>>>>>>>> which rely on the impossibility of that event.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> However, in a nutshell, the issue is this:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Even if Halts has access to a "magic oracle" which knows
>>>>>>>>>>>>>>> the halting answer for every <P, I> pair, Halts still
>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>> return the right answer for <H_Hat, H_Hat>.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If Halts asks the magic oracle, "does H_Hat(H_Hat) halt?",
>>>>>>>>>>>>>>> the oracle will give it the correct answer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> However, how can Halts return that answer? Halts is
>>>>>>>>>>>>>>> itself embedded in
>>>>>>>>>>>>>>> H_Hat, which intercepts the answer and behaves in a
>>>>>>>>>>>>>>> contradicting
>>>>>>>>>>>>>>> manner. That is inescapable.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Even when Halts is embedded within H_Hat the master UTM
>>>>>>>>>>>>>> based halt decider sees this and decides halting correctly
>>>>>>>>>>>>>> anyway. To do this it must stop simulating its infinitely
>>>>>>>>>>>>>> recursive input of H_Hat() calling its embedded Halts().
>>>>>>>>>>>>>
>>>>>>>>>>>>> Linz's proof states that for every putative halt decider H,
>>>>>>>>>>>>> one can derive a program H_Hat such that H(H_Hat, H_Hat)
>>>>>>>>>>>>> cannot be correctly decided.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Yes and I prove {Linz, Sipser, and Kozen} are wrong about this.
>>>>>>>>>>>>
>>>>>>>>>>>>> Don't you see that your "Master UTM" isn't even attempting
>>>>>>>>>>>>> to perform the computation equivalent to H(H_Hat, H_Hat);
>>>>>>>>>>>>> it is performing the computation H(main, NULL) which is
>>>>>>>>>>>>> something entirely different.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>>
>>>>>>>>>>>> Actual debug trace of H() deciding halting on H_Hat()
>>>>>>>>>>>>
>>>>>>>>>>>> Input to Microsoft C compiler, output is from generated COFF
>>>>>>>>>>>> object file. Execution trace is from an x86 emulator.
>>>>>>>>>>>>
>>>>>>>>>>>> #define HALT __asm hlt
>>>>>>>>>>>>
>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>> {
>>>>>>>>>>>> u32 Input_Halts = H(P, P);
>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>> else
>>>>>>>>>>>> HALT
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> H((u32)H_Hat, (u32)H_Hat);
>>>>>>>>>>>> HALT;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> _H_Hat()
>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>>> [000005f1](03) 83c408 add esp,+08
>>>>>>>>>>>> [000005f4](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>>> [000005f7](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>>>>>>>> [000005fb](02) 7404 jz 00000601
>>>>>>>>>>>> [000005fd](02) ebfe jmp 000005fd
>>>>>>>>>>>> [000005ff](02) eb01 jmp 00000602
>>>>>>>>>>>> [00000601](01) f4 hlt
>>>>>>>>>>>> [00000602](02) 8be5 mov esp,ebp
>>>>>>>>>>>> [00000604](01) 5d pop ebp
>>>>>>>>>>>> [00000605](01) c3 ret
>>>>>>>>>>>>
>>>>>>>>>>>> _main()
>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370
>>>>>>>>>>>> [00000622](03) 83c408 add esp,+08
>>>>>>>>>>>> [00000625](01) f4 hlt
>>>>>>>>>>>> [00000626](01) 5d pop ebp
>>>>>>>>>>>> [00000627](01) c3 ret
>>>>>>>>>>>>
>>>>>>>>>>>> Output_Debug_Trace() Trace_List.size(20)
>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370 ----CALL
>>>>>>>>>>>> [00000370]
>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370 ----CALL
>>>>>>>>>>>> [00000370]
>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370 ----CALL
>>>>>>>>>>>> [00000370]
>>>>>>>>>>>> The PRIOR Instruction Specifies Infinite Recursion:
>>>>>>>>>>>> Simulation Stopped:
>>>>>>>>>>>> Number of Instructions Executed(2777)
>>>>>>>>>>>>
>>>>>>>>>>>> Every time that the same function is called from the same
>>>>>>>>>>>> machine address a second time without any control flow
>>>>>>>>>>>> instructions in-between is a case of infinite recursion.
>>>>>>>>>>>> This is shown at execution trace lines 13-21 above.
>>>>>>>>>>>
>>>>>>>>>>> Except, as has been noted by others, your trace is incomplete.
>>>>>>>>>> I could provide 142 more pages of detail and this extra detail
>>>>>>>>>> would not change a thing.
>>>>>>>>>>
>>>>>>>>>>>>> When you add this "master UTM" to your system and claim
>>>>>>>>>>>>> that this is your actual halt detector, your H_Hat needs to
>>>>>>>>>>>>> be derived from that master UTM. It would need to do
>>>>>>>>>>>>> everything that your master UTM does (including your weird
>>>>>>>>>>>>> automatic invocation of Halts(main) etc), but at the point
>>>>>>>>>>>>> where your master UTM returns 'halts', it would need to
>>>>>>>>>>>>> enter an infinite loop.
>>>>>>>>>>>>
>>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>
>>>>>>>>>>> I don't think you grasp how proofs work. Proofs have premises
>>>>>>>>>>> and conclusions. Code traces do not. Your "fully operational
>>>>>>>>>>> code" doesn't even remotely address my objection above.
>>>>>>>>>>
>>>>>>>>>> A code trace <is> a formal proof of the execution of the x86
>>>>>>>>>> language.
>>>>>>>>>
>>>>>>>>> No, a code trace is not a formal proof of anything.
>>>>>>>>
>>>>>>>> A code trace is a totally complete proof of what the code
>>>>>>>> actually does on its input.
>>>>>>>
>>>>>>> It isn't a proof of anything. It illustrates what a particular
>>>>>>> run of a piece of software does. It doesn't in any way
>>>>>>> demonstrate that the results it produces are correct (i.e.
>>>>>>> produce the correct result for the problem the software purports
>>>>>>> to solve).
>>>>>>
>>>>>> The execution trace does prove that it applied its criteria to its
>>>>>> input correctly.
>>>>>
>>>>> No it doesn't. It shows that your global Halts() decided to abort
>>>>> its input. Nothing about that trace demonstrates that this was the
>>>>> correct decision to make,
>>>>
>>>> If you absolutely make sure to ignore what I say then when I prove
>>>> my point you will not see that I proved my point.
>>>>
>>>> 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.
>>>>
>>>> On the other hand when we apply the above criteria to this case
>>>>
>>>> int main()
>>>> {
>>>> H_Halt(u32) H_Hat);
>>>> }
>>>>
>>>> and Halts always reports infinite recursion the first chance that it
>>>> gets, then it does correctly abort the above as infinite execution
>>>> according to the above criteria.
>>>>
>>>>
>>>> Actual debug trace of Halts() deciding halting on main()
>>>>
>>>> Input to Microsoft C compiler, output is from generated COFF object
>>>> file.
>>>> Execution trace is from an x86 emulator.
>>>>
>>>> #define HALT __asm hlt
>>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>> u32 Input_Halts = DebugTrace(P, P);
>>>> if (Input_Halts)
>>>> HERE: goto HERE;
>>>> else
>>>> HALT
>>>> }
>>>>
>>>>
>>>> int main()
>>>> {
>>>> H_Hat((u32)H_Hat);
>>>> HALT;
>>>> }
>>>>
>>>>
>>>> _H_Hat()
>>>> [0000051c](01) 55 push ebp
>>>> [0000051d](02) 8bec mov ebp,esp
>>>> [0000051f](01) 51 push ecx
>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>> [00000523](01) 50 push eax
>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>> [00000527](01) 51 push ecx
>>>> [00000528](05) e83ffeffff call 0000036c
>>>> [0000052d](03) 83c408 add esp,+08
>>>> [00000530](03) 8945fc mov [ebp-04],eax
>>>> [00000533](04) 837dfc00 cmp dword [ebp-04],+00
>>>> [00000537](02) 7404 jz 0000053d
>>>> [00000539](02) ebfe jmp 00000539
>>>> [0000053b](02) eb01 jmp 0000053e
>>>> [0000053d](01) f4 hlt
>>>> [0000053e](02) 8be5 mov esp,ebp
>>>> [00000540](01) 5d pop ebp
>>>> [00000541](01) c3 ret
>>>>
>>>> _main()
>>>> [0000054c](01) 55 push ebp
>>>> [0000054d](02) 8bec mov ebp,esp
>>>> [0000054f](05) 681c050000 push 0000051c
>>>> [00000554](05) e8c3ffffff call 0000051c
>>>> [00000559](03) 83c404 add esp,+04
>>>> [0000055c](01) f4 hlt
>>>> [0000055d](01) 5d pop ebp
>>>> [0000055e](01) c3 ret
>>>>
>>>> Output_Debug_Trace() Trace_List.size(19)
>>>> [0000054c](01) 55 push ebp
>>>> [0000054d](02) 8bec mov ebp,esp
>>>> [0000054f](05) 681c050000 push 0000051c
>>>> [00000554](05) e8c3ffffff call 0000051c ----CALL
>>>> [0000051c]
>>>> [0000051c](01) 55 push ebp
>>>> [0000051d](02) 8bec mov ebp,esp
>>>> [0000051f](01) 51 push ecx
>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>> [00000523](01) 50 push eax
>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>> [00000527](01) 51 push ecx
>>>> [00000528](05) e83ffeffff call 0000036c ----CALL
>>>> [0000036c]
>>>> [0000051c](01) 55 push ebp
>>>> [0000051d](02) 8bec mov ebp,esp
>>>> [0000051f](01) 51 push ecx
>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>> [00000523](01) 50 push eax
>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>> [00000527](01) 51 push ecx
>>>> [00000528](05) e83ffeffff call 0000036c ----CALL
>>>> [0000036c]
>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>>>
>>>> Every time that the same function is called from the same machine
>>>> address a second time without any control flow instructions
>>>> in-between is a case of infinite recursion. This is shown at
>>>> execution trace lines 12-20 above.
>>>
>>> Is this one of your "canned" replies?
>>>
>>> Again: you need to be able to detect infinite recursion that does
>>> have control flow instructions in-between.
>>>
>>> /Flibble
>>>
>>
>> I do not need this to refute {Linz, Sipser and Kozen}.
>> The infinite recursion in these cases has no control flow in-between.
>
> You have claimed in the past to great fanfare that you have refuted Alan
> Turing's proof; do you now accept that you haven't?
>
> /Flibble
>
Where the Hell did you get that from?
There are no control flow instructions that break out of the infinite
recursion of the {Linz, Sipser and Kozen} templates so I do not need to
look at recursion that does have control flow in-between to refute all
three of these proofs.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> |
|---|---|
| Date | 2020-12-11 00:19 +0000 |
| Subject | Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] |
| Message-ID | <tWyAH.116209$9J69.107063@fx21.ams4> |
| In reply to | #2188 |
On 11/12/2020 00:16, olcott wrote:
> On 12/10/2020 5:38 PM, Mr Flibble wrote:
>> On 10/12/2020 21:53, olcott wrote:
>>> On 12/10/2020 3:19 PM, Mr Flibble wrote:
>>>> On 10/12/2020 21:02, olcott wrote:
>>>>> On 12/10/2020 1:32 PM, André G. Isaak wrote:
>>>>>> On 2020-12-10 09:11, olcott wrote:
>>>>>>> On 12/10/2020 9:55 AM, André G. Isaak wrote:
>>>>>>>> On 2020-12-10 08:35, olcott wrote:
>>>>>>>>> On 12/10/2020 9:18 AM, André G. Isaak wrote:
>>>>>>>>>> On 2020-12-10 07:44, olcott wrote:
>>>>>>>>>>> On 12/10/2020 12:54 AM, André G. Isaak wrote:
>>>>>>>>>>>> On 2020-12-09 21:48, olcott wrote:
>>>>>>>>>>>>> On 12/9/2020 10:36 PM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2020-12-09 11:04, olcott wrote:
>>>>>>>>>>>>>>> On 12/9/2020 10:52 AM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>> On 2020-12-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>> On 12/9/2020 5:43 AM, Anton Shepelev wrote:
>>>>>>>>>>>>>>>>>> Ben Bacarisse to Anton Shepelev about Pete Olcott:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That prompts an experiment: Pete Olcott provides a halt
>>>>>>>>>>>>>>>>>>>> decider, and you provide a program that will fool it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I've presented that challenge to him and he did in fact
>>>>>>>>>>>>>>>>>>> respond.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> OK, let us make a bargain: that sometime in 2021 Pete has
>>>>>>>>>>>>>>>>>> his groundbreaking reasearch published in one of the three
>>>>>>>>>>>>>>>>>> or five respectable computer-science magazines that we
>>>>>>>>>>>>>>>>>> offer. The losing side sends the winner a book that he
>>>>>>>>>>>>>>>>>> wants. If Pete wins, he will get about 15 books for free.
>>>>>>>>>>>>>>>>>> If he loses, he shall have to buy a book for each of us :-)
>>>>>>>>>>>>>>>>>> He has more than a year, so I think it a fair bargain.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I would be happy with a fair and honest review based on paying close
>>>>>>>>>>>>>>>>> attention to what I say and staying sharply focused on the point at hand.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The problem you're going to run into is getting a correct
>>>>>>>>>>>>>>>> return value out of the Halts function.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You've built a system which can tell that the overall situation his
>>>>>>>>>>>>>>>> runaway recursion. Somehow you hope that this can inform Halts
>>>>>>>>>>>>>>>> so that Halts can return the correct value, thereby refuting proofs
>>>>>>>>>>>>>>>> which rely on the impossibility of that event.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> However, in a nutshell, the issue is this:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Even if Halts has access to a "magic oracle" which knows
>>>>>>>>>>>>>>>> the halting answer for every <P, I> pair, Halts still cannot
>>>>>>>>>>>>>>>> return the right answer for <H_Hat, H_Hat>.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If Halts asks the magic oracle, "does H_Hat(H_Hat) halt?",
>>>>>>>>>>>>>>>> the oracle will give it the correct answer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> However, how can Halts return that answer? Halts is itself embedded in
>>>>>>>>>>>>>>>> H_Hat, which intercepts the answer and behaves in a contradicting
>>>>>>>>>>>>>>>> manner. That is inescapable.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Even when Halts is embedded within H_Hat the master UTM based halt decider sees this and decides halting correctly anyway. To do this it must stop simulating its infinitely recursive input of H_Hat() calling its embedded Halts().
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Linz's proof states that for every putative halt decider H, one can derive a program H_Hat such that H(H_Hat, H_Hat) cannot be correctly decided.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes and I prove {Linz, Sipser, and Kozen} are wrong about this.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Don't you see that your "Master UTM" isn't even attempting to perform the computation equivalent to H(H_Hat, H_Hat); it is performing the computation H(main, NULL) which is something entirely different.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Actual debug trace of H() deciding halting on H_Hat()
>>>>>>>>>>>>>
>>>>>>>>>>>>> Input to Microsoft C compiler, output is from generated COFF object file. Execution trace is from an x86 emulator.
>>>>>>>>>>>>>
>>>>>>>>>>>>> #define HALT __asm hlt
>>>>>>>>>>>>>
>>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>>> {
>>>>>>>>>>>>> u32 Input_Halts = H(P, P);
>>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>> else
>>>>>>>>>>>>> HALT
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> H((u32)H_Hat, (u32)H_Hat);
>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> _H_Hat()
>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>>>> [000005f1](03) 83c408 add esp,+08
>>>>>>>>>>>>> [000005f4](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>>>> [000005f7](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>>>>>>>>> [000005fb](02) 7404 jz 00000601
>>>>>>>>>>>>> [000005fd](02) ebfe jmp 000005fd
>>>>>>>>>>>>> [000005ff](02) eb01 jmp 00000602
>>>>>>>>>>>>> [00000601](01) f4 hlt
>>>>>>>>>>>>> [00000602](02) 8be5 mov esp,ebp
>>>>>>>>>>>>> [00000604](01) 5d pop ebp
>>>>>>>>>>>>> [00000605](01) c3 ret
>>>>>>>>>>>>>
>>>>>>>>>>>>> _main()
>>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370
>>>>>>>>>>>>> [00000622](03) 83c408 add esp,+08
>>>>>>>>>>>>> [00000625](01) f4 hlt
>>>>>>>>>>>>> [00000626](01) 5d pop ebp
>>>>>>>>>>>>> [00000627](01) c3 ret
>>>>>>>>>>>>>
>>>>>>>>>>>>> Output_Debug_Trace() Trace_List.size(20)
>>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>>>>>>>>>>>> Number of Instructions Executed(2777)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Every time that the same function is called from the same machine address a second time without any control flow instructions in-between is a case of infinite recursion. This is shown at execution trace lines 13-21 above.
>>>>>>>>>>>>
>>>>>>>>>>>> Except, as has been noted by others, your trace is incomplete.
>>>>>>>>>>> I could provide 142 more pages of detail and this extra detail would not change a thing.
>>>>>>>>>>>
>>>>>>>>>>>>>> When you add this "master UTM" to your system and claim that this is your actual halt detector, your H_Hat needs to be derived from that master UTM. It would need to do everything that your master UTM does (including your weird automatic invocation of Halts(main) etc), but at the point where your master UTM returns 'halts', it would need to enter an infinite loop.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>>
>>>>>>>>>>>> I don't think you grasp how proofs work. Proofs have premises and conclusions. Code traces do not. Your "fully operational code" doesn't even remotely address my objection above.
>>>>>>>>>>>
>>>>>>>>>>> A code trace <is> a formal proof of the execution of the x86 language.
>>>>>>>>>>
>>>>>>>>>> No, a code trace is not a formal proof of anything.
>>>>>>>>>
>>>>>>>>> A code trace is a totally complete proof of what the code actually does on its input.
>>>>>>>>
>>>>>>>> It isn't a proof of anything. It illustrates what a particular run of a piece of software does. It doesn't in any way demonstrate that the results it produces are correct (i.e. produce the correct result for the problem the software purports to solve).
>>>>>>>
>>>>>>> The execution trace does prove that it applied its criteria to its input correctly.
>>>>>>
>>>>>> No it doesn't. It shows that your global Halts() decided to abort its input. Nothing about that trace demonstrates that this was the correct decision to make,
>>>>>
>>>>> If you absolutely make sure to ignore what I say then when I prove my point you will not see that I proved my point.
>>>>>
>>>>> 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.
>>>>>
>>>>> On the other hand when we apply the above criteria to this case
>>>>>
>>>>> int main()
>>>>> {
>>>>> H_Halt(u32) H_Hat);
>>>>> }
>>>>>
>>>>> and Halts always reports infinite recursion the first chance that it gets, then it does correctly abort the above as infinite execution according to the above criteria.
>>>>>
>>>>>
>>>>> Actual debug trace of Halts() deciding halting on main()
>>>>>
>>>>> Input to Microsoft C compiler, output is from generated COFF object file.
>>>>> Execution trace is from an x86 emulator.
>>>>>
>>>>> #define HALT __asm hlt
>>>>>
>>>>> void H_Hat(u32 P)
>>>>> {
>>>>> u32 Input_Halts = DebugTrace(P, P);
>>>>> if (Input_Halts)
>>>>> HERE: goto HERE;
>>>>> else
>>>>> HALT
>>>>> }
>>>>>
>>>>>
>>>>> int main()
>>>>> {
>>>>> H_Hat((u32)H_Hat);
>>>>> HALT;
>>>>> }
>>>>>
>>>>>
>>>>> _H_Hat()
>>>>> [0000051c](01) 55 push ebp
>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>> [0000051f](01) 51 push ecx
>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>> [00000523](01) 50 push eax
>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>> [00000527](01) 51 push ecx
>>>>> [00000528](05) e83ffeffff call 0000036c
>>>>> [0000052d](03) 83c408 add esp,+08
>>>>> [00000530](03) 8945fc mov [ebp-04],eax
>>>>> [00000533](04) 837dfc00 cmp dword [ebp-04],+00
>>>>> [00000537](02) 7404 jz 0000053d
>>>>> [00000539](02) ebfe jmp 00000539
>>>>> [0000053b](02) eb01 jmp 0000053e
>>>>> [0000053d](01) f4 hlt
>>>>> [0000053e](02) 8be5 mov esp,ebp
>>>>> [00000540](01) 5d pop ebp
>>>>> [00000541](01) c3 ret
>>>>>
>>>>> _main()
>>>>> [0000054c](01) 55 push ebp
>>>>> [0000054d](02) 8bec mov ebp,esp
>>>>> [0000054f](05) 681c050000 push 0000051c
>>>>> [00000554](05) e8c3ffffff call 0000051c
>>>>> [00000559](03) 83c404 add esp,+04
>>>>> [0000055c](01) f4 hlt
>>>>> [0000055d](01) 5d pop ebp
>>>>> [0000055e](01) c3 ret
>>>>>
>>>>> Output_Debug_Trace() Trace_List.size(19)
>>>>> [0000054c](01) 55 push ebp
>>>>> [0000054d](02) 8bec mov ebp,esp
>>>>> [0000054f](05) 681c050000 push 0000051c
>>>>> [00000554](05) e8c3ffffff call 0000051c ----CALL [0000051c]
>>>>> [0000051c](01) 55 push ebp
>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>> [0000051f](01) 51 push ecx
>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>> [00000523](01) 50 push eax
>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>> [00000527](01) 51 push ecx
>>>>> [00000528](05) e83ffeffff call 0000036c ----CALL [0000036c]
>>>>> [0000051c](01) 55 push ebp
>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>> [0000051f](01) 51 push ecx
>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>> [00000523](01) 50 push eax
>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>> [00000527](01) 51 push ecx
>>>>> [00000528](05) e83ffeffff call 0000036c ----CALL [0000036c]
>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>>>>
>>>>> Every time that the same function is called from the same machine address a second time without any control flow instructions in-between is a case of infinite recursion. This is shown at execution trace lines 12-20 above.
>>>>
>>>> Is this one of your "canned" replies?
>>>>
>>>> Again: you need to be able to detect infinite recursion that does have control flow instructions in-between.
>>>>
>>>> /Flibble
>>>>
>>>
>>> I do not need this to refute {Linz, Sipser and Kozen}.
>>> The infinite recursion in these cases has no control flow in-between.
>>
>> You have claimed in the past to great fanfare that you have refuted Alan Turing's proof; do you now accept that you haven't?
>>
>> /Flibble
>>
>
> Where the Hell did you get that from?
>
> There are no control flow instructions that break out of the infinite recursion of the {Linz, Sipser and Kozen} templates so I do not need to look at recursion that does have control flow in-between to refute all three of these proofs.
I will take your answer as a "yes"; i.e. you admit that you have not "solved" the halting problem.
/Flibble
--
😎
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-10 18:27 -0600 |
| Subject | Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] |
| Message-ID | <s86dndmgOfVLIU_CnZ2dnUU7-QHNnZ2d@giganews.com> |
| In reply to | #2189 |
On 12/10/2020 6:19 PM, Mr Flibble wrote:
> On 11/12/2020 00:16, olcott wrote:
>> On 12/10/2020 5:38 PM, Mr Flibble wrote:
>>> On 10/12/2020 21:53, olcott wrote:
>>>> On 12/10/2020 3:19 PM, Mr Flibble wrote:
>>>>> On 10/12/2020 21:02, olcott wrote:
>>>>>> On 12/10/2020 1:32 PM, André G. Isaak wrote:
>>>>>>> On 2020-12-10 09:11, olcott wrote:
>>>>>>>> On 12/10/2020 9:55 AM, André G. Isaak wrote:
>>>>>>>>> On 2020-12-10 08:35, olcott wrote:
>>>>>>>>>> On 12/10/2020 9:18 AM, André G. Isaak wrote:
>>>>>>>>>>> On 2020-12-10 07:44, olcott wrote:
>>>>>>>>>>>> On 12/10/2020 12:54 AM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2020-12-09 21:48, olcott wrote:
>>>>>>>>>>>>>> On 12/9/2020 10:36 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2020-12-09 11:04, olcott wrote:
>>>>>>>>>>>>>>>> On 12/9/2020 10:52 AM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>> On 2020-12-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>> On 12/9/2020 5:43 AM, Anton Shepelev wrote:
>>>>>>>>>>>>>>>>>>> Ben Bacarisse to Anton Shepelev about Pete Olcott:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That prompts an experiment: Pete Olcott provides a
>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>> decider, and you provide a program that will fool it.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I've presented that challenge to him and he did in fact
>>>>>>>>>>>>>>>>>>>> respond.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> OK, let us make a bargain: that sometime in 2021 Pete
>>>>>>>>>>>>>>>>>>> has
>>>>>>>>>>>>>>>>>>> his groundbreaking reasearch published in one of the
>>>>>>>>>>>>>>>>>>> three
>>>>>>>>>>>>>>>>>>> or five respectable computer-science magazines that we
>>>>>>>>>>>>>>>>>>> offer. The losing side sends the winner a book that he
>>>>>>>>>>>>>>>>>>> wants. If Pete wins, he will get about 15 books for
>>>>>>>>>>>>>>>>>>> free.
>>>>>>>>>>>>>>>>>>> If he loses, he shall have to buy a book for each of
>>>>>>>>>>>>>>>>>>> us :-)
>>>>>>>>>>>>>>>>>>> He has more than a year, so I think it a fair bargain.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I would be happy with a fair and honest review based
>>>>>>>>>>>>>>>>>> on paying close
>>>>>>>>>>>>>>>>>> attention to what I say and staying sharply focused on
>>>>>>>>>>>>>>>>>> the point at hand.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The problem you're going to run into is getting a correct
>>>>>>>>>>>>>>>>> return value out of the Halts function.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You've built a system which can tell that the overall
>>>>>>>>>>>>>>>>> situation his
>>>>>>>>>>>>>>>>> runaway recursion. Somehow you hope that this can
>>>>>>>>>>>>>>>>> inform Halts
>>>>>>>>>>>>>>>>> so that Halts can return the correct value, thereby
>>>>>>>>>>>>>>>>> refuting proofs
>>>>>>>>>>>>>>>>> which rely on the impossibility of that event.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> However, in a nutshell, the issue is this:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Even if Halts has access to a "magic oracle" which
>>>>>>>>>>>>>>>>> knows
>>>>>>>>>>>>>>>>> the halting answer for every <P, I> pair, Halts
>>>>>>>>>>>>>>>>> still cannot
>>>>>>>>>>>>>>>>> return the right answer for <H_Hat, H_Hat>.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If Halts asks the magic oracle, "does H_Hat(H_Hat) halt?",
>>>>>>>>>>>>>>>>> the oracle will give it the correct answer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> However, how can Halts return that answer? Halts is
>>>>>>>>>>>>>>>>> itself embedded in
>>>>>>>>>>>>>>>>> H_Hat, which intercepts the answer and behaves in a
>>>>>>>>>>>>>>>>> contradicting
>>>>>>>>>>>>>>>>> manner. That is inescapable.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Even when Halts is embedded within H_Hat the master UTM
>>>>>>>>>>>>>>>> based halt decider sees this and decides halting
>>>>>>>>>>>>>>>> correctly anyway. To do this it must stop simulating its
>>>>>>>>>>>>>>>> infinitely recursive input of H_Hat() calling its
>>>>>>>>>>>>>>>> embedded Halts().
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Linz's proof states that for every putative halt decider
>>>>>>>>>>>>>>> H, one can derive a program H_Hat such that H(H_Hat,
>>>>>>>>>>>>>>> H_Hat) cannot be correctly decided.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes and I prove {Linz, Sipser, and Kozen} are wrong about
>>>>>>>>>>>>>> this.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Don't you see that your "Master UTM" isn't even
>>>>>>>>>>>>>>> attempting to perform the computation equivalent to
>>>>>>>>>>>>>>> H(H_Hat, H_Hat); it is performing the computation H(main,
>>>>>>>>>>>>>>> NULL) which is something entirely different.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Actual debug trace of H() deciding halting on H_Hat()
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Input to Microsoft C compiler, output is from generated
>>>>>>>>>>>>>> COFF object file. Execution trace is from an x86 emulator.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> #define HALT __asm hlt
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> u32 Input_Halts = H(P, P);
>>>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>> else
>>>>>>>>>>>>>> HALT
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> H((u32)H_Hat, (u32)H_Hat);
>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _H_Hat()
>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>>>>> [000005f1](03) 83c408 add esp,+08
>>>>>>>>>>>>>> [000005f4](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>>>>> [000005f7](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>>>>>>>>>> [000005fb](02) 7404 jz 00000601
>>>>>>>>>>>>>> [000005fd](02) ebfe jmp 000005fd
>>>>>>>>>>>>>> [000005ff](02) eb01 jmp 00000602
>>>>>>>>>>>>>> [00000601](01) f4 hlt
>>>>>>>>>>>>>> [00000602](02) 8be5 mov esp,ebp
>>>>>>>>>>>>>> [00000604](01) 5d pop ebp
>>>>>>>>>>>>>> [00000605](01) c3 ret
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370
>>>>>>>>>>>>>> [00000622](03) 83c408 add esp,+08
>>>>>>>>>>>>>> [00000625](01) f4 hlt
>>>>>>>>>>>>>> [00000626](01) 5d pop ebp
>>>>>>>>>>>>>> [00000627](01) c3 ret
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Output_Debug_Trace() Trace_List.size(20)
>>>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370
>>>>>>>>>>>>>> ----CALL [00000370]
>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>>>>> ----CALL [00000370]
>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>>>>> ----CALL [00000370]
>>>>>>>>>>>>>> The PRIOR Instruction Specifies Infinite Recursion:
>>>>>>>>>>>>>> Simulation Stopped:
>>>>>>>>>>>>>> Number of Instructions Executed(2777)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Every time that the same function is called from the same
>>>>>>>>>>>>>> machine address a second time without any control flow
>>>>>>>>>>>>>> instructions in-between is a case of infinite recursion.
>>>>>>>>>>>>>> This is shown at execution trace lines 13-21 above.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except, as has been noted by others, your trace is incomplete.
>>>>>>>>>>>> I could provide 142 more pages of detail and this extra
>>>>>>>>>>>> detail would not change a thing.
>>>>>>>>>>>>
>>>>>>>>>>>>>>> When you add this "master UTM" to your system and claim
>>>>>>>>>>>>>>> that this is your actual halt detector, your H_Hat needs
>>>>>>>>>>>>>>> to be derived from that master UTM. It would need to do
>>>>>>>>>>>>>>> everything that your master UTM does (including your
>>>>>>>>>>>>>>> weird automatic invocation of Halts(main) etc), but at
>>>>>>>>>>>>>>> the point where your master UTM returns 'halts', it would
>>>>>>>>>>>>>>> need to enter an infinite loop.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I don't think you grasp how proofs work. Proofs have
>>>>>>>>>>>>> premises and conclusions. Code traces do not. Your "fully
>>>>>>>>>>>>> operational code" doesn't even remotely address my
>>>>>>>>>>>>> objection above.
>>>>>>>>>>>>
>>>>>>>>>>>> A code trace <is> a formal proof of the execution of the x86
>>>>>>>>>>>> language.
>>>>>>>>>>>
>>>>>>>>>>> No, a code trace is not a formal proof of anything.
>>>>>>>>>>
>>>>>>>>>> A code trace is a totally complete proof of what the code
>>>>>>>>>> actually does on its input.
>>>>>>>>>
>>>>>>>>> It isn't a proof of anything. It illustrates what a particular
>>>>>>>>> run of a piece of software does. It doesn't in any way
>>>>>>>>> demonstrate that the results it produces are correct (i.e.
>>>>>>>>> produce the correct result for the problem the software
>>>>>>>>> purports to solve).
>>>>>>>>
>>>>>>>> The execution trace does prove that it applied its criteria to
>>>>>>>> its input correctly.
>>>>>>>
>>>>>>> No it doesn't. It shows that your global Halts() decided to abort
>>>>>>> its input. Nothing about that trace demonstrates that this was
>>>>>>> the correct decision to make,
>>>>>>
>>>>>> If you absolutely make sure to ignore what I say then when I prove
>>>>>> my point you will not see that I proved my point.
>>>>>>
>>>>>> 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.
>>>>>>
>>>>>> On the other hand when we apply the above criteria to this case
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> H_Halt(u32) H_Hat);
>>>>>> }
>>>>>>
>>>>>> and Halts always reports infinite recursion the first chance that
>>>>>> it gets, then it does correctly abort the above as infinite
>>>>>> execution according to the above criteria.
>>>>>>
>>>>>>
>>>>>> Actual debug trace of Halts() deciding halting on main()
>>>>>>
>>>>>> Input to Microsoft C compiler, output is from generated COFF
>>>>>> object file.
>>>>>> Execution trace is from an x86 emulator.
>>>>>>
>>>>>> #define HALT __asm hlt
>>>>>>
>>>>>> void H_Hat(u32 P)
>>>>>> {
>>>>>> u32 Input_Halts = DebugTrace(P, P);
>>>>>> if (Input_Halts)
>>>>>> HERE: goto HERE;
>>>>>> else
>>>>>> HALT
>>>>>> }
>>>>>>
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> H_Hat((u32)H_Hat);
>>>>>> HALT;
>>>>>> }
>>>>>>
>>>>>>
>>>>>> _H_Hat()
>>>>>> [0000051c](01) 55 push ebp
>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>> [0000051f](01) 51 push ecx
>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>> [00000523](01) 50 push eax
>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [00000527](01) 51 push ecx
>>>>>> [00000528](05) e83ffeffff call 0000036c
>>>>>> [0000052d](03) 83c408 add esp,+08
>>>>>> [00000530](03) 8945fc mov [ebp-04],eax
>>>>>> [00000533](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>> [00000537](02) 7404 jz 0000053d
>>>>>> [00000539](02) ebfe jmp 00000539
>>>>>> [0000053b](02) eb01 jmp 0000053e
>>>>>> [0000053d](01) f4 hlt
>>>>>> [0000053e](02) 8be5 mov esp,ebp
>>>>>> [00000540](01) 5d pop ebp
>>>>>> [00000541](01) c3 ret
>>>>>>
>>>>>> _main()
>>>>>> [0000054c](01) 55 push ebp
>>>>>> [0000054d](02) 8bec mov ebp,esp
>>>>>> [0000054f](05) 681c050000 push 0000051c
>>>>>> [00000554](05) e8c3ffffff call 0000051c
>>>>>> [00000559](03) 83c404 add esp,+04
>>>>>> [0000055c](01) f4 hlt
>>>>>> [0000055d](01) 5d pop ebp
>>>>>> [0000055e](01) c3 ret
>>>>>>
>>>>>> Output_Debug_Trace() Trace_List.size(19)
>>>>>> [0000054c](01) 55 push ebp
>>>>>> [0000054d](02) 8bec mov ebp,esp
>>>>>> [0000054f](05) 681c050000 push 0000051c
>>>>>> [00000554](05) e8c3ffffff call 0000051c ----CALL
>>>>>> [0000051c]
>>>>>> [0000051c](01) 55 push ebp
>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>> [0000051f](01) 51 push ecx
>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>> [00000523](01) 50 push eax
>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [00000527](01) 51 push ecx
>>>>>> [00000528](05) e83ffeffff call 0000036c ----CALL
>>>>>> [0000036c]
>>>>>> [0000051c](01) 55 push ebp
>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>> [0000051f](01) 51 push ecx
>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>> [00000523](01) 50 push eax
>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [00000527](01) 51 push ecx
>>>>>> [00000528](05) e83ffeffff call 0000036c ----CALL
>>>>>> [0000036c]
>>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation
>>>>>> Stopped:
>>>>>>
>>>>>> Every time that the same function is called from the same machine
>>>>>> address a second time without any control flow instructions
>>>>>> in-between is a case of infinite recursion. This is shown at
>>>>>> execution trace lines 12-20 above.
>>>>>
>>>>> Is this one of your "canned" replies?
>>>>>
>>>>> Again: you need to be able to detect infinite recursion that does
>>>>> have control flow instructions in-between.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> I do not need this to refute {Linz, Sipser and Kozen}.
>>>> The infinite recursion in these cases has no control flow in-between.
>>>
>>> You have claimed in the past to great fanfare that you have refuted
>>> Alan Turing's proof; do you now accept that you haven't?
>>>
>>> /Flibble
>>>
>>
>> Where the Hell did you get that from?
>>
>> There are no control flow instructions that break out of the infinite
>> recursion of the {Linz, Sipser and Kozen} templates so I do not need
>> to look at recursion that does have control flow in-between to refute
>> all three of these proofs.
>
> I will take your answer as a "yes"; i.e. you admit that you have not
> "solved" the halting problem.
>
> /Flibble
>
So maybe you understand that refuting the undecidability proofs is not
the same thing as solving the halting problem?
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> |
|---|---|
| Date | 2020-12-11 00:29 +0000 |
| Subject | Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] |
| Message-ID | <F3zAH.116210$9J69.86636@fx21.ams4> |
| In reply to | #2190 |
On 11/12/2020 00:27, olcott wrote:
> On 12/10/2020 6:19 PM, Mr Flibble wrote:
>> On 11/12/2020 00:16, olcott wrote:
>>> On 12/10/2020 5:38 PM, Mr Flibble wrote:
>>>> On 10/12/2020 21:53, olcott wrote:
>>>>> On 12/10/2020 3:19 PM, Mr Flibble wrote:
>>>>>> On 10/12/2020 21:02, olcott wrote:
>>>>>>> On 12/10/2020 1:32 PM, André G. Isaak wrote:
>>>>>>>> On 2020-12-10 09:11, olcott wrote:
>>>>>>>>> On 12/10/2020 9:55 AM, André G. Isaak wrote:
>>>>>>>>>> On 2020-12-10 08:35, olcott wrote:
>>>>>>>>>>> On 12/10/2020 9:18 AM, André G. Isaak wrote:
>>>>>>>>>>>> On 2020-12-10 07:44, olcott wrote:
>>>>>>>>>>>>> On 12/10/2020 12:54 AM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2020-12-09 21:48, olcott wrote:
>>>>>>>>>>>>>>> On 12/9/2020 10:36 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>> On 2020-12-09 11:04, olcott wrote:
>>>>>>>>>>>>>>>>> On 12/9/2020 10:52 AM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>>> On 2020-12-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>> On 12/9/2020 5:43 AM, Anton Shepelev wrote:
>>>>>>>>>>>>>>>>>>>> Ben Bacarisse to Anton Shepelev about Pete Olcott:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> That prompts an experiment: Pete Olcott provides a halt
>>>>>>>>>>>>>>>>>>>>>> decider, and you provide a program that will fool it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I've presented that challenge to him and he did in fact
>>>>>>>>>>>>>>>>>>>>> respond.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> OK, let us make a bargain: that sometime in 2021 Pete has
>>>>>>>>>>>>>>>>>>>> his groundbreaking reasearch published in one of the three
>>>>>>>>>>>>>>>>>>>> or five respectable computer-science magazines that we
>>>>>>>>>>>>>>>>>>>> offer. The losing side sends the winner a book that he
>>>>>>>>>>>>>>>>>>>> wants. If Pete wins, he will get about 15 books for free.
>>>>>>>>>>>>>>>>>>>> If he loses, he shall have to buy a book for each of us :-)
>>>>>>>>>>>>>>>>>>>> He has more than a year, so I think it a fair bargain.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I would be happy with a fair and honest review based on paying close
>>>>>>>>>>>>>>>>>>> attention to what I say and staying sharply focused on the point at hand.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The problem you're going to run into is getting a correct
>>>>>>>>>>>>>>>>>> return value out of the Halts function.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You've built a system which can tell that the overall situation his
>>>>>>>>>>>>>>>>>> runaway recursion. Somehow you hope that this can inform Halts
>>>>>>>>>>>>>>>>>> so that Halts can return the correct value, thereby refuting proofs
>>>>>>>>>>>>>>>>>> which rely on the impossibility of that event.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> However, in a nutshell, the issue is this:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Even if Halts has access to a "magic oracle" which knows
>>>>>>>>>>>>>>>>>> the halting answer for every <P, I> pair, Halts still cannot
>>>>>>>>>>>>>>>>>> return the right answer for <H_Hat, H_Hat>.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If Halts asks the magic oracle, "does H_Hat(H_Hat) halt?",
>>>>>>>>>>>>>>>>>> the oracle will give it the correct answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> However, how can Halts return that answer? Halts is itself embedded in
>>>>>>>>>>>>>>>>>> H_Hat, which intercepts the answer and behaves in a contradicting
>>>>>>>>>>>>>>>>>> manner. That is inescapable.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Even when Halts is embedded within H_Hat the master UTM based halt decider sees this and decides halting correctly anyway. To do this it must stop simulating its infinitely recursive input of H_Hat() calling its embedded Halts().
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Linz's proof states that for every putative halt decider H, one can derive a program H_Hat such that H(H_Hat, H_Hat) cannot be correctly decided.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes and I prove {Linz, Sipser, and Kozen} are wrong about this.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Don't you see that your "Master UTM" isn't even attempting to perform the computation equivalent to H(H_Hat, H_Hat); it is performing the computation H(main, NULL) which is something entirely different.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Actual debug trace of H() deciding halting on H_Hat()
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Input to Microsoft C compiler, output is from generated COFF object file. Execution trace is from an x86 emulator.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> #define HALT __asm hlt
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> u32 Input_Halts = H(P, P);
>>>>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>> HALT
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> H((u32)H_Hat, (u32)H_Hat);
>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> _H_Hat()
>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>>>>>> [000005f1](03) 83c408 add esp,+08
>>>>>>>>>>>>>>> [000005f4](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>>>>>> [000005f7](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>>>>>>>>>>> [000005fb](02) 7404 jz 00000601
>>>>>>>>>>>>>>> [000005fd](02) ebfe jmp 000005fd
>>>>>>>>>>>>>>> [000005ff](02) eb01 jmp 00000602
>>>>>>>>>>>>>>> [00000601](01) f4 hlt
>>>>>>>>>>>>>>> [00000602](02) 8be5 mov esp,ebp
>>>>>>>>>>>>>>> [00000604](01) 5d pop ebp
>>>>>>>>>>>>>>> [00000605](01) c3 ret
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370
>>>>>>>>>>>>>>> [00000622](03) 83c408 add esp,+08
>>>>>>>>>>>>>>> [00000625](01) f4 hlt
>>>>>>>>>>>>>>> [00000626](01) 5d pop ebp
>>>>>>>>>>>>>>> [00000627](01) c3 ret
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Output_Debug_Trace() Trace_List.size(20)
>>>>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>>>>>>>>>>>>>> Number of Instructions Executed(2777)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Every time that the same function is called from the same machine address a second time without any control flow instructions in-between is a case of infinite recursion. This is shown at execution trace lines 13-21 above.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except, as has been noted by others, your trace is incomplete.
>>>>>>>>>>>>> I could provide 142 more pages of detail and this extra detail would not change a thing.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When you add this "master UTM" to your system and claim that this is your actual halt detector, your H_Hat needs to be derived from that master UTM. It would need to do everything that your master UTM does (including your weird automatic invocation of Halts(main) etc), but at the point where your master UTM returns 'halts', it would need to enter an infinite loop.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I don't think you grasp how proofs work. Proofs have premises and conclusions. Code traces do not. Your "fully operational code" doesn't even remotely address my objection above.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A code trace <is> a formal proof of the execution of the x86 language.
>>>>>>>>>>>>
>>>>>>>>>>>> No, a code trace is not a formal proof of anything.
>>>>>>>>>>>
>>>>>>>>>>> A code trace is a totally complete proof of what the code actually does on its input.
>>>>>>>>>>
>>>>>>>>>> It isn't a proof of anything. It illustrates what a particular run of a piece of software does. It doesn't in any way demonstrate that the results it produces are correct (i.e. produce the correct result for the problem the software purports to solve).
>>>>>>>>>
>>>>>>>>> The execution trace does prove that it applied its criteria to its input correctly.
>>>>>>>>
>>>>>>>> No it doesn't. It shows that your global Halts() decided to abort its input. Nothing about that trace demonstrates that this was the correct decision to make,
>>>>>>>
>>>>>>> If you absolutely make sure to ignore what I say then when I prove my point you will not see that I proved my point.
>>>>>>>
>>>>>>> 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.
>>>>>>>
>>>>>>> On the other hand when we apply the above criteria to this case
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> H_Halt(u32) H_Hat);
>>>>>>> }
>>>>>>>
>>>>>>> and Halts always reports infinite recursion the first chance that it gets, then it does correctly abort the above as infinite execution according to the above criteria.
>>>>>>>
>>>>>>>
>>>>>>> Actual debug trace of Halts() deciding halting on main()
>>>>>>>
>>>>>>> Input to Microsoft C compiler, output is from generated COFF object file.
>>>>>>> Execution trace is from an x86 emulator.
>>>>>>>
>>>>>>> #define HALT __asm hlt
>>>>>>>
>>>>>>> void H_Hat(u32 P)
>>>>>>> {
>>>>>>> u32 Input_Halts = DebugTrace(P, P);
>>>>>>> if (Input_Halts)
>>>>>>> HERE: goto HERE;
>>>>>>> else
>>>>>>> HALT
>>>>>>> }
>>>>>>>
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> H_Hat((u32)H_Hat);
>>>>>>> HALT;
>>>>>>> }
>>>>>>>
>>>>>>>
>>>>>>> _H_Hat()
>>>>>>> [0000051c](01) 55 push ebp
>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>> [0000051f](01) 51 push ecx
>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>> [00000523](01) 50 push eax
>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>> [00000527](01) 51 push ecx
>>>>>>> [00000528](05) e83ffeffff call 0000036c
>>>>>>> [0000052d](03) 83c408 add esp,+08
>>>>>>> [00000530](03) 8945fc mov [ebp-04],eax
>>>>>>> [00000533](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>>> [00000537](02) 7404 jz 0000053d
>>>>>>> [00000539](02) ebfe jmp 00000539
>>>>>>> [0000053b](02) eb01 jmp 0000053e
>>>>>>> [0000053d](01) f4 hlt
>>>>>>> [0000053e](02) 8be5 mov esp,ebp
>>>>>>> [00000540](01) 5d pop ebp
>>>>>>> [00000541](01) c3 ret
>>>>>>>
>>>>>>> _main()
>>>>>>> [0000054c](01) 55 push ebp
>>>>>>> [0000054d](02) 8bec mov ebp,esp
>>>>>>> [0000054f](05) 681c050000 push 0000051c
>>>>>>> [00000554](05) e8c3ffffff call 0000051c
>>>>>>> [00000559](03) 83c404 add esp,+04
>>>>>>> [0000055c](01) f4 hlt
>>>>>>> [0000055d](01) 5d pop ebp
>>>>>>> [0000055e](01) c3 ret
>>>>>>>
>>>>>>> Output_Debug_Trace() Trace_List.size(19)
>>>>>>> [0000054c](01) 55 push ebp
>>>>>>> [0000054d](02) 8bec mov ebp,esp
>>>>>>> [0000054f](05) 681c050000 push 0000051c
>>>>>>> [00000554](05) e8c3ffffff call 0000051c ----CALL [0000051c]
>>>>>>> [0000051c](01) 55 push ebp
>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>> [0000051f](01) 51 push ecx
>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>> [00000523](01) 50 push eax
>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>> [00000527](01) 51 push ecx
>>>>>>> [00000528](05) e83ffeffff call 0000036c ----CALL [0000036c]
>>>>>>> [0000051c](01) 55 push ebp
>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>> [0000051f](01) 51 push ecx
>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>> [00000523](01) 50 push eax
>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>> [00000527](01) 51 push ecx
>>>>>>> [00000528](05) e83ffeffff call 0000036c ----CALL [0000036c]
>>>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>>>>>>
>>>>>>> Every time that the same function is called from the same machine address a second time without any control flow instructions in-between is a case of infinite recursion. This is shown at execution trace lines 12-20 above.
>>>>>>
>>>>>> Is this one of your "canned" replies?
>>>>>>
>>>>>> Again: you need to be able to detect infinite recursion that does have control flow instructions in-between.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> I do not need this to refute {Linz, Sipser and Kozen}.
>>>>> The infinite recursion in these cases has no control flow in-between.
>>>>
>>>> You have claimed in the past to great fanfare that you have refuted Alan Turing's proof; do you now accept that you haven't?
>>>>
>>>> /Flibble
>>>>
>>>
>>> Where the Hell did you get that from?
>>>
>>> There are no control flow instructions that break out of the infinite recursion of the {Linz, Sipser and Kozen} templates so I do not need to look at recursion that does have control flow in-between to refute all three of these proofs.
>>
>> I will take your answer as a "yes"; i.e. you admit that you have not "solved" the halting problem.
>>
>> /Flibble
>>
>
> So maybe you understand that refuting the undecidability proofs is not the same thing as solving the halting problem?
I am not familiar with these proofs and they don't interest me; all that interests me is that Alan Turing was correct and the halting problem is extant and always will be.
/Flibble
--
😎
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-10 18:45 -0600 |
| Subject | Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] |
| Message-ID | <gPmdncSF-4-PXE_CnZ2dnUU7-IfNnZ2d@giganews.com> |
| In reply to | #2191 |
On 12/10/2020 6:29 PM, Mr Flibble wrote:
> On 11/12/2020 00:27, olcott wrote:
>> On 12/10/2020 6:19 PM, Mr Flibble wrote:
>>> On 11/12/2020 00:16, olcott wrote:
>>>> On 12/10/2020 5:38 PM, Mr Flibble wrote:
>>>>> On 10/12/2020 21:53, olcott wrote:
>>>>>> On 12/10/2020 3:19 PM, Mr Flibble wrote:
>>>>>>> On 10/12/2020 21:02, olcott wrote:
>>>>>>>> On 12/10/2020 1:32 PM, André G. Isaak wrote:
>>>>>>>>> On 2020-12-10 09:11, olcott wrote:
>>>>>>>>>> On 12/10/2020 9:55 AM, André G. Isaak wrote:
>>>>>>>>>>> On 2020-12-10 08:35, olcott wrote:
>>>>>>>>>>>> On 12/10/2020 9:18 AM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2020-12-10 07:44, olcott wrote:
>>>>>>>>>>>>>> On 12/10/2020 12:54 AM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2020-12-09 21:48, olcott wrote:
>>>>>>>>>>>>>>>> On 12/9/2020 10:36 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>> On 2020-12-09 11:04, olcott wrote:
>>>>>>>>>>>>>>>>>> On 12/9/2020 10:52 AM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>>>> On 2020-12-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>> On 12/9/2020 5:43 AM, Anton Shepelev wrote:
>>>>>>>>>>>>>>>>>>>>> Ben Bacarisse to Anton Shepelev about Pete Olcott:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> That prompts an experiment: Pete Olcott provides
>>>>>>>>>>>>>>>>>>>>>>> a halt
>>>>>>>>>>>>>>>>>>>>>>> decider, and you provide a program that will fool
>>>>>>>>>>>>>>>>>>>>>>> it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I've presented that challenge to him and he did in
>>>>>>>>>>>>>>>>>>>>>> fact
>>>>>>>>>>>>>>>>>>>>>> respond.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> OK, let us make a bargain: that sometime in 2021
>>>>>>>>>>>>>>>>>>>>> Pete has
>>>>>>>>>>>>>>>>>>>>> his groundbreaking reasearch published in one of
>>>>>>>>>>>>>>>>>>>>> the three
>>>>>>>>>>>>>>>>>>>>> or five respectable computer-science magazines that we
>>>>>>>>>>>>>>>>>>>>> offer. The losing side sends the winner a book that he
>>>>>>>>>>>>>>>>>>>>> wants. If Pete wins, he will get about 15 books
>>>>>>>>>>>>>>>>>>>>> for free.
>>>>>>>>>>>>>>>>>>>>> If he loses, he shall have to buy a book for each
>>>>>>>>>>>>>>>>>>>>> of us :-)
>>>>>>>>>>>>>>>>>>>>> He has more than a year, so I think it a fair bargain.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I would be happy with a fair and honest review based
>>>>>>>>>>>>>>>>>>>> on paying close
>>>>>>>>>>>>>>>>>>>> attention to what I say and staying sharply focused
>>>>>>>>>>>>>>>>>>>> on the point at hand.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The problem you're going to run into is getting a
>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>> return value out of the Halts function.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You've built a system which can tell that the overall
>>>>>>>>>>>>>>>>>>> situation his
>>>>>>>>>>>>>>>>>>> runaway recursion. Somehow you hope that this can
>>>>>>>>>>>>>>>>>>> inform Halts
>>>>>>>>>>>>>>>>>>> so that Halts can return the correct value, thereby
>>>>>>>>>>>>>>>>>>> refuting proofs
>>>>>>>>>>>>>>>>>>> which rely on the impossibility of that event.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> However, in a nutshell, the issue is this:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Even if Halts has access to a "magic oracle"
>>>>>>>>>>>>>>>>>>> which knows
>>>>>>>>>>>>>>>>>>> the halting answer for every <P, I> pair, Halts
>>>>>>>>>>>>>>>>>>> still cannot
>>>>>>>>>>>>>>>>>>> return the right answer for <H_Hat, H_Hat>.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If Halts asks the magic oracle, "does H_Hat(H_Hat)
>>>>>>>>>>>>>>>>>>> halt?",
>>>>>>>>>>>>>>>>>>> the oracle will give it the correct answer.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> However, how can Halts return that answer? Halts is
>>>>>>>>>>>>>>>>>>> itself embedded in
>>>>>>>>>>>>>>>>>>> H_Hat, which intercepts the answer and behaves in a
>>>>>>>>>>>>>>>>>>> contradicting
>>>>>>>>>>>>>>>>>>> manner. That is inescapable.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Even when Halts is embedded within H_Hat the master
>>>>>>>>>>>>>>>>>> UTM based halt decider sees this and decides halting
>>>>>>>>>>>>>>>>>> correctly anyway. To do this it must stop simulating
>>>>>>>>>>>>>>>>>> its infinitely recursive input of H_Hat() calling its
>>>>>>>>>>>>>>>>>> embedded Halts().
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Linz's proof states that for every putative halt
>>>>>>>>>>>>>>>>> decider H, one can derive a program H_Hat such that
>>>>>>>>>>>>>>>>> H(H_Hat, H_Hat) cannot be correctly decided.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes and I prove {Linz, Sipser, and Kozen} are wrong
>>>>>>>>>>>>>>>> about this.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Don't you see that your "Master UTM" isn't even
>>>>>>>>>>>>>>>>> attempting to perform the computation equivalent to
>>>>>>>>>>>>>>>>> H(H_Hat, H_Hat); it is performing the computation
>>>>>>>>>>>>>>>>> H(main, NULL) which is something entirely different.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Actual debug trace of H() deciding halting on H_Hat()
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Input to Microsoft C compiler, output is from generated
>>>>>>>>>>>>>>>> COFF object file. Execution trace is from an x86 emulator.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> #define HALT __asm hlt
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> u32 Input_Halts = H(P, P);
>>>>>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>>> HALT
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> H((u32)H_Hat, (u32)H_Hat);
>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _H_Hat()
>>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>>>>>>> [000005f1](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>> [000005f4](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>>>>>>> [000005f7](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>>>>>>>>>>>> [000005fb](02) 7404 jz 00000601
>>>>>>>>>>>>>>>> [000005fd](02) ebfe jmp 000005fd
>>>>>>>>>>>>>>>> [000005ff](02) eb01 jmp 00000602
>>>>>>>>>>>>>>>> [00000601](01) f4 hlt
>>>>>>>>>>>>>>>> [00000602](02) 8be5 mov esp,ebp
>>>>>>>>>>>>>>>> [00000604](01) 5d pop ebp
>>>>>>>>>>>>>>>> [00000605](01) c3 ret
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370
>>>>>>>>>>>>>>>> [00000622](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>> [00000625](01) f4 hlt
>>>>>>>>>>>>>>>> [00000626](01) 5d pop ebp
>>>>>>>>>>>>>>>> [00000627](01) c3 ret
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Output_Debug_Trace() Trace_List.size(20)
>>>>>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370
>>>>>>>>>>>>>>>> ----CALL [00000370]
>>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>>>>>>> ----CALL [00000370]
>>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>>>>>>> ----CALL [00000370]
>>>>>>>>>>>>>>>> The PRIOR Instruction Specifies Infinite Recursion:
>>>>>>>>>>>>>>>> Simulation Stopped:
>>>>>>>>>>>>>>>> Number of Instructions Executed(2777)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Every time that the same function is called from the
>>>>>>>>>>>>>>>> same machine address a second time without any control
>>>>>>>>>>>>>>>> flow instructions in-between is a case of infinite
>>>>>>>>>>>>>>>> recursion. This is shown at execution trace lines 13-21
>>>>>>>>>>>>>>>> above.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except, as has been noted by others, your trace is
>>>>>>>>>>>>>>> incomplete.
>>>>>>>>>>>>>> I could provide 142 more pages of detail and this extra
>>>>>>>>>>>>>> detail would not change a thing.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When you add this "master UTM" to your system and claim
>>>>>>>>>>>>>>>>> that this is your actual halt detector, your H_Hat
>>>>>>>>>>>>>>>>> needs to be derived from that master UTM. It would need
>>>>>>>>>>>>>>>>> to do everything that your master UTM does (including
>>>>>>>>>>>>>>>>> your weird automatic invocation of Halts(main) etc),
>>>>>>>>>>>>>>>>> but at the point where your master UTM returns 'halts',
>>>>>>>>>>>>>>>>> it would need to enter an infinite loop.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I don't think you grasp how proofs work. Proofs have
>>>>>>>>>>>>>>> premises and conclusions. Code traces do not. Your "fully
>>>>>>>>>>>>>>> operational code" doesn't even remotely address my
>>>>>>>>>>>>>>> objection above.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A code trace <is> a formal proof of the execution of the
>>>>>>>>>>>>>> x86 language.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, a code trace is not a formal proof of anything.
>>>>>>>>>>>>
>>>>>>>>>>>> A code trace is a totally complete proof of what the code
>>>>>>>>>>>> actually does on its input.
>>>>>>>>>>>
>>>>>>>>>>> It isn't a proof of anything. It illustrates what a
>>>>>>>>>>> particular run of a piece of software does. It doesn't in any
>>>>>>>>>>> way demonstrate that the results it produces are correct
>>>>>>>>>>> (i.e. produce the correct result for the problem the software
>>>>>>>>>>> purports to solve).
>>>>>>>>>>
>>>>>>>>>> The execution trace does prove that it applied its criteria to
>>>>>>>>>> its input correctly.
>>>>>>>>>
>>>>>>>>> No it doesn't. It shows that your global Halts() decided to
>>>>>>>>> abort its input. Nothing about that trace demonstrates that
>>>>>>>>> this was the correct decision to make,
>>>>>>>>
>>>>>>>> If you absolutely make sure to ignore what I say then when I
>>>>>>>> prove my point you will not see that I proved my point.
>>>>>>>>
>>>>>>>> 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.
>>>>>>>>
>>>>>>>> On the other hand when we apply the above criteria to this case
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> H_Halt(u32) H_Hat);
>>>>>>>> }
>>>>>>>>
>>>>>>>> and Halts always reports infinite recursion the first chance
>>>>>>>> that it gets, then it does correctly abort the above as infinite
>>>>>>>> execution according to the above criteria.
>>>>>>>>
>>>>>>>>
>>>>>>>> Actual debug trace of Halts() deciding halting on main()
>>>>>>>>
>>>>>>>> Input to Microsoft C compiler, output is from generated COFF
>>>>>>>> object file.
>>>>>>>> Execution trace is from an x86 emulator.
>>>>>>>>
>>>>>>>> #define HALT __asm hlt
>>>>>>>>
>>>>>>>> void H_Hat(u32 P)
>>>>>>>> {
>>>>>>>> u32 Input_Halts = DebugTrace(P, P);
>>>>>>>> if (Input_Halts)
>>>>>>>> HERE: goto HERE;
>>>>>>>> else
>>>>>>>> HALT
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> H_Hat((u32)H_Hat);
>>>>>>>> HALT;
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>> _H_Hat()
>>>>>>>> [0000051c](01) 55 push ebp
>>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>>> [0000051f](01) 51 push ecx
>>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>>> [00000523](01) 50 push eax
>>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>> [00000527](01) 51 push ecx
>>>>>>>> [00000528](05) e83ffeffff call 0000036c
>>>>>>>> [0000052d](03) 83c408 add esp,+08
>>>>>>>> [00000530](03) 8945fc mov [ebp-04],eax
>>>>>>>> [00000533](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>>>> [00000537](02) 7404 jz 0000053d
>>>>>>>> [00000539](02) ebfe jmp 00000539
>>>>>>>> [0000053b](02) eb01 jmp 0000053e
>>>>>>>> [0000053d](01) f4 hlt
>>>>>>>> [0000053e](02) 8be5 mov esp,ebp
>>>>>>>> [00000540](01) 5d pop ebp
>>>>>>>> [00000541](01) c3 ret
>>>>>>>>
>>>>>>>> _main()
>>>>>>>> [0000054c](01) 55 push ebp
>>>>>>>> [0000054d](02) 8bec mov ebp,esp
>>>>>>>> [0000054f](05) 681c050000 push 0000051c
>>>>>>>> [00000554](05) e8c3ffffff call 0000051c
>>>>>>>> [00000559](03) 83c404 add esp,+04
>>>>>>>> [0000055c](01) f4 hlt
>>>>>>>> [0000055d](01) 5d pop ebp
>>>>>>>> [0000055e](01) c3 ret
>>>>>>>>
>>>>>>>> Output_Debug_Trace() Trace_List.size(19)
>>>>>>>> [0000054c](01) 55 push ebp
>>>>>>>> [0000054d](02) 8bec mov ebp,esp
>>>>>>>> [0000054f](05) 681c050000 push 0000051c
>>>>>>>> [00000554](05) e8c3ffffff call 0000051c ----CALL
>>>>>>>> [0000051c]
>>>>>>>> [0000051c](01) 55 push ebp
>>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>>> [0000051f](01) 51 push ecx
>>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>>> [00000523](01) 50 push eax
>>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>> [00000527](01) 51 push ecx
>>>>>>>> [00000528](05) e83ffeffff call 0000036c ----CALL
>>>>>>>> [0000036c]
>>>>>>>> [0000051c](01) 55 push ebp
>>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>>> [0000051f](01) 51 push ecx
>>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>>> [00000523](01) 50 push eax
>>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>> [00000527](01) 51 push ecx
>>>>>>>> [00000528](05) e83ffeffff call 0000036c ----CALL
>>>>>>>> [0000036c]
>>>>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation
>>>>>>>> Stopped:
>>>>>>>>
>>>>>>>> Every time that the same function is called from the same
>>>>>>>> machine address a second time without any control flow
>>>>>>>> instructions in-between is a case of infinite recursion. This is
>>>>>>>> shown at execution trace lines 12-20 above.
>>>>>>>
>>>>>>> Is this one of your "canned" replies?
>>>>>>>
>>>>>>> Again: you need to be able to detect infinite recursion that does
>>>>>>> have control flow instructions in-between.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> I do not need this to refute {Linz, Sipser and Kozen}.
>>>>>> The infinite recursion in these cases has no control flow in-between.
>>>>>
>>>>> You have claimed in the past to great fanfare that you have refuted
>>>>> Alan Turing's proof; do you now accept that you haven't?
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Where the Hell did you get that from?
>>>>
>>>> There are no control flow instructions that break out of the
>>>> infinite recursion of the {Linz, Sipser and Kozen} templates so I do
>>>> not need to look at recursion that does have control flow in-between
>>>> to refute all three of these proofs.
>>>
>>> I will take your answer as a "yes"; i.e. you admit that you have not
>>> "solved" the halting problem.
>>>
>>> /Flibble
>>>
>>
>> So maybe you understand that refuting the undecidability proofs is not
>> the same thing as solving the halting problem?
>
> I am not familiar with these proofs and they don't interest me; all that
> interests me is that Alan Turing was correct and the halting problem is
> extant and always will be.
>
> /Flibble
>
Basically all the conventional proofs of the undecidability of the
halting problem are incorrect.
Weirdo "proofs" like:
if (Goldbach's conjecture is true)
HERE: goto HERE;
else
HALT
are not covered by my refutation.
--
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-11 00:54 +0000 |
| Subject | Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] |
| Message-ID | <20201210165245.505@kylheku.com> |
| In reply to | #2192 |
On 2020-12-11, olcott <NoOne@NoWhere.com> wrote: > Basically all the conventional proofs of the undecidability of the > halting problem are incorrect. Well, they will be when this coming weekend you demonstrate, as promised, how Halts returns the correct value for H_Hat(H_Hat) in spite of being embedded in that function and contradicted by its behavior. -- TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-10 19:48 -0600 |
| Subject | Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] |
| Message-ID | <l_ydnQzQj7RqUk_CnZ2dnUU7-avNnZ2d@giganews.com> |
| In reply to | #2194 |
On 12/10/2020 6:54 PM, Kaz Kylheku wrote: > On 2020-12-11, olcott <NoOne@NoWhere.com> wrote: >> Basically all the conventional proofs of the undecidability of the >> halting problem are incorrect. > > Well, they will be when this coming weekend you demonstrate, as > promised, how Halts returns the correct value for H_Hat(H_Hat) in spite > of being embedded in that function and contradicted by its behavior. > I can't quite imagine what an embedded function would look like. I can imagine that H_Hat has a function named Halts2(). In this case it is the same refutation that I already provided. -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> |
|---|---|
| Date | 2020-12-11 00:55 +0000 |
| Subject | Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] |
| Message-ID | <SrzAH.116211$9J69.5125@fx21.ams4> |
| In reply to | #2192 |
On 11/12/2020 00:45, olcott wrote:
> On 12/10/2020 6:29 PM, Mr Flibble wrote:
>> On 11/12/2020 00:27, olcott wrote:
>>> On 12/10/2020 6:19 PM, Mr Flibble wrote:
>>>> On 11/12/2020 00:16, olcott wrote:
>>>>> On 12/10/2020 5:38 PM, Mr Flibble wrote:
>>>>>> On 10/12/2020 21:53, olcott wrote:
>>>>>>> On 12/10/2020 3:19 PM, Mr Flibble wrote:
>>>>>>>> On 10/12/2020 21:02, olcott wrote:
>>>>>>>>> On 12/10/2020 1:32 PM, André G. Isaak wrote:
>>>>>>>>>> On 2020-12-10 09:11, olcott wrote:
>>>>>>>>>>> On 12/10/2020 9:55 AM, André G. Isaak wrote:
>>>>>>>>>>>> On 2020-12-10 08:35, olcott wrote:
>>>>>>>>>>>>> On 12/10/2020 9:18 AM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2020-12-10 07:44, olcott wrote:
>>>>>>>>>>>>>>> On 12/10/2020 12:54 AM, André G. Isaak wrote:
>>>>>>>>>>>>>>>> On 2020-12-09 21:48, olcott wrote:
>>>>>>>>>>>>>>>>> On 12/9/2020 10:36 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>> On 2020-12-09 11:04, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 12/9/2020 10:52 AM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>>>>> On 2020-12-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>> On 12/9/2020 5:43 AM, Anton Shepelev wrote:
>>>>>>>>>>>>>>>>>>>>>> Ben Bacarisse to Anton Shepelev about Pete Olcott:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> That prompts an experiment: Pete Olcott provides a halt
>>>>>>>>>>>>>>>>>>>>>>>> decider, and you provide a program that will fool it.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I've presented that challenge to him and he did in fact
>>>>>>>>>>>>>>>>>>>>>>> respond.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> OK, let us make a bargain: that sometime in 2021 Pete has
>>>>>>>>>>>>>>>>>>>>>> his groundbreaking reasearch published in one of the three
>>>>>>>>>>>>>>>>>>>>>> or five respectable computer-science magazines that we
>>>>>>>>>>>>>>>>>>>>>> offer. The losing side sends the winner a book that he
>>>>>>>>>>>>>>>>>>>>>> wants. If Pete wins, he will get about 15 books for free.
>>>>>>>>>>>>>>>>>>>>>> If he loses, he shall have to buy a book for each of us :-)
>>>>>>>>>>>>>>>>>>>>>> He has more than a year, so I think it a fair bargain.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I would be happy with a fair and honest review based on paying close
>>>>>>>>>>>>>>>>>>>>> attention to what I say and staying sharply focused on the point at hand.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The problem you're going to run into is getting a correct
>>>>>>>>>>>>>>>>>>>> return value out of the Halts function.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You've built a system which can tell that the overall situation his
>>>>>>>>>>>>>>>>>>>> runaway recursion. Somehow you hope that this can inform Halts
>>>>>>>>>>>>>>>>>>>> so that Halts can return the correct value, thereby refuting proofs
>>>>>>>>>>>>>>>>>>>> which rely on the impossibility of that event.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> However, in a nutshell, the issue is this:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Even if Halts has access to a "magic oracle" which knows
>>>>>>>>>>>>>>>>>>>> the halting answer for every <P, I> pair, Halts still cannot
>>>>>>>>>>>>>>>>>>>> return the right answer for <H_Hat, H_Hat>.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If Halts asks the magic oracle, "does H_Hat(H_Hat) halt?",
>>>>>>>>>>>>>>>>>>>> the oracle will give it the correct answer.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> However, how can Halts return that answer? Halts is itself embedded in
>>>>>>>>>>>>>>>>>>>> H_Hat, which intercepts the answer and behaves in a contradicting
>>>>>>>>>>>>>>>>>>>> manner. That is inescapable.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Even when Halts is embedded within H_Hat the master UTM based halt decider sees this and decides halting correctly anyway. To do this it must stop simulating its infinitely recursive input of H_Hat() calling its embedded Halts().
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Linz's proof states that for every putative halt decider H, one can derive a program H_Hat such that H(H_Hat, H_Hat) cannot be correctly decided.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes and I prove {Linz, Sipser, and Kozen} are wrong about this.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Don't you see that your "Master UTM" isn't even attempting to perform the computation equivalent to H(H_Hat, H_Hat); it is performing the computation H(main, NULL) which is something entirely different.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Actual debug trace of H() deciding halting on H_Hat()
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Input to Microsoft C compiler, output is from generated COFF object file. Execution trace is from an x86 emulator.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> #define HALT __asm hlt
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> u32 Input_Halts = H(P, P);
>>>>>>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>>>> HALT
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> H((u32)H_Hat, (u32)H_Hat);
>>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> _H_Hat()
>>>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>>>>>>>> [000005f1](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>> [000005f4](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>>>>>>>> [000005f7](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>>>>>>>>>>>>> [000005fb](02) 7404 jz 00000601
>>>>>>>>>>>>>>>>> [000005fd](02) ebfe jmp 000005fd
>>>>>>>>>>>>>>>>> [000005ff](02) eb01 jmp 00000602
>>>>>>>>>>>>>>>>> [00000601](01) f4 hlt
>>>>>>>>>>>>>>>>> [00000602](02) 8be5 mov esp,ebp
>>>>>>>>>>>>>>>>> [00000604](01) 5d pop ebp
>>>>>>>>>>>>>>>>> [00000605](01) c3 ret
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370
>>>>>>>>>>>>>>>>> [00000622](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>> [00000625](01) f4 hlt
>>>>>>>>>>>>>>>>> [00000626](01) 5d pop ebp
>>>>>>>>>>>>>>>>> [00000627](01) c3 ret
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Output_Debug_Trace() Trace_List.size(20)
>>>>>>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>>>>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>>>>>>>>>>>>>>>> Number of Instructions Executed(2777)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Every time that the same function is called from the same machine address a second time without any control flow instructions in-between is a case of infinite recursion. This is shown at execution trace lines 13-21 above.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except, as has been noted by others, your trace is incomplete.
>>>>>>>>>>>>>>> I could provide 142 more pages of detail and this extra detail would not change a thing.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When you add this "master UTM" to your system and claim that this is your actual halt detector, your H_Hat needs to be derived from that master UTM. It would need to do everything that your master UTM does (including your weird automatic invocation of Halts(main) etc), but at the point where your master UTM returns 'halts', it would need to enter an infinite loop.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I don't think you grasp how proofs work. Proofs have premises and conclusions. Code traces do not. Your "fully operational code" doesn't even remotely address my objection above.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A code trace <is> a formal proof of the execution of the x86 language.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, a code trace is not a formal proof of anything.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A code trace is a totally complete proof of what the code actually does on its input.
>>>>>>>>>>>>
>>>>>>>>>>>> It isn't a proof of anything. It illustrates what a particular run of a piece of software does. It doesn't in any way demonstrate that the results it produces are correct (i.e. produce the correct result for the problem the software purports to solve).
>>>>>>>>>>>
>>>>>>>>>>> The execution trace does prove that it applied its criteria to its input correctly.
>>>>>>>>>>
>>>>>>>>>> No it doesn't. It shows that your global Halts() decided to abort its input. Nothing about that trace demonstrates that this was the correct decision to make,
>>>>>>>>>
>>>>>>>>> If you absolutely make sure to ignore what I say then when I prove my point you will not see that I proved my point.
>>>>>>>>>
>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>> On the other hand when we apply the above criteria to this case
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> H_Halt(u32) H_Hat);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> and Halts always reports infinite recursion the first chance that it gets, then it does correctly abort the above as infinite execution according to the above criteria.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Actual debug trace of Halts() deciding halting on main()
>>>>>>>>>
>>>>>>>>> Input to Microsoft C compiler, output is from generated COFF object file.
>>>>>>>>> Execution trace is from an x86 emulator.
>>>>>>>>>
>>>>>>>>> #define HALT __asm hlt
>>>>>>>>>
>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>> {
>>>>>>>>> u32 Input_Halts = DebugTrace(P, P);
>>>>>>>>> if (Input_Halts)
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> else
>>>>>>>>> HALT
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> H_Hat((u32)H_Hat);
>>>>>>>>> HALT;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> _H_Hat()
>>>>>>>>> [0000051c](01) 55 push ebp
>>>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>>>> [0000051f](01) 51 push ecx
>>>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>> [00000523](01) 50 push eax
>>>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>> [00000527](01) 51 push ecx
>>>>>>>>> [00000528](05) e83ffeffff call 0000036c
>>>>>>>>> [0000052d](03) 83c408 add esp,+08
>>>>>>>>> [00000530](03) 8945fc mov [ebp-04],eax
>>>>>>>>> [00000533](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>>>>> [00000537](02) 7404 jz 0000053d
>>>>>>>>> [00000539](02) ebfe jmp 00000539
>>>>>>>>> [0000053b](02) eb01 jmp 0000053e
>>>>>>>>> [0000053d](01) f4 hlt
>>>>>>>>> [0000053e](02) 8be5 mov esp,ebp
>>>>>>>>> [00000540](01) 5d pop ebp
>>>>>>>>> [00000541](01) c3 ret
>>>>>>>>>
>>>>>>>>> _main()
>>>>>>>>> [0000054c](01) 55 push ebp
>>>>>>>>> [0000054d](02) 8bec mov ebp,esp
>>>>>>>>> [0000054f](05) 681c050000 push 0000051c
>>>>>>>>> [00000554](05) e8c3ffffff call 0000051c
>>>>>>>>> [00000559](03) 83c404 add esp,+04
>>>>>>>>> [0000055c](01) f4 hlt
>>>>>>>>> [0000055d](01) 5d pop ebp
>>>>>>>>> [0000055e](01) c3 ret
>>>>>>>>>
>>>>>>>>> Output_Debug_Trace() Trace_List.size(19)
>>>>>>>>> [0000054c](01) 55 push ebp
>>>>>>>>> [0000054d](02) 8bec mov ebp,esp
>>>>>>>>> [0000054f](05) 681c050000 push 0000051c
>>>>>>>>> [00000554](05) e8c3ffffff call 0000051c ----CALL [0000051c]
>>>>>>>>> [0000051c](01) 55 push ebp
>>>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>>>> [0000051f](01) 51 push ecx
>>>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>> [00000523](01) 50 push eax
>>>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>> [00000527](01) 51 push ecx
>>>>>>>>> [00000528](05) e83ffeffff call 0000036c ----CALL [0000036c]
>>>>>>>>> [0000051c](01) 55 push ebp
>>>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>>>> [0000051f](01) 51 push ecx
>>>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>> [00000523](01) 50 push eax
>>>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>> [00000527](01) 51 push ecx
>>>>>>>>> [00000528](05) e83ffeffff call 0000036c ----CALL [0000036c]
>>>>>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>>>>>>>>
>>>>>>>>> Every time that the same function is called from the same machine address a second time without any control flow instructions in-between is a case of infinite recursion. This is shown at execution trace lines 12-20 above.
>>>>>>>>
>>>>>>>> Is this one of your "canned" replies?
>>>>>>>>
>>>>>>>> Again: you need to be able to detect infinite recursion that does have control flow instructions in-between.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> I do not need this to refute {Linz, Sipser and Kozen}.
>>>>>>> The infinite recursion in these cases has no control flow in-between.
>>>>>>
>>>>>> You have claimed in the past to great fanfare that you have refuted Alan Turing's proof; do you now accept that you haven't?
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> Where the Hell did you get that from?
>>>>>
>>>>> There are no control flow instructions that break out of the infinite recursion of the {Linz, Sipser and Kozen} templates so I do not need to look at recursion that does have control flow in-between to refute all three of these proofs.
>>>>
>>>> I will take your answer as a "yes"; i.e. you admit that you have not "solved" the halting problem.
>>>>
>>>> /Flibble
>>>>
>>>
>>> So maybe you understand that refuting the undecidability proofs is not the same thing as solving the halting problem?
>>
>> I am not familiar with these proofs and they don't interest me; all that interests me is that Alan Turing was correct and the halting problem is extant and always will be.
>>
>> /Flibble
>>
>
> Basically all the conventional proofs of the undecidability of the halting problem are incorrect.
>
> Weirdo "proofs" like:
> if (Goldbach's conjecture is true)
> HERE: goto HERE;
> else
> HALT
>
> are not covered by my refutation.
I hope the time you have spent trying to point out an error in some "proof" that has no bearing on the validity of the halting problem itself has been worth it.
I have far better ways of spending my time.
/Flibble
--
😎
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-10 19:01 -0600 |
| Subject | Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] |
| Message-ID | <1-qdnUqjTL92WU_CnZ2dnUU7-SmdnZ2d@giganews.com> |
| In reply to | #2195 |
On 12/10/2020 6:55 PM, Mr Flibble wrote:
> On 11/12/2020 00:45, olcott wrote:
>> On 12/10/2020 6:29 PM, Mr Flibble wrote:
>>> On 11/12/2020 00:27, olcott wrote:
>>>> On 12/10/2020 6:19 PM, Mr Flibble wrote:
>>>>> On 11/12/2020 00:16, olcott wrote:
>>>>>> On 12/10/2020 5:38 PM, Mr Flibble wrote:
>>>>>>> On 10/12/2020 21:53, olcott wrote:
>>>>>>>> On 12/10/2020 3:19 PM, Mr Flibble wrote:
>>>>>>>>> On 10/12/2020 21:02, olcott wrote:
>>>>>>>>>> On 12/10/2020 1:32 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2020-12-10 09:11, olcott wrote:
>>>>>>>>>>>> On 12/10/2020 9:55 AM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2020-12-10 08:35, olcott wrote:
>>>>>>>>>>>>>> On 12/10/2020 9:18 AM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2020-12-10 07:44, olcott wrote:
>>>>>>>>>>>>>>>> On 12/10/2020 12:54 AM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>> On 2020-12-09 21:48, olcott wrote:
>>>>>>>>>>>>>>>>>> On 12/9/2020 10:36 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>>> On 2020-12-09 11:04, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 12/9/2020 10:52 AM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>> On 2020-12-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>> On 12/9/2020 5:43 AM, Anton Shepelev wrote:
>>>>>>>>>>>>>>>>>>>>>>> Ben Bacarisse to Anton Shepelev about Pete Olcott:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> That prompts an experiment: Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>>> provides a halt
>>>>>>>>>>>>>>>>>>>>>>>>> decider, and you provide a program that will
>>>>>>>>>>>>>>>>>>>>>>>>> fool it.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I've presented that challenge to him and he did
>>>>>>>>>>>>>>>>>>>>>>>> in fact
>>>>>>>>>>>>>>>>>>>>>>>> respond.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> OK, let us make a bargain: that sometime in 2021
>>>>>>>>>>>>>>>>>>>>>>> Pete has
>>>>>>>>>>>>>>>>>>>>>>> his groundbreaking reasearch published in one of
>>>>>>>>>>>>>>>>>>>>>>> the three
>>>>>>>>>>>>>>>>>>>>>>> or five respectable computer-science magazines
>>>>>>>>>>>>>>>>>>>>>>> that we
>>>>>>>>>>>>>>>>>>>>>>> offer. The losing side sends the winner a book
>>>>>>>>>>>>>>>>>>>>>>> that he
>>>>>>>>>>>>>>>>>>>>>>> wants. If Pete wins, he will get about 15 books
>>>>>>>>>>>>>>>>>>>>>>> for free.
>>>>>>>>>>>>>>>>>>>>>>> If he loses, he shall have to buy a book for each
>>>>>>>>>>>>>>>>>>>>>>> of us :-)
>>>>>>>>>>>>>>>>>>>>>>> He has more than a year, so I think it a fair
>>>>>>>>>>>>>>>>>>>>>>> bargain.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I would be happy with a fair and honest review
>>>>>>>>>>>>>>>>>>>>>> based on paying close
>>>>>>>>>>>>>>>>>>>>>> attention to what I say and staying sharply
>>>>>>>>>>>>>>>>>>>>>> focused on the point at hand.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The problem you're going to run into is getting a
>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>> return value out of the Halts function.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You've built a system which can tell that the
>>>>>>>>>>>>>>>>>>>>> overall situation his
>>>>>>>>>>>>>>>>>>>>> runaway recursion. Somehow you hope that this can
>>>>>>>>>>>>>>>>>>>>> inform Halts
>>>>>>>>>>>>>>>>>>>>> so that Halts can return the correct value, thereby
>>>>>>>>>>>>>>>>>>>>> refuting proofs
>>>>>>>>>>>>>>>>>>>>> which rely on the impossibility of that event.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> However, in a nutshell, the issue is this:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Even if Halts has access to a "magic oracle"
>>>>>>>>>>>>>>>>>>>>> which knows
>>>>>>>>>>>>>>>>>>>>> the halting answer for every <P, I> pair, Halts
>>>>>>>>>>>>>>>>>>>>> still cannot
>>>>>>>>>>>>>>>>>>>>> return the right answer for <H_Hat, H_Hat>.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If Halts asks the magic oracle, "does H_Hat(H_Hat)
>>>>>>>>>>>>>>>>>>>>> halt?",
>>>>>>>>>>>>>>>>>>>>> the oracle will give it the correct answer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> However, how can Halts return that answer? Halts is
>>>>>>>>>>>>>>>>>>>>> itself embedded in
>>>>>>>>>>>>>>>>>>>>> H_Hat, which intercepts the answer and behaves in a
>>>>>>>>>>>>>>>>>>>>> contradicting
>>>>>>>>>>>>>>>>>>>>> manner. That is inescapable.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Even when Halts is embedded within H_Hat the master
>>>>>>>>>>>>>>>>>>>> UTM based halt decider sees this and decides halting
>>>>>>>>>>>>>>>>>>>> correctly anyway. To do this it must stop simulating
>>>>>>>>>>>>>>>>>>>> its infinitely recursive input of H_Hat() calling
>>>>>>>>>>>>>>>>>>>> its embedded Halts().
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Linz's proof states that for every putative halt
>>>>>>>>>>>>>>>>>>> decider H, one can derive a program H_Hat such that
>>>>>>>>>>>>>>>>>>> H(H_Hat, H_Hat) cannot be correctly decided.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes and I prove {Linz, Sipser, and Kozen} are wrong
>>>>>>>>>>>>>>>>>> about this.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Don't you see that your "Master UTM" isn't even
>>>>>>>>>>>>>>>>>>> attempting to perform the computation equivalent to
>>>>>>>>>>>>>>>>>>> H(H_Hat, H_Hat); it is performing the computation
>>>>>>>>>>>>>>>>>>> H(main, NULL) which is something entirely different.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I have fully operational code to prove that is
>>>>>>>>>>>>>>>>>> ridiculous.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Actual debug trace of H() deciding halting on H_Hat()
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Input to Microsoft C compiler, output is from
>>>>>>>>>>>>>>>>>> generated COFF object file. Execution trace is from an
>>>>>>>>>>>>>>>>>> x86 emulator.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> #define HALT __asm hlt
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> u32 Input_Halts = H(P, P);
>>>>>>>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>>>>> HALT
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> H((u32)H_Hat, (u32)H_Hat);
>>>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> _H_Hat()
>>>>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>>>>>>>>> [000005f1](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>> [000005f4](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>>>>>>>>> [000005f7](04) 837dfc00 cmp dword
>>>>>>>>>>>>>>>>>> [ebp-04],+00
>>>>>>>>>>>>>>>>>> [000005fb](02) 7404 jz 00000601
>>>>>>>>>>>>>>>>>> [000005fd](02) ebfe jmp 000005fd
>>>>>>>>>>>>>>>>>> [000005ff](02) eb01 jmp 00000602
>>>>>>>>>>>>>>>>>> [00000601](01) f4 hlt
>>>>>>>>>>>>>>>>>> [00000602](02) 8be5 mov esp,ebp
>>>>>>>>>>>>>>>>>> [00000604](01) 5d pop ebp
>>>>>>>>>>>>>>>>>> [00000605](01) c3 ret
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370
>>>>>>>>>>>>>>>>>> [00000622](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>> [00000625](01) f4 hlt
>>>>>>>>>>>>>>>>>> [00000626](01) 5d pop ebp
>>>>>>>>>>>>>>>>>> [00000627](01) c3 ret
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Output_Debug_Trace() Trace_List.size(20)
>>>>>>>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370
>>>>>>>>>>>>>>>>>> ----CALL [00000370]
>>>>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>>>>>>>>> ----CALL [00000370]
>>>>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>>>>>>>>> ----CALL [00000370]
>>>>>>>>>>>>>>>>>> The PRIOR Instruction Specifies Infinite Recursion:
>>>>>>>>>>>>>>>>>> Simulation Stopped:
>>>>>>>>>>>>>>>>>> Number of Instructions Executed(2777)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Every time that the same function is called from the
>>>>>>>>>>>>>>>>>> same machine address a second time without any control
>>>>>>>>>>>>>>>>>> flow instructions in-between is a case of infinite
>>>>>>>>>>>>>>>>>> recursion. This is shown at execution trace lines
>>>>>>>>>>>>>>>>>> 13-21 above.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except, as has been noted by others, your trace is
>>>>>>>>>>>>>>>>> incomplete.
>>>>>>>>>>>>>>>> I could provide 142 more pages of detail and this extra
>>>>>>>>>>>>>>>> detail would not change a thing.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When you add this "master UTM" to your system and
>>>>>>>>>>>>>>>>>>> claim that this is your actual halt detector, your
>>>>>>>>>>>>>>>>>>> H_Hat needs to be derived from that master UTM. It
>>>>>>>>>>>>>>>>>>> would need to do everything that your master UTM does
>>>>>>>>>>>>>>>>>>> (including your weird automatic invocation of
>>>>>>>>>>>>>>>>>>> Halts(main) etc), but at the point where your master
>>>>>>>>>>>>>>>>>>> UTM returns 'halts', it would need to enter an
>>>>>>>>>>>>>>>>>>> infinite loop.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I have fully operational code to prove that is
>>>>>>>>>>>>>>>>>> ridiculous.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I don't think you grasp how proofs work. Proofs have
>>>>>>>>>>>>>>>>> premises and conclusions. Code traces do not. Your
>>>>>>>>>>>>>>>>> "fully operational code" doesn't even remotely address
>>>>>>>>>>>>>>>>> my objection above.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A code trace <is> a formal proof of the execution of the
>>>>>>>>>>>>>>>> x86 language.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, a code trace is not a formal proof of anything.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A code trace is a totally complete proof of what the code
>>>>>>>>>>>>>> actually does on its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It isn't a proof of anything. It illustrates what a
>>>>>>>>>>>>> particular run of a piece of software does. It doesn't in
>>>>>>>>>>>>> any way demonstrate that the results it produces are
>>>>>>>>>>>>> correct (i.e. produce the correct result for the problem
>>>>>>>>>>>>> the software purports to solve).
>>>>>>>>>>>>
>>>>>>>>>>>> The execution trace does prove that it applied its criteria
>>>>>>>>>>>> to its input correctly.
>>>>>>>>>>>
>>>>>>>>>>> No it doesn't. It shows that your global Halts() decided to
>>>>>>>>>>> abort its input. Nothing about that trace demonstrates that
>>>>>>>>>>> this was the correct decision to make,
>>>>>>>>>>
>>>>>>>>>> If you absolutely make sure to ignore what I say then when I
>>>>>>>>>> prove my point you will not see that I proved my point.
>>>>>>>>>>
>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> On the other hand when we apply the above criteria to this case
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> H_Halt(u32) H_Hat);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> and Halts always reports infinite recursion the first chance
>>>>>>>>>> that it gets, then it does correctly abort the above as
>>>>>>>>>> infinite execution according to the above criteria.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Actual debug trace of Halts() deciding halting on main()
>>>>>>>>>>
>>>>>>>>>> Input to Microsoft C compiler, output is from generated COFF
>>>>>>>>>> object file.
>>>>>>>>>> Execution trace is from an x86 emulator.
>>>>>>>>>>
>>>>>>>>>> #define HALT __asm hlt
>>>>>>>>>>
>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>> {
>>>>>>>>>> u32 Input_Halts = DebugTrace(P, P);
>>>>>>>>>> if (Input_Halts)
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> else
>>>>>>>>>> HALT
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> H_Hat((u32)H_Hat);
>>>>>>>>>> HALT;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> _H_Hat()
>>>>>>>>>> [0000051c](01) 55 push ebp
>>>>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>>>>> [0000051f](01) 51 push ecx
>>>>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>> [00000523](01) 50 push eax
>>>>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>> [00000527](01) 51 push ecx
>>>>>>>>>> [00000528](05) e83ffeffff call 0000036c
>>>>>>>>>> [0000052d](03) 83c408 add esp,+08
>>>>>>>>>> [00000530](03) 8945fc mov [ebp-04],eax
>>>>>>>>>> [00000533](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>>>>>> [00000537](02) 7404 jz 0000053d
>>>>>>>>>> [00000539](02) ebfe jmp 00000539
>>>>>>>>>> [0000053b](02) eb01 jmp 0000053e
>>>>>>>>>> [0000053d](01) f4 hlt
>>>>>>>>>> [0000053e](02) 8be5 mov esp,ebp
>>>>>>>>>> [00000540](01) 5d pop ebp
>>>>>>>>>> [00000541](01) c3 ret
>>>>>>>>>>
>>>>>>>>>> _main()
>>>>>>>>>> [0000054c](01) 55 push ebp
>>>>>>>>>> [0000054d](02) 8bec mov ebp,esp
>>>>>>>>>> [0000054f](05) 681c050000 push 0000051c
>>>>>>>>>> [00000554](05) e8c3ffffff call 0000051c
>>>>>>>>>> [00000559](03) 83c404 add esp,+04
>>>>>>>>>> [0000055c](01) f4 hlt
>>>>>>>>>> [0000055d](01) 5d pop ebp
>>>>>>>>>> [0000055e](01) c3 ret
>>>>>>>>>>
>>>>>>>>>> Output_Debug_Trace() Trace_List.size(19)
>>>>>>>>>> [0000054c](01) 55 push ebp
>>>>>>>>>> [0000054d](02) 8bec mov ebp,esp
>>>>>>>>>> [0000054f](05) 681c050000 push 0000051c
>>>>>>>>>> [00000554](05) e8c3ffffff call 0000051c
>>>>>>>>>> ----CALL [0000051c]
>>>>>>>>>> [0000051c](01) 55 push ebp
>>>>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>>>>> [0000051f](01) 51 push ecx
>>>>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>> [00000523](01) 50 push eax
>>>>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>> [00000527](01) 51 push ecx
>>>>>>>>>> [00000528](05) e83ffeffff call 0000036c
>>>>>>>>>> ----CALL [0000036c]
>>>>>>>>>> [0000051c](01) 55 push ebp
>>>>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>>>>> [0000051f](01) 51 push ecx
>>>>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>> [00000523](01) 50 push eax
>>>>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>> [00000527](01) 51 push ecx
>>>>>>>>>> [00000528](05) e83ffeffff call 0000036c
>>>>>>>>>> ----CALL [0000036c]
>>>>>>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation
>>>>>>>>>> Stopped:
>>>>>>>>>>
>>>>>>>>>> Every time that the same function is called from the same
>>>>>>>>>> machine address a second time without any control flow
>>>>>>>>>> instructions in-between is a case of infinite recursion. This
>>>>>>>>>> is shown at execution trace lines 12-20 above.
>>>>>>>>>
>>>>>>>>> Is this one of your "canned" replies?
>>>>>>>>>
>>>>>>>>> Again: you need to be able to detect infinite recursion that
>>>>>>>>> does have control flow instructions in-between.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> I do not need this to refute {Linz, Sipser and Kozen}.
>>>>>>>> The infinite recursion in these cases has no control flow
>>>>>>>> in-between.
>>>>>>>
>>>>>>> You have claimed in the past to great fanfare that you have
>>>>>>> refuted Alan Turing's proof; do you now accept that you haven't?
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> Where the Hell did you get that from?
>>>>>>
>>>>>> There are no control flow instructions that break out of the
>>>>>> infinite recursion of the {Linz, Sipser and Kozen} templates so I
>>>>>> do not need to look at recursion that does have control flow
>>>>>> in-between to refute all three of these proofs.
>>>>>
>>>>> I will take your answer as a "yes"; i.e. you admit that you have
>>>>> not "solved" the halting problem.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> So maybe you understand that refuting the undecidability proofs is
>>>> not the same thing as solving the halting problem?
>>>
>>> I am not familiar with these proofs and they don't interest me; all
>>> that interests me is that Alan Turing was correct and the halting
>>> problem is extant and always will be.
>>>
>>> /Flibble
>>>
>>
>> Basically all the conventional proofs of the undecidability of the
>> halting problem are incorrect.
>>
>> Weirdo "proofs" like:
>> if (Goldbach's conjecture is true)
>> HERE: goto HERE;
>> else
>> HALT
>>
>> are not covered by my refutation.
>
> I hope the time you have spent trying to point out an error in some
> "proof" that has no bearing on the validity of the halting problem
> itself has been worth it.
>
> I have far better ways of spending my time.
>
> /Flibble
>
Since my refutation applies to three variations of the proof that means
it would also apply to the Turing proof because these other proofs are
based on the Turing proof.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> |
|---|---|
| Date | 2020-12-11 01:03 +0000 |
| Subject | Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] |
| Message-ID | <BzzAH.116212$9J69.26221@fx21.ams4> |
| In reply to | #2197 |
On 11/12/2020 01:01, olcott wrote:
> On 12/10/2020 6:55 PM, Mr Flibble wrote:
>> On 11/12/2020 00:45, olcott wrote:
>>> On 12/10/2020 6:29 PM, Mr Flibble wrote:
>>>> On 11/12/2020 00:27, olcott wrote:
>>>>> On 12/10/2020 6:19 PM, Mr Flibble wrote:
>>>>>> On 11/12/2020 00:16, olcott wrote:
>>>>>>> On 12/10/2020 5:38 PM, Mr Flibble wrote:
>>>>>>>> On 10/12/2020 21:53, olcott wrote:
>>>>>>>>> On 12/10/2020 3:19 PM, Mr Flibble wrote:
>>>>>>>>>> On 10/12/2020 21:02, olcott wrote:
>>>>>>>>>>> On 12/10/2020 1:32 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2020-12-10 09:11, olcott wrote:
>>>>>>>>>>>>> On 12/10/2020 9:55 AM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2020-12-10 08:35, olcott wrote:
>>>>>>>>>>>>>>> On 12/10/2020 9:18 AM, André G. Isaak wrote:
>>>>>>>>>>>>>>>> On 2020-12-10 07:44, olcott wrote:
>>>>>>>>>>>>>>>>> On 12/10/2020 12:54 AM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>> On 2020-12-09 21:48, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 12/9/2020 10:36 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>>>> On 2020-12-09 11:04, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 12/9/2020 10:52 AM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2020-12-09, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 12/9/2020 5:43 AM, Anton Shepelev wrote:
>>>>>>>>>>>>>>>>>>>>>>>> Ben Bacarisse to Anton Shepelev about Pete Olcott:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> That prompts an experiment: Pete Olcott provides a halt
>>>>>>>>>>>>>>>>>>>>>>>>>> decider, and you provide a program that will fool it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I've presented that challenge to him and he did in fact
>>>>>>>>>>>>>>>>>>>>>>>>> respond.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> OK, let us make a bargain: that sometime in 2021 Pete has
>>>>>>>>>>>>>>>>>>>>>>>> his groundbreaking reasearch published in one of the three
>>>>>>>>>>>>>>>>>>>>>>>> or five respectable computer-science magazines that we
>>>>>>>>>>>>>>>>>>>>>>>> offer. The losing side sends the winner a book that he
>>>>>>>>>>>>>>>>>>>>>>>> wants. If Pete wins, he will get about 15 books for free.
>>>>>>>>>>>>>>>>>>>>>>>> If he loses, he shall have to buy a book for each of us :-)
>>>>>>>>>>>>>>>>>>>>>>>> He has more than a year, so I think it a fair bargain.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I would be happy with a fair and honest review based on paying close
>>>>>>>>>>>>>>>>>>>>>>> attention to what I say and staying sharply focused on the point at hand.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The problem you're going to run into is getting a correct
>>>>>>>>>>>>>>>>>>>>>> return value out of the Halts function.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You've built a system which can tell that the overall situation his
>>>>>>>>>>>>>>>>>>>>>> runaway recursion. Somehow you hope that this can inform Halts
>>>>>>>>>>>>>>>>>>>>>> so that Halts can return the correct value, thereby refuting proofs
>>>>>>>>>>>>>>>>>>>>>> which rely on the impossibility of that event.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> However, in a nutshell, the issue is this:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Even if Halts has access to a "magic oracle" which knows
>>>>>>>>>>>>>>>>>>>>>> the halting answer for every <P, I> pair, Halts still cannot
>>>>>>>>>>>>>>>>>>>>>> return the right answer for <H_Hat, H_Hat>.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If Halts asks the magic oracle, "does H_Hat(H_Hat) halt?",
>>>>>>>>>>>>>>>>>>>>>> the oracle will give it the correct answer.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> However, how can Halts return that answer? Halts is itself embedded in
>>>>>>>>>>>>>>>>>>>>>> H_Hat, which intercepts the answer and behaves in a contradicting
>>>>>>>>>>>>>>>>>>>>>> manner. That is inescapable.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Even when Halts is embedded within H_Hat the master UTM based halt decider sees this and decides halting correctly anyway. To do this it must stop simulating its infinitely recursive input of H_Hat() calling its embedded Halts().
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Linz's proof states that for every putative halt decider H, one can derive a program H_Hat such that H(H_Hat, H_Hat) cannot be correctly decided.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes and I prove {Linz, Sipser, and Kozen} are wrong about this.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Don't you see that your "Master UTM" isn't even attempting to perform the computation equivalent to H(H_Hat, H_Hat); it is performing the computation H(main, NULL) which is something entirely different.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Actual debug trace of H() deciding halting on H_Hat()
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Input to Microsoft C compiler, output is from generated COFF object file. Execution trace is from an x86 emulator.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> #define HALT __asm hlt
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> u32 Input_Halts = H(P, P);
>>>>>>>>>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>>>>>> HALT
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> H((u32)H_Hat, (u32)H_Hat);
>>>>>>>>>>>>>>>>>>> HALT;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> _H_Hat()
>>>>>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370
>>>>>>>>>>>>>>>>>>> [000005f1](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>> [000005f4](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>>>>>>>>>> [000005f7](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>>>>>>>>>>>>>>> [000005fb](02) 7404 jz 00000601
>>>>>>>>>>>>>>>>>>> [000005fd](02) ebfe jmp 000005fd
>>>>>>>>>>>>>>>>>>> [000005ff](02) eb01 jmp 00000602
>>>>>>>>>>>>>>>>>>> [00000601](01) f4 hlt
>>>>>>>>>>>>>>>>>>> [00000602](02) 8be5 mov esp,ebp
>>>>>>>>>>>>>>>>>>> [00000604](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>> [00000605](01) c3 ret
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370
>>>>>>>>>>>>>>>>>>> [00000622](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>> [00000625](01) f4 hlt
>>>>>>>>>>>>>>>>>>> [00000626](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>> [00000627](01) c3 ret
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Output_Debug_Trace() Trace_List.size(20)
>>>>>>>>>>>>>>>>>>> [00000610](01) 55 push ebp
>>>>>>>>>>>>>>>>>>> [00000611](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>> [00000613](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>>>>> [00000618](05) 68e0050000 push 000005e0
>>>>>>>>>>>>>>>>>>> [0000061d](05) e84efdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>>>>>>>>>> [000005e0](01) 55 push ebp
>>>>>>>>>>>>>>>>>>> [000005e1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>> [000005e3](01) 51 push ecx
>>>>>>>>>>>>>>>>>>> [000005e4](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>> [000005e7](01) 50 push eax
>>>>>>>>>>>>>>>>>>> [000005e8](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>> [000005eb](01) 51 push ecx
>>>>>>>>>>>>>>>>>>> [000005ec](05) e87ffdffff call 00000370 ----CALL [00000370]
>>>>>>>>>>>>>>>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(2777)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Every time that the same function is called from the same machine address a second time without any control flow instructions in-between is a case of infinite recursion. This is shown at execution trace lines 13-21 above.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Except, as has been noted by others, your trace is incomplete.
>>>>>>>>>>>>>>>>> I could provide 142 more pages of detail and this extra detail would not change a thing.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When you add this "master UTM" to your system and claim that this is your actual halt detector, your H_Hat needs to be derived from that master UTM. It would need to do everything that your master UTM does (including your weird automatic invocation of Halts(main) etc), but at the point where your master UTM returns 'halts', it would need to enter an infinite loop.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I have fully operational code to prove that is ridiculous.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I don't think you grasp how proofs work. Proofs have premises and conclusions. Code traces do not. Your "fully operational code" doesn't even remotely address my objection above.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A code trace <is> a formal proof of the execution of the x86 language.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, a code trace is not a formal proof of anything.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A code trace is a totally complete proof of what the code actually does on its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It isn't a proof of anything. It illustrates what a particular run of a piece of software does. It doesn't in any way demonstrate that the results it produces are correct (i.e. produce the correct result for the problem the software purports to solve).
>>>>>>>>>>>>>
>>>>>>>>>>>>> The execution trace does prove that it applied its criteria to its input correctly.
>>>>>>>>>>>>
>>>>>>>>>>>> No it doesn't. It shows that your global Halts() decided to abort its input. Nothing about that trace demonstrates that this was the correct decision to make,
>>>>>>>>>>>
>>>>>>>>>>> If you absolutely make sure to ignore what I say then when I prove my point you will not see that I proved my point.
>>>>>>>>>>>
>>>>>>>>>>> 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.
>>>>>>>>>>>
>>>>>>>>>>> On the other hand when we apply the above criteria to this case
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>> H_Halt(u32) H_Hat);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> and Halts always reports infinite recursion the first chance that it gets, then it does correctly abort the above as infinite execution according to the above criteria.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Actual debug trace of Halts() deciding halting on main()
>>>>>>>>>>>
>>>>>>>>>>> Input to Microsoft C compiler, output is from generated COFF object file.
>>>>>>>>>>> Execution trace is from an x86 emulator.
>>>>>>>>>>>
>>>>>>>>>>> #define HALT __asm hlt
>>>>>>>>>>>
>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>> {
>>>>>>>>>>> u32 Input_Halts = DebugTrace(P, P);
>>>>>>>>>>> if (Input_Halts)
>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>> else
>>>>>>>>>>> HALT
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>> H_Hat((u32)H_Hat);
>>>>>>>>>>> HALT;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> _H_Hat()
>>>>>>>>>>> [0000051c](01) 55 push ebp
>>>>>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>>>>>> [0000051f](01) 51 push ecx
>>>>>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> [00000523](01) 50 push eax
>>>>>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> [00000527](01) 51 push ecx
>>>>>>>>>>> [00000528](05) e83ffeffff call 0000036c
>>>>>>>>>>> [0000052d](03) 83c408 add esp,+08
>>>>>>>>>>> [00000530](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>> [00000533](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>>>>>>> [00000537](02) 7404 jz 0000053d
>>>>>>>>>>> [00000539](02) ebfe jmp 00000539
>>>>>>>>>>> [0000053b](02) eb01 jmp 0000053e
>>>>>>>>>>> [0000053d](01) f4 hlt
>>>>>>>>>>> [0000053e](02) 8be5 mov esp,ebp
>>>>>>>>>>> [00000540](01) 5d pop ebp
>>>>>>>>>>> [00000541](01) c3 ret
>>>>>>>>>>>
>>>>>>>>>>> _main()
>>>>>>>>>>> [0000054c](01) 55 push ebp
>>>>>>>>>>> [0000054d](02) 8bec mov ebp,esp
>>>>>>>>>>> [0000054f](05) 681c050000 push 0000051c
>>>>>>>>>>> [00000554](05) e8c3ffffff call 0000051c
>>>>>>>>>>> [00000559](03) 83c404 add esp,+04
>>>>>>>>>>> [0000055c](01) f4 hlt
>>>>>>>>>>> [0000055d](01) 5d pop ebp
>>>>>>>>>>> [0000055e](01) c3 ret
>>>>>>>>>>>
>>>>>>>>>>> Output_Debug_Trace() Trace_List.size(19)
>>>>>>>>>>> [0000054c](01) 55 push ebp
>>>>>>>>>>> [0000054d](02) 8bec mov ebp,esp
>>>>>>>>>>> [0000054f](05) 681c050000 push 0000051c
>>>>>>>>>>> [00000554](05) e8c3ffffff call 0000051c ----CALL [0000051c]
>>>>>>>>>>> [0000051c](01) 55 push ebp
>>>>>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>>>>>> [0000051f](01) 51 push ecx
>>>>>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> [00000523](01) 50 push eax
>>>>>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> [00000527](01) 51 push ecx
>>>>>>>>>>> [00000528](05) e83ffeffff call 0000036c ----CALL [0000036c]
>>>>>>>>>>> [0000051c](01) 55 push ebp
>>>>>>>>>>> [0000051d](02) 8bec mov ebp,esp
>>>>>>>>>>> [0000051f](01) 51 push ecx
>>>>>>>>>>> [00000520](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> [00000523](01) 50 push eax
>>>>>>>>>>> [00000524](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> [00000527](01) 51 push ecx
>>>>>>>>>>> [00000528](05) e83ffeffff call 0000036c ----CALL [0000036c]
>>>>>>>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>>>>>>>>>>
>>>>>>>>>>> Every time that the same function is called from the same machine address a second time without any control flow instructions in-between is a case of infinite recursion. This is shown at execution trace lines 12-20 above.
>>>>>>>>>>
>>>>>>>>>> Is this one of your "canned" replies?
>>>>>>>>>>
>>>>>>>>>> Again: you need to be able to detect infinite recursion that does have control flow instructions in-between.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I do not need this to refute {Linz, Sipser and Kozen}.
>>>>>>>>> The infinite recursion in these cases has no control flow in-between.
>>>>>>>>
>>>>>>>> You have claimed in the past to great fanfare that you have refuted Alan Turing's proof; do you now accept that you haven't?
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> Where the Hell did you get that from?
>>>>>>>
>>>>>>> There are no control flow instructions that break out of the infinite recursion of the {Linz, Sipser and Kozen} templates so I do not need to look at recursion that does have control flow in-between to refute all three of these proofs.
>>>>>>
>>>>>> I will take your answer as a "yes"; i.e. you admit that you have not "solved" the halting problem.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> So maybe you understand that refuting the undecidability proofs is not the same thing as solving the halting problem?
>>>>
>>>> I am not familiar with these proofs and they don't interest me; all that interests me is that Alan Turing was correct and the halting problem is extant and always will be.
>>>>
>>>> /Flibble
>>>>
>>>
>>> Basically all the conventional proofs of the undecidability of the halting problem are incorrect.
>>>
>>> Weirdo "proofs" like:
>>> if (Goldbach's conjecture is true)
>>> HERE: goto HERE;
>>> else
>>> HALT
>>>
>>> are not covered by my refutation.
>>
>> I hope the time you have spent trying to point out an error in some "proof" that has no bearing on the validity of the halting problem itself has been worth it.
>>
>> I have far better ways of spending my time.
>>
>> /Flibble
>>
>
> Since my refutation applies to three variations of the proof that means it would also apply to the Turing proof because these other proofs are based on the Turing proof.
How long have you been suffering from Obsessive Self-Contradiction Disorder exactly?
/Flibble
--
😎
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2020-12-11 01:14 +0000 |
| Subject | Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] |
| Message-ID | <20201210171338.306@kylheku.com> |
| In reply to | #2197 |
On 2020-12-11, olcott <NoOne@NoWhere.com> wrote: > Since my refutation applies to three variations of the proof that means > it would also apply to the Turing proof because these other proofs are > based on the Turing proof. That statement contains a severe error of logical inference. No wait, did you say three variations? never mind, you're good! -- TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | Jeff Barnett <jbb@notatt.com> |
|---|---|
| Date | 2020-12-10 21:54 -0700 |
| Subject | Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] |
| Message-ID | <rquu2o$5rs$1@dont-email.me> |
| In reply to | #2195 |
On 12/10/2020 5:55 PM, Mr Flibble wrote:
> On 11/12/2020 00:45, olcott wrote:
<Big SNIP>
>> are not covered by my refutation.
>
> I hope the time you have spent trying to point out an error in some
> "proof" that has no bearing on the validity of the halting problem
> itself has been worth it.
>
> I have far better ways of spending my time.
You surely don't think debating with this idiot is a better way of
spending your time, do you?
--
Jeff Barnett
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2020-12-10 23:10 +0000 |
| Subject | Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ] |
| Message-ID | <20201210142914.610@kylheku.com> |
| In reply to | #2179 |
["Followup-To:" header set to comp.theory.]
On 2020-12-10, olcott <NoOne@NoWhere.com> wrote:
>> No it doesn't. It shows that your global Halts() decided to abort its
>> input. Nothing about that trace demonstrates that this was the correct
>> decision to make,
>
> If you absolutely make sure to ignore what I say then when I prove my
> point you will not see that I proved my point.
>
> 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.
>
> On the other hand when we apply the above criteria to this case
>
> int main()
> {
> H_Halt(u32) H_Hat);
> }
>
> and Halts always reports infinite recursion the first chance that it
> gets, then it does correctly abort the above as infinite execution
> according to the above criteria.
Halts reporting infinite recursion the first chance it gets is literally
this:
bool Halts()
{
return false;
}
> Actual debug trace of Halts() deciding halting on main()
None of the traces you've shown so far show Halts deciding anything.
They confirm that the execution stops at a point where Halts has not
returned.
The program you're showing now doesn't even contain a function
called Halts:
> #define HALT __asm hlt
>
> void H_Hat(u32 P)
> {
> u32 Input_Halts = DebugTrace(P, P);
DebugTrace is supposed to the halting decider; okay let's
take that at face value.
> if (Input_Halts)
> HERE: goto HERE;
> else
> HALT
> }
>
>
> int main()
> {
> H_Hat((u32)H_Hat);
> HALT;
> }
>
> _H_Hat()
> [0000051c](01) 55 push ebp
> [0000051d](02) 8bec mov ebp,esp
> [0000051f](01) 51 push ecx
> [00000520](03) 8b4508 mov eax,[ebp+08]
> [00000523](01) 50 push eax
> [00000524](03) 8b4d08 mov ecx,[ebp+08]
> [00000527](01) 51 push ecx
> [00000528](05) e83ffeffff call 0000036c
Note that address 528 is in H_Hat().
> Output_Debug_Trace() Trace_List.size(19)
> [0000054c](01) 55 push ebp
[ ... ]
> [00000527](01) 51 push ecx
> [00000528](05) e83ffeffff call 0000036c ----CALL [0000036c]
> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
The PRIOR instruction is in H_Hat, not in anything called Halts or
DebugTrace.
Everything stops, and so the last piece of code executed was inside
H_Hat.
That's not the place where any decision is announced.
Evidence of a decision being made would consist of the execution
reaching this block of code in H_Hat:
> [00000537](02) 7404 jz 0000053d
Fall through to here if the decision is non-zero (halts).
> [00000539](02) ebfe jmp 00000539
Else go here, if the decision is zero (does not halt).
> [0000053d](01) f4 hlt
The machine would detect these and stop; it stops on hlt, and it stops
on a trivial loop (instruction jumping to itself).
If you can get it to execute that far, it would show that the DebugTrace
decider has reported a return value. We would know that the value
is wrong because if "jz 000053d" is taken ("does not halt"), then hlt
is executed, and if that branch is not taken ("does halt"), then in fact
the machine does not halt due to a loop.
Your trace does not reach here, and so no decision has been announced.
--
TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-10 18:58 -0600 |
| Subject | Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) |
| Message-ID | <1-qdnUujTL_fWU_CnZ2dnUU7-SnNnZ2d@giganews.com> |
| In reply to | #2172 |
On 12/10/2020 6:49 PM, Mike Terry wrote: > On 10/12/2020 22:28, Kaz Kylheku wrote: >> On 2020-12-10, Ben Bacarisse <ben.usenet@bsb.me.uk> wrote: >>> André G. Isaak <agisaak@gm.invalid> writes: >>> <cut the dump of a "trace" of something> >>> >>>> The problem is that there *are* conditional branches between the above >>>> calls. You just don't show them. There must be because your 'halt >>>> detector' makes a decision as to whether to abort at any given >>>> call. That involves a conditional branch. >>> >>> Is it wise to even discuss these traces? You don't even have the source >>> that generated the x86 code being traced (recent posts have all >>> suspiciously omitted the key function), and you certainly don't have the >>> software that does the tracing and generates the output. >>> >>> Remember when "halting" was defined by what the code would do if a line >>> in H was commented out? That's a measure of the sort of thing that >>> could be going on here. And another time, Halts(P, I) was replaced by >>> an "emulator" that just called P(I). There is, right now, simply no way >>> to know what sort of skulduggery is gong on. >> >> I suspect it might be headed toward some hack whereby the H(P, P) call >> inside H_Hat (where P = H_Hat) returns a different value from H(H_Hat, >> H_Hat) >> in the main function. >> >> Peter will then not accept that it is invalid for different calls >> to H to yield different values on exactly the same inputs. > > We've previously covered that one and PO agreed that all calls to H with > the same parameters must give the same result. Except infinitely recursive calls that are aborted and thus do not return any result at all. > (He could find some > excuse to change his mind if he needed to, I'm sure, but I've not seen > that happening yet.) > > Mike. > > >> -- 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-11 01:13 +0000 |
| Subject | Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) |
| Message-ID | <20201210170641.499@kylheku.com> |
| In reply to | #2196 |
On 2020-12-11, olcott <NoOne@NoWhere.com> wrote: > On 12/10/2020 6:49 PM, Mike Terry wrote: >> On 10/12/2020 22:28, Kaz Kylheku wrote: >>> On 2020-12-10, Ben Bacarisse <ben.usenet@bsb.me.uk> wrote: >>>> André G. Isaak <agisaak@gm.invalid> writes: >>>> <cut the dump of a "trace" of something> >>>> >>>>> The problem is that there *are* conditional branches between the above >>>>> calls. You just don't show them. There must be because your 'halt >>>>> detector' makes a decision as to whether to abort at any given >>>>> call. That involves a conditional branch. >>>> >>>> Is it wise to even discuss these traces? You don't even have the source >>>> that generated the x86 code being traced (recent posts have all >>>> suspiciously omitted the key function), and you certainly don't have the >>>> software that does the tracing and generates the output. >>>> >>>> Remember when "halting" was defined by what the code would do if a line >>>> in H was commented out? That's a measure of the sort of thing that >>>> could be going on here. And another time, Halts(P, I) was replaced by >>>> an "emulator" that just called P(I). There is, right now, simply no way >>>> to know what sort of skulduggery is gong on. >>> >>> I suspect it might be headed toward some hack whereby the H(P, P) call >>> inside H_Hat (where P = H_Hat) returns a different value from H(H_Hat, >>> H_Hat) >>> in the main function. >>> >>> Peter will then not accept that it is invalid for different calls >>> to H to yield different values on exactly the same inputs. >> >> We've previously covered that one and PO agreed that all calls to H with >> the same parameters must give the same result. > > Except infinitely recursive calls that are aborted and thus do not > return any result at all. That's not really an exception to anything, since infinitely recursive calls which are not aborted also do not return any result at all; but it's good to see you repeat an acknowledgement that an aborted execution does not return a result. -- TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-10 19:33 -0600 |
| Subject | Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) |
| Message-ID | <xI2dndA92MoeUU_CnZ2dnUU7-SXNnZ2d@giganews.com> |
| In reply to | #2200 |
On 12/10/2020 7:13 PM, Kaz Kylheku wrote: > On 2020-12-11, olcott <NoOne@NoWhere.com> wrote: >> On 12/10/2020 6:49 PM, Mike Terry wrote: >>> On 10/12/2020 22:28, Kaz Kylheku wrote: >>>> On 2020-12-10, Ben Bacarisse <ben.usenet@bsb.me.uk> wrote: >>>>> André G. Isaak <agisaak@gm.invalid> writes: >>>>> <cut the dump of a "trace" of something> >>>>> >>>>>> The problem is that there *are* conditional branches between the above >>>>>> calls. You just don't show them. There must be because your 'halt >>>>>> detector' makes a decision as to whether to abort at any given >>>>>> call. That involves a conditional branch. >>>>> >>>>> Is it wise to even discuss these traces? You don't even have the source >>>>> that generated the x86 code being traced (recent posts have all >>>>> suspiciously omitted the key function), and you certainly don't have the >>>>> software that does the tracing and generates the output. >>>>> >>>>> Remember when "halting" was defined by what the code would do if a line >>>>> in H was commented out? That's a measure of the sort of thing that >>>>> could be going on here. And another time, Halts(P, I) was replaced by >>>>> an "emulator" that just called P(I). There is, right now, simply no way >>>>> to know what sort of skulduggery is gong on. >>>> >>>> I suspect it might be headed toward some hack whereby the H(P, P) call >>>> inside H_Hat (where P = H_Hat) returns a different value from H(H_Hat, >>>> H_Hat) >>>> in the main function. >>>> >>>> Peter will then not accept that it is invalid for different calls >>>> to H to yield different values on exactly the same inputs. >>> >>> We've previously covered that one and PO agreed that all calls to H with >>> the same parameters must give the same result. >> >> Except infinitely recursive calls that are aborted and thus do not >> return any result at all. > > That's not really an exception to anything, since infinitely recursive > calls which are not aborted also do not return any result at all; but > it's good to see you repeat an acknowledgement that an aborted execution > does not return a result. > Until my discovery in 2016 I don't think it ever occurred to anyone that the conventional halting problem counter-examples are inherently infinitely recursive, thus decidable on this basis. This was the key discovery that made them decidable. Infinitely Recursive input on HP Proofs https://groups.google.com/g/comp.theory/c/NcFS02hKs1U/m/dhNDYvhFAAAJ -- 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-11 19:13 +0000 |
| Subject | Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) |
| Message-ID | <20201211110506.118@kylheku.com> |
| In reply to | #2203 |
["Followup-To:" header set to comp.theory.]
On 2020-12-11, olcott <NoOne@NoWhere.com> wrote:
> On 12/10/2020 7:13 PM, Kaz Kylheku wrote:
>> On 2020-12-11, olcott <NoOne@NoWhere.com> wrote:
>>> On 12/10/2020 6:49 PM, Mike Terry wrote:
>>>> On 10/12/2020 22:28, Kaz Kylheku wrote:
>>>>> On 2020-12-10, Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>>>>>> André G. Isaak <agisaak@gm.invalid> writes:
>>>>>> <cut the dump of a "trace" of something>
>>>>>>
>>>>>>> The problem is that there *are* conditional branches between the above
>>>>>>> calls. You just don't show them. There must be because your 'halt
>>>>>>> detector' makes a decision as to whether to abort at any given
>>>>>>> call. That involves a conditional branch.
>>>>>>
>>>>>> Is it wise to even discuss these traces? You don't even have the source
>>>>>> that generated the x86 code being traced (recent posts have all
>>>>>> suspiciously omitted the key function), and you certainly don't have the
>>>>>> software that does the tracing and generates the output.
>>>>>>
>>>>>> Remember when "halting" was defined by what the code would do if a line
>>>>>> in H was commented out? That's a measure of the sort of thing that
>>>>>> could be going on here. And another time, Halts(P, I) was replaced by
>>>>>> an "emulator" that just called P(I). There is, right now, simply no way
>>>>>> to know what sort of skulduggery is gong on.
>>>>>
>>>>> I suspect it might be headed toward some hack whereby the H(P, P) call
>>>>> inside H_Hat (where P = H_Hat) returns a different value from H(H_Hat,
>>>>> H_Hat)
>>>>> in the main function.
>>>>>
>>>>> Peter will then not accept that it is invalid for different calls
>>>>> to H to yield different values on exactly the same inputs.
>>>>
>>>> We've previously covered that one and PO agreed that all calls to H with
>>>> the same parameters must give the same result.
>>>
>>> Except infinitely recursive calls that are aborted and thus do not
>>> return any result at all.
>>
>> That's not really an exception to anything, since infinitely recursive
>> calls which are not aborted also do not return any result at all; but
>> it's good to see you repeat an acknowledgement that an aborted execution
>> does not return a result.
>>
>
> Until my discovery in 2016 I don't think it ever occurred to anyone that
> the conventional halting problem counter-examples are inherently
> infinitely recursive, thus decidable on this basis.
That is false; the examples are only infinitely recursive if Halts is
written in such a way that it calls or otherwise direcly executes P(I):
bool Halts(Obj P, Obj I)
{
Execute(P, I);
return true; // if we got here, it halted!
}
The proofs make no such assumptions: the idea is that Halts is any
function whatsoever. It is not necessarily the above function.
Now I studied this as an undergrad decades ago, and I remember that one
of the first things I read about the halting problem included the
argument along these lines: if the halting decider simply executes the
code, it will run into infinite regress. The line of argumentation was
that the difficulty of deciding deciding halting in the general case is
equivalent to running the program, but doing so runs into non-halting:
the decider will not terminate due to infinite regress.
You discovered this in 2016, before anyone else?
Poppycock and fiddlesticks!
--
TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-12-10 20:53 -0600 |
| Subject | Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) |
| Message-ID | <zOudnQZ1CeaPQk_CnZ2dnUU7-fHNnZ2d@giganews.com> |
| In reply to | #2196 |
On 12/10/2020 8:06 PM, Mike Terry wrote:
> On 11/12/2020 00:58, olcott wrote:
>> On 12/10/2020 6:49 PM, Mike Terry wrote:
>>> On 10/12/2020 22:28, Kaz Kylheku wrote:
>>>> On 2020-12-10, Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>>>>> André G. Isaak <agisaak@gm.invalid> writes:
>>>>> <cut the dump of a "trace" of something>
>>>>>
>>>>>> The problem is that there *are* conditional branches between the
>>>>>> above
>>>>>> calls. You just don't show them. There must be because your 'halt
>>>>>> detector' makes a decision as to whether to abort at any given
>>>>>> call. That involves a conditional branch.
>>>>>
>>>>> Is it wise to even discuss these traces? You don't even have the
>>>>> source
>>>>> that generated the x86 code being traced (recent posts have all
>>>>> suspiciously omitted the key function), and you certainly don't have
>>>>> the
>>>>> software that does the tracing and generates the output.
>>>>>
>>>>> Remember when "halting" was defined by what the code would do if a
>>>>> line
>>>>> in H was commented out? That's a measure of the sort of thing that
>>>>> could be going on here. And another time, Halts(P, I) was replaced by
>>>>> an "emulator" that just called P(I). There is, right now, simply no
>>>>> way
>>>>> to know what sort of skulduggery is gong on.
>>>>
>>>> I suspect it might be headed toward some hack whereby the H(P, P) call
>>>> inside H_Hat (where P = H_Hat) returns a different value from
>>>> H(H_Hat, H_Hat)
>>>> in the main function.
>>>>
>>>> Peter will then not accept that it is invalid for different calls
>>>> to H to yield different values on exactly the same inputs.
>>>
>>> We've previously covered that one and PO agreed that all calls to H
>>> with the same parameters must give the same result.
>>
>> Except infinitely recursive calls that are aborted and thus do not
>> return any result at all.
>>
>
> One big problem here is that your abortion logic identifies examples
> that are actually halting, and aborts them. Your test is unsound, and
> you STILL have not provided any proof that it is sound.
>
> Hey, I've just realised that I too have refute Linz! How's about this
> for a global recursion detector:
>
> 1) Examine instructions being executed and check for instruction
> 0x68.
> 2) When detected, abort and print message "The PRIOR Instruction
> Specifies Infinite Recursion: Simulation Stopped"
>
> When run for H_Hat(H_Hat) it detects infinite recursion and aborts it.
> When run for H(H_Hat,H_Hat) it also detects infinite recursion and
> aborts it. Hmm, come to think of it that's no good after all - H is not
> supposed to have infinite recursion! But this is exactly equivalent to
> what you are doing, IIUC.
>
> [Except of course, my test for infinite recursion is different to yours,
> but, just like you I will just obstinately claim it is correct without
> offering any proof.]
>
> So, what's the differenc in what you're doing? [Serious question. I'm
> actually curious... There are two separate problems for you to address
> here: (a) My/your H would seem to be infinitely recursive (as reported
> by the global recursion detector) which is against the rules for H. (b)
> Are you happy that I've REFUTED Linz here? (If so, I have to say that
> was rather easy!)]
>
>
> Mike.
>
Whenever any computation meets this 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.
and applies this criteria as soon as it is met:
Every time that the same function is called from the same machine
address a second time without any control flow instructions in-between
is a case of infinite recursion.
Then from the global perspective where nothing is hidden from the halt
decider's view then not-halting is correctly decided on this computation:
Actual debug trace of global Halts() deciding halting on main()
Input to Microsoft C compiler, output is from generated COFF object
file. Execution trace is from an x86 emulator.
#define HALT __asm hlt
void H_Hat(u32 P)
{
u32 Input_Halts = DebugTrace(P, P);
if (Input_Halts)
HERE: goto HERE;
else
HALT
}
int main()
{
H_Hat((u32)H_Hat);
HALT;
}
_H_Hat()
[0000051c](01) 55 push ebp
[0000051d](02) 8bec mov ebp,esp
[0000051f](01) 51 push ecx
[00000520](03) 8b4508 mov eax,[ebp+08]
[00000523](01) 50 push eax
[00000524](03) 8b4d08 mov ecx,[ebp+08]
[00000527](01) 51 push ecx
[00000528](05) e83ffeffff call 0000036c
[0000052d](03) 83c408 add esp,+08
[00000530](03) 8945fc mov [ebp-04],eax
[00000533](04) 837dfc00 cmp dword [ebp-04],+00
[00000537](02) 7404 jz 0000053d
[00000539](02) ebfe jmp 00000539
[0000053b](02) eb01 jmp 0000053e
[0000053d](01) f4 hlt
[0000053e](02) 8be5 mov esp,ebp
[00000540](01) 5d pop ebp
[00000541](01) c3 ret
_main()
[0000054c](01) 55 push ebp
[0000054d](02) 8bec mov ebp,esp
[0000054f](05) 681c050000 push 0000051c
[00000554](05) e8c3ffffff call 0000051c
[00000559](03) 83c404 add esp,+04
[0000055c](01) f4 hlt
[0000055d](01) 5d pop ebp
[0000055e](01) c3 ret
Output_Debug_Trace() Trace_List.size(19)
[0000054c](01) 55 push ebp
[0000054d](02) 8bec mov ebp,esp
[0000054f](05) 681c050000 push 0000051c
[00000554](05) e8c3ffffff call 0000051c ----CALL [0000051c]
[0000051c](01) 55 push ebp
[0000051d](02) 8bec mov ebp,esp
[0000051f](01) 51 push ecx
[00000520](03) 8b4508 mov eax,[ebp+08]
[00000523](01) 50 push eax
[00000524](03) 8b4d08 mov ecx,[ebp+08]
[00000527](01) 51 push ecx
[00000528](05) e83ffeffff call 0000036c ----CALL [0000036c]
[0000051c](01) 55 push ebp
[0000051d](02) 8bec mov ebp,esp
[0000051f](01) 51 push ecx
[00000520](03) 8b4508 mov eax,[ebp+08]
[00000523](01) 50 push eax
[00000524](03) 8b4d08 mov ecx,[ebp+08]
[00000527](01) 51 push ecx
[00000528](05) e83ffeffff call 0000036c ----CALL [0000036c]
The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
Every time that the same function is called from the same machine
address a second time without any control flow instructions in-between
is a case of infinite recursion.
This is shown at execution trace lines 12-20 above.
You can't point out any mistakes or inconsistencies because there are
none: The criteria was precisely and consistently applied as specified.
When we allow a global halt decider to see everything it correctly
decides halting at an earlier step than when we do not allow the halt
decider to see everything.
--
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-10 19:18 -0600 |
| Subject | Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct) |
| Message-ID | <-7WdnWZBCsNHVU_CnZ2dnUU7-b2dnZ2d@giganews.com> |
| In reply to | #2172 |
On 12/10/2020 6:55 PM, Kaz Kylheku wrote: > On 2020-12-11, Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote: >> On 10/12/2020 22:28, Kaz Kylheku wrote: >>> Peter will then not accept that it is invalid for different calls >>> to H to yield different values on exactly the same inputs. >> >> We've previously covered that one and PO agreed that all calls to H with >> the same parameters must give the same result. > > And since PO has never demonstrated severe lapses of memory, that one is safe! > Yes I said this years ago before I wrote my halt decider that prevents infinitely recursive calls to Halts() from ever returning any value. -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 7 of 21 — ← Prev page 1 … 5 6 [7] 8 9 … 21 Next page →
Back to top | Article view | comp.software-eng
csiph-web