Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.software-eng > #1940 > unrolled thread

Re: Happy Thanksgiving to all

Started byolcott <NoOne@NoWhere.com>
First post2020-11-27 13:20 -0600
Last post2020-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.


Contents

  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 6 of 21 — ← Prev page 1 … 4 5 [6] 7 8 … 21  Next page →


#2035 — Re: Refuting the Peter Linz HP Proof (Ben is proven wrong by the actual facts)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-02 21:45 +0000
SubjectRe: Refuting the Peter Linz HP Proof (Ben is proven wrong by the actual facts)
Message-ID<20201202130444.97@kylheku.com>
In reply to#2032
["Followup-To:" header set to comp.theory.]
On 2020-12-02, olcott <NoOne@NoWhere.com> wrote:
> On 12/2/2020 2:11 PM, Richard Damon wrote:
>> On 12/2/20 2:12 PM, olcott wrote:
>>> On 12/2/2020 12:42 PM, Richard Damon wrote:
>> 
>>>> Which means your H_Hat isn't the equivalent of Linz H_Hat, as DebugTrace
>>>> is nothing like H in Linz.
>>>>
>>>
>>> You keep (intentionally?) forgetting that the ⊢* (wildcard) state
>>> transitions explicitly specify that the code can be any damn thing that
>>> correctly decides halting on its inputs:
>>>
>>>      The input to H will be the description (encoded in some form)
>>>      of M, say WM, as well as the input w. The requirement is then
>>>      that, given any (WM, w), the Turing machine H will halt with
>>>      either a yes or no answer.
>>>
>>>      H.q0 wMw ⊢* H.yes   if M applied to w halts, and
>>>      H.q0 wMw ⊢* H.no    if M applied to w [would] not halt.
>>>      (Linz 1990:318)
>>>
>>> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>>> Lexington/Toronto: D. C. Heath and Company.
>>>
>>>
>> 
>> BUT it MUST end up at H.no or H.yes at the end, or it fails to meet the
>> requirements. 'Aborting' the calling machine is a failure to reach one
>> of those two states.
>> 
>> That is a FATAL flaw in your 'equivalence'. You don't give the answer.
>> 
>> Yes, you can do whatever computation you want on the way to get there,
>> but you MUST get to one of the two output states of H, and when you get
>> to those states, H^ will then get the answer and proceed.
>> 
>
> This <is> a "no" (would not halt) at the operating system level:
> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:

It's possible to develop a test case which terminates and yet which
coaxes your machine into hitting the above situation.

I believe you have successfully articulated a known and obvious flaw in
the pseudo-code illustrations that are used in halting proof sketches
for teaching.

A program of the form

  Program(P)
  {
     if (Halts(P, P))
        Loop { }
     else
        return;
  }

does suffer from trivial runaway recursion, if:

- the Halts function simply calls P(P); and

- Halts is invoked at the top-level as Halts(Program, Program).

This allows Halts to, instead of directly calling P(P), to execute P(P)
with a stepwise monitor that detects the trivial recursion, such
as using the criterion that no conditional branch instructions are
being execued in between the unconditional among a couple of functions.

The simplified exmaples used in textbooks have teaching value.
It is much more difficult to understand halting through the details of
Turing's tape machines, compared to the illustrative pseudo-code in
a higher level language.

But any bright undergraduate student can see from those pseudo-code
examples how the technique generalizes, and how the Program can be
manipulated to thwart the monitored-execution tactics.

For instance:

  Program(P)
  {
     if (ComplicatedComputation(P))
        Dummy_Function_Foo();
     else
        Dummy_Function_Bar();

     if (Halts(P, P))
        Loop { }
     else
        return;
  }

the runaway recursion is still there, but now there are many
instructions in the code path, including conditional ones.
The trivial recursion detector will not work.

The underlying problem is that if the Halts function executes P, either
directly or through a controlled virtual machine (it doesn't matter), it
exposes itself to the possibility of non-termination.

If P(P) fails to terminate, and does so in any manner that the virtual
machine does not handle, then Halts will fail to terminate, and in so
doing, it will fail to decide. So that is to say, actually executing the
to-be-analyzed code is extremely risky. It is only useful for catching
certain cases that are known to occur within a bounded number of
instructions.

The technique you are using is only good for showing that the strawman
cases used in the proof sketches have some flaws, and those examples
cannot be taken literally as the basis for the halting theorem.

But that is already obvious; you've put a lot of effort into
not discovering anything new.

(If you don't believe me, why don't you write up what you have so far
and try to get it published: cite some papers about Halting which use
pseudo-code examples and argue about how those perform trivial recursion
which can be detected.)

-- 
TXR Programming Language: http://nongnu.org/txr
Music DIY Mailing List:  http://www.kylheku.com/diy
ADA MP-1 Mailing List:   http://www.kylheku.com/mp1

[toc] | [prev] | [next] | [standalone]


#2037 — Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-02 19:27 -0600
SubjectRe: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)
Message-ID<Fs6dnaCqptGKolXCnZ2dnUU7-SnNnZ2d@giganews.com>
In reply to#2035
On 12/2/2020 7:22 PM, Kaz Kylheku wrote:
> On 2020-12-02, olcott <NoOne@NoWhere.com> wrote:
>> On 12/2/2020 3:45 PM, Kaz Kylheku wrote:
>>> But that is already obvious; you've put a lot of effort into
>>> not discovering anything new.
>>>
>>
>> Please cite sources for this claim.
>>
>> You are the very first one that did not simply claim that I am incorrect
>> on the basis of either a flat out lie or woeful ignorance.
> 
> I believe you are not incorrect about the claim that certain code
> templates used to explain halting do through using cases that feature
> trivial recursion, which could be detected.
> 
> Obviously if Halts(P, P) just calls P(P), and then the first thing P(P)
> does is call Halts(P, P) to interrogate it for its return value,
> then we have trivial runaway recursion, and it's obvious that instead
> of running P(P), Halts could carefully step it to detect that recursion.
>

So then I have correctly refuted the Linz template.

> Proofs of the halting theorem which use those code patterns, in order to
> be rigorous, require additional arguments to show that for any given
> proposed halting decider, the template pattern of embedding that decider
> into a trick program can be "seasoned to taste" in order to thwart that
> decider.
> 
> Without that, they at best just informative literature that does a good
> job of introducing halting; "proof sketches" as I called them.
> 
>> Your claim is that I am correct, yet this is not of great significance.
> 
> Well, yes. A programmer recognizes obvious recursion ... applause?
> 
>> I will not accept that my work is of inconsequential significance until
>> I see a specific citation that can be validated.
> 
> The thing to do would be to search for published articles or books
> on the halting problem, compile a list of them and see if they are going
> wrong in the above way.

So then you have no such citation. You are merely going by how obvious 
it is after the fact of my proof.

> Then you may be able to publish an article somewhere about "pitfalls in
> explaining the Halting Problem" or something.
> 
> You could refer to your simulation work to actually show the recursion
> detector in practice, though that doesn't seem necessary. Informal
> arguments that such a thing is possible are readily believable.
> 
> Shrug.
> 
> If you're eager to get your "name out there" somehow, do it in any way
> you can.
> 



-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2050 — Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-03 18:18 +0000
SubjectRe: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)
Message-ID<20201203101313.803@kylheku.com>
In reply to#2037
On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
> On 12/2/2020 7:22 PM, Kaz Kylheku wrote:
>> The thing to do would be to search for published articles or books
>> on the halting problem, compile a list of them and see if they are going
>> wrong in the above way.
>
> So then you have no such citation. You are merely going by how obvious 
> it is after the fact of my proof.

If you want to publish an article which exposes issues with the manner
of presentation of the halting problem in various literature, the onus
is on you to hunt down the specific pieces literature that you wish to
target, read all of them, and determine what issues are present in which
piece.

-- 
TXR Programming Language: http://nongnu.org/txr
Music DIY Mailing List:  http://www.kylheku.com/diy
ADA MP-1 Mailing List:   http://www.kylheku.com/mp1

[toc] | [prev] | [next] | [standalone]


#2038 — Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-02 19:50 -0600
SubjectRe: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)
Message-ID<qpednRErqvjF2VXCnZ2dnUU7-LvNnZ2d@giganews.com>
In reply to#2035
On 12/2/2020 7:42 PM, Malcolm McLean wrote:
> On Thursday, 3 December 2020 at 01:23:04 UTC, Kaz Kylheku wrote:
>>
>> The thing to do would be to search for published articles or books
>> on the halting problem, compile a list of them and see if they are going
>> wrong in the above way.
>>
> The "halting problem" is called a "problem", but it isn't an open problem
> in computer science that computer scientists work on. It was known
> that it is impossible to determine halting before electronic computers
> became available.
> 

I did correctly refute the computational equivalent of the Linz Ĥ, and 
every pseudo-code cuonter-example of the halting problem proof.

I have been proving that for two weeks and Kaz is the only one honest 
enough to admit it.

-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2052 — Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-03 18:32 +0000
SubjectRe: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)
Message-ID<20201203102524.181@kylheku.com>
In reply to#2038
On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
> On 12/2/2020 7:42 PM, Malcolm McLean wrote:
>> On Thursday, 3 December 2020 at 01:23:04 UTC, Kaz Kylheku wrote:
>>>
>>> The thing to do would be to search for published articles or books
>>> on the halting problem, compile a list of them and see if they are going
>>> wrong in the above way.
>>>
>> The "halting problem" is called a "problem", but it isn't an open problem
>> in computer science that computer scientists work on. It was known
>> that it is impossible to determine halting before electronic computers
>> became available.
>> 
>
> I did correctly refute the computational equivalent of the Linz Ĥ, and 
> every pseudo-code cuonter-example of the halting problem proof.
>
> I have been proving that for two weeks and Kaz is the only one honest 
> enough to admit it.

Yesterday, it was Malcom McLean. You do have a problem with memory,
don't you!

For years, you have been on a program to disprove the theorem
that halting is not decidable.

This new minor goal is different; but you presented your argumenation in
very unclear ways which don't make it clear that you've digressed into
exposing issues with the pseudo-code templates used in informal
presenations of the halting problem.

People are still conversing with you in the context of the major
program.

-- 
TXR Programming Language: http://nongnu.org/txr
Music DIY Mailing List:  http://www.kylheku.com/diy
ADA MP-1 Mailing List:   http://www.kylheku.com/mp1

[toc] | [prev] | [next] | [standalone]


#2053 — Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-03 12:35 -0600
SubjectRe: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)
Message-ID<DfadnWStpqJFslTCnZ2dnUU7-TmdnZ2d@giganews.com>
In reply to#2052
On 12/3/2020 12:32 PM, Kaz Kylheku wrote:
> On 2020-12-03, olcott <NoOne@NoWhere.com> wrote:
>> On 12/2/2020 7:42 PM, Malcolm McLean wrote:
>>> On Thursday, 3 December 2020 at 01:23:04 UTC, Kaz Kylheku wrote:
>>>>
>>>> The thing to do would be to search for published articles or books
>>>> on the halting problem, compile a list of them and see if they are going
>>>> wrong in the above way.
>>>>
>>> The "halting problem" is called a "problem", but it isn't an open problem
>>> in computer science that computer scientists work on. It was known
>>> that it is impossible to determine halting before electronic computers
>>> became available.
>>>
>>
>> I did correctly refute the computational equivalent of the Linz Ĥ, and
>> every pseudo-code cuonter-example of the halting problem proof.
>>
>> I have been proving that for two weeks and Kaz is the only one honest
>> enough to admit it.
> 
> Yesterday, it was Malcom McLean. You do have a problem with memory,
> don't you!
> 
> For years, you have been on a program to disprove the theorem
> that halting is not decidable.
> 
> This new minor goal is different; but you presented your argumenation in
> very unclear ways which don't make it clear that you've digressed into
> exposing issues with the pseudo-code templates used in informal
> presenations of the halting problem.
> 
> People are still conversing with you in the context of the major
> program.
> 

I did apparently at least correctly refute the Linz proof. That by 
itself would qualify for publication somewhere.

-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2056 — Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-03 15:47 -0600
SubjectRe: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)
Message-ID<g_2dnYEN-JJGwVTCnZ2dnUU7-f_NnZ2d@giganews.com>
In reply to#2035
On 12/3/2020 3:03 PM, Andy Walker wrote:
> On 03/12/2020 01:22, Kaz Kylheku wrote:
>> Obviously if Halts(P, P) just calls P(P), and then the first thing P(P)
>> does is call Halts(P, P) to interrogate it for its return value,
>> then we have trivial runaway recursion, and it's obvious that instead
>> of running P(P), Halts could carefully step it to detect that recursion.
> 
>      So far, so good.
> 
>> Proofs of the halting theorem which use those code patterns, in order to
>> be rigorous, require additional arguments to show that for any given
>> proposed halting decider, the template pattern of embedding that decider
>> into a trick program can be "seasoned to taste" in order to thwart that
>> decider.
> 
>      But this is too elaborate.  Assuming that "P" is what has in
> former incarnations been called "H_hat" or similar, and what
> 
>    http://www.cuboid.me.uk/anw/G12FCO/lect17.html
> 
> [near the bottom] calls "C", it is based on "Halts", and we don't get
> to change "Halts" or "P" to suit ourselves [or PO].  "P" is a copy of
> "Halts" except that exactly if "Halts" decides that "P(P)" halts,
> "P(P)" in fact loops and exactly if "Halts" decides that "P(P)" does
> not halt, it in fact does.  What different programs might do is not
> relevant.  What "P(P)" actually does is also not relevant;  the point
> is that "Halts" gets it wrong [or fails to make a decision].
> 
>      [Lecture 18 (linked from above page) and other nearby pages
> may also be of interest.]
> 
>      It doesn't matter how clever "Halts" is at spotting patterns;
> "P" does exactly the same until the point where "Halts" makes its final
> decision and then ensures that that decision is incorrect.  Even if
> "Halts" is clever enough to spot that the program under test is "P"
> and reverses its decision, the corresponding "P" will spot the same
> thing, reverse in the same way, and still cause "Halts" to give the
> wrong answer.
> 
>      If you add a "supervisor" program of some sort to detect all
> that, then that supervisor is part of a new, more powerful "Halts",
> call it "Halts+", and then the usual method generates a "P+" that
> "Halts+" gets wrong.  That "Halts+" may be able to decide "P(P)" is
> of no interest;  what matters is that it gets "P+(P+) wrong.  The
> well-known result is thus that for any purported halt decider, there
> is an easy example of a program that it fails to decide correctly.
> What that program in fact does is irrelevant;  it could go either
> way, depending on exactly how the pseudo-decider goes wrong.
> 

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.
 >
 > Every computation that does halt even when its simulation is never
 > halted is by logical necessity a halting computation.


-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2134 — Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-07 12:29 -0600
SubjectRe: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)
Message-ID<6sKdnUtrsNfz6VPCnZ2dnUU7-b3NnZ2d@giganews.com>
In reply to#2035
On 12/7/2020 12:16 PM, Anton Shepelev wrote:
> Andy Walker:
> 
>>          If you add a "supervisor" program of some sort to
>> detect all that, then that supervisor is part of a new,
>> more powerful "Halts", call it "Halts+", and then the
>> usual method generates a "P+" that "Halts+" gets wrong.
>> That "Halts+" may be able to decide "P(P)" is of no
>> interest;  what matters is that it gets "P+(P+) wrong.
>> The well-known result is thus that for any purported halt
>> decider, there is an easy example of a program that it
>> fails to decide correctly.  What that program in fact does
>> is irrelevant;  it could go either way, depending on
>> exactly how the pseudo-decider goes wrong.
> 
> That prompts an experiment: Pete Olcott provides a halt
> decider, and you provide a program that will fool it.
> 

When the halt decider is based on adapting a UTM then this UTM can 
directly see every detail of the execution of an entire hierarchy of 
UTMs executing the Turing Machine descriptions of other UTMs.

As soon as it sees that this recursion is infinite it decides not 
halting and transitions to its own final state.

-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2144 — Re: Refuting the Peter Linz HP Proof (Ben still tries to dodge the truth)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-07 20:10 -0600
SubjectRe: Refuting the Peter Linz HP Proof (Ben still tries to dodge the truth)
Message-ID<G6idnbecKIAbfVPCnZ2dnUU7-b_NnZ2d@giganews.com>
In reply to#2035
On 12/7/2020 7:55 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 12/7/2020 5:54 PM, Ben Bacarisse wrote:
>>> Anton Shepelev <anton.txt@gmail.com> writes:
>>>
>>>> Andy Walker:
>>>>
>>>>>           If you add a "supervisor" program of some sort to
>>>>> detect all that, then that supervisor is part of a new,
>>>>> more powerful "Halts", call it "Halts+", and then the
>>>>> usual method generates a "P+" that "Halts+" gets wrong.
>>>>> That "Halts+" may be able to decide "P(P)" is of no
>>>>> interest;  what matters is that it gets "P+(P+) wrong.
>>>>> The well-known result is thus that for any purported halt
>>>>> decider, there is an easy example of a program that it
>>>>> fails to decide correctly.  What that program in fact does
>>>>> is irrelevant;  it could go either way, depending on
>>>>> exactly how the pseudo-decider goes wrong.
>>>>
>>>> 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.  He has
>>> also inadvertently confirmed the facts needed to show that his response
>>> is incorrect about the confounding example I supplied!  In summary, I
>>> asked him to
>>>
>>>     Show a function F such that F(P, I) is true if, and only if, P(I) is a
>>>     finite computation and false otherwise.
>>>
>>> He replied with
>>>
>>>     bool Halts(u32 P, u32 I)
>>>     {
>>>       bool Halted  = false;
>>>       bool Aborted = false;
>>>       while (!Halted && !Aborted)
>>>       {
>>>         Halted  = DebugStep(P, I);
>>>         Aborted = Needs_To_Be_Aborted();
>>>       }
>>>       return !Aborted;
>>>     }
>>>
>>> and as I am sure everyone (including PO) expected I replied with
>>>
>>>     void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>
>>> making the the confounding example for Halts the computation
>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>> returned by the function call Halts(Confound_Halts, Confound_Halts).
>>>
>>> In the ensuing exchange he said both:
>>>
>>>     "Halts(Confound_Halts, Confound_Halts) returns false."
>>>     Message-ID: <2aidnV9e3qQaOCDCnZ2dnUU7-c3NnZ2d@giganews.com>
>>>
>>> and
>>>
>>>     "The input to Halts is only finite because..."
>>>     Message-ID: <6eSdnYuLBrIuVFzCnZ2dnUU7-cPNnZ2d@giganews.com>
>>>
>>
>> Message ID's are useless to me when I click on them my newsreader
>> thinks that I want to send an email. I need date-time-stamps.
> 
> Date: Tue, 24 Nov 2020 18:30:04 -0600
> Date: Fri, 27 Nov 2020 21:53:30 -0600
> 
> Have you thought of using a proper news reader/server?  But I don't post
> to persuade you.  As far as I can tell, nothing will persuade you.  I
> post to persuade other people that you have nothing.
> 
>> int main()
>> {
>>    Confound_Halts((u32)Confound_Halts);
>>    HALT;
>> }
>>
>> int main()
>> {
>>    Halts((u32)Confound_Halts, (u32)Confound_Halts);
>>    HALT;
>> }
>>
>> Both of the above executions are decided as infinitely recursive by
>> the following criteria:
> 
> Sorry, but I don't care about your made-up criteria.  

THIS IS THE 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.

> I asked for a
> function with well-defined behaviour which you were not able to produce.

I PROVIDED IT AND YOU IGNORED IT

> None of my objections where based on whether either or both of these
> programs were whatever you call "infinitely recursive".  Your proposed
> code failed because (according to you)
> 
> (a) Halts(Confound_Halts, Confound_Halts) returns false and,
> (b) Confound_Halts(Confound_Halts) is a finite computation.
> 
BOTH OF THE FUNCTIONS ARE INFINITE
WHEN I SAID THAT THE SECOND ONE WAS FINITE I WAS WRONG

I AM GOING TO KEEP YOU PINNED DOWN ON THIS NO MATTER WHAT ELSE YOU SAY 
ABOUT ANYTHING ELSE:

MY HALT DECIDER CORRECTLY DECIDES BOTH OF THESE
 > (a) Halts(Confound_Halts, Confound_Halts) returns false and,
 > (b) Confound_Halts(Confound_Halts) is a finite computation.


-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2151 — Re: Refuting the Peter Linz HP Proof (Ben still tries to dodge the truth)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-08 08:33 -0600
SubjectRe: Refuting the Peter Linz HP Proof (Ben still tries to dodge the truth)
Message-ID<epGdnRZrnIQiE1LCnZ2dnUU7-aHNnZ2d@giganews.com>
In reply to#2035
On 12/8/2020 4:52 AM, Malcolm McLean wrote:
> On Tuesday, 8 December 2020 at 00:19:06 UTC, olcott wrote:
>> On 12/7/2020 5:54 PM, Ben Bacarisse wrote:
>>> Anton Shepelev <anto...@gmail.com> writes:
>>>
>>>> Andy Walker:
>>>>
>>>>> If you add a "supervisor" program of some sort to
>>>>> detect all that, then that supervisor is part of a new,
>>>>> more powerful "Halts", call it "Halts+", and then the
>>>>> usual method generates a "P+" that "Halts+" gets wrong.
>>>>> That "Halts+" may be able to decide "P(P)" is of no
>>>>> interest; what matters is that it gets "P+(P+) wrong.
>>>>> The well-known result is thus that for any purported halt
>>>>> decider, there is an easy example of a program that it
>>>>> fails to decide correctly. What that program in fact does
>>>>> is irrelevant; it could go either way, depending on
>>>>> exactly how the pseudo-decider goes wrong.
>>>>
>>>> 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. He has
>>> also inadvertently confirmed the facts needed to show that his response
>>> is incorrect about the confounding example I supplied! In summary, I
>>> asked him to
>>>
>>> Show a function F such that F(P, I) is true if, and only if, P(I) is a
>>> finite computation and false otherwise.
>>>
>>> He replied with
>>>
>>> bool Halts(u32 P, u32 I)
>>> {
>>> bool Halted = false;
>>> bool Aborted = false;
>>> while (!Halted && !Aborted)
>>> {
>>> Halted = DebugStep(P, I);
>>> Aborted = Needs_To_Be_Aborted();
>>> }
>>> return !Aborted;
>>> }
>>>
>>> and as I am sure everyone (including PO) expected I replied with
>>>
>>> void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
>>>
>>> making the the confounding example for Halts the computation
>>> Confound_Halts(Confound_Halts) whose halting status is not correctly
>>> returned by the function call Halts(Confound_Halts, Confound_Halts).
>>>
>>> In the ensuing exchange he said both:
>>>
>>> "Halts(Confound_Halts, Confound_Halts) returns false."
>>> Message-ID: <2aidnV9e3qQaOCDC...@giganews.com>
>>>
>>> and
>>>
>>> "The input to Halts is only finite because..."
>>> Message-ID: <6eSdnYuLBrIuVFzC...@giganews.com>
>>>
>> Message ID's are useless to me when I click on them my newsreader thinks
>> that I want to send an email. I need date-time-stamps.
>>
>>
>> int main()
>> {
>> Confound_Halts((u32)Confound_Halts);
>> HALT;
>> }
>>
>> int main()
>> {
>> Halts((u32)Confound_Halts, (u32)Confound_Halts);
>> HALT;
>> }
>>
>> Both of the above executions are decided as infinitely recursive by the
>> following 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.
>> I posted the full execution trace proving this.
>>
> OK, so the important point here is that both of these programs are run
> under the global halt detector. They are not run natively.
> 

Yes, by doing this it is no longer possible to hide any details of the 
execution trace from the halt decider and thereby get results that 
superficially seem to be inconsistent under naive analysis.

Also on the basis of common knowledge whenever the Turing machine 
description of a machine is simulated under a UTM this is 
computationally equivalent to the direct execution of the TM.

This also applies in the case of a UTM simulating its own TMD simulating 
its own TMD. This case is computationally equivalent to recursion.

-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2162 — Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-09 12:04 -0600
SubjectRe: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)
Message-ID<bu6dnRRFqcQwjEzCnZ2dnUU7-UfNnZ2d@giganews.com>
In reply to#2035
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().

> If Halts cannot use the correct answer obtained from a magic oracle, how
> can it use the answer somehow obtained from your recursion-detecting
> virtual machine?
> 
> Halts doesn't have a problem with obtaining quality information; the main
> issue is that it can't use it.
> 


-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2166 — Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-09 22:48 -0600
SubjectRe: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)
Message-ID<BuCdnWJkOZM4NUzCnZ2dnUU7-UPNnZ2d@giganews.com>
In reply to#2162
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.

> 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.

> You'd need to then invoke your master UTM with an input of the above 
> H_Hat, H_Hat (not of main, NULL). If you don't do this, your alleged 
> 'solution' has nothing to do with Linz's proof.
> 
> André
> 

Think of this is simpler terms:
I have an x86 emulator that aborts infinite loops and infinite recursion.

-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2167 — Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)

FromMr Flibble <flibble@i42.REMOVETHISBIT.co.uk>
Date2020-12-10 12:13 +0000
SubjectRe: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)
Message-ID<ghoAH.115213$9J69.400@fx21.ams4>
In reply to#2166
On 10/12/2020 04: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.
> 
>> 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.
> 
>> You'd need to then invoke your master UTM with an input of the above H_Hat, H_Hat (not of main, NULL). If you don't do this, your alleged 'solution' has nothing to do with Linz's proof.
>>
>> André
>>
> 
> Think of this is simpler terms:
> I have an x86 emulator that aborts infinite loops and infinite recursion.

It is impossible for an x86 emulator to detect infinite recursion as any such emulator will be emulating a FINITE STACK SIZE; your emulator doesn't have infinite RAM, mate, and even if it did you still couldn't detect infinite recursion as it would require being run for an infinite amount of time.

Please GET A FUCKING CLUE AND THEN FUCK OFF.  YOUR SPAM IS GETTING VERY TEDIOUS NOW.

/Flibble

-- 
😎

[toc] | [prev] | [next] | [standalone]


#2168 — Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)

FromMr Flibble <flibble@i42.REMOVETHISBIT.co.uk>
Date2020-12-10 12:21 +0000
SubjectRe: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)
Message-ID<spoAH.91098$HFx7.66417@fx43.ams4>
In reply to#2167
On 10/12/2020 12:13, Mr Flibble wrote:
> On 10/12/2020 04: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.
>>
>>> 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.
>>
>>> You'd need to then invoke your master UTM with an input of the above H_Hat, H_Hat (not of main, NULL). If you don't do this, your alleged 'solution' has nothing to do with Linz's proof.
>>>
>>> André
>>>
>>
>> Think of this is simpler terms:
>> I have an x86 emulator that aborts infinite loops and infinite recursion.
> 
> It is impossible for an x86 emulator to detect infinite recursion as any such emulator will be emulating a FINITE STACK SIZE; your emulator doesn't have infinite RAM, mate, and even if it did you still couldn't detect infinite recursion as it would require being run for an infinite amount of time.
> 
> Please GET A FUCKING CLUE AND THEN FUCK OFF.  YOUR SPAM IS GETTING VERY TEDIOUS NOW.

To be clear: you also need to be able to detect "infinite recursion" which DOES HAVE conditionals being called inbetween the same function being called from the same machine address.

YOU HAVE REFUTED *NOTHING* JUST WASTED A LOT OF YOUR TIME AND THE TIME OF OTHERS.

/Flibble

-- 
😎

[toc] | [prev] | [next] | [standalone]


#2170 — Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-10 08:22 -0600
SubjectRe: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)
Message-ID<YfednTpYwK2Xsk_CnZ2dnUU7-WGdnZ2d@giganews.com>
In reply to#2168
On 12/10/2020 6:21 AM, Mr Flibble wrote:
> On 10/12/2020 12:13, Mr Flibble wrote:
>> On 10/12/2020 04: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.
>>>
>>>> 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.
>>>
>>>> You'd need to then invoke your master UTM with an input of the above 
>>>> H_Hat, H_Hat (not of main, NULL). If you don't do this, your alleged 
>>>> 'solution' has nothing to do with Linz's proof.
>>>>
>>>> André
>>>>
>>>
>>> Think of this is simpler terms:
>>> I have an x86 emulator that aborts infinite loops and infinite 
>>> recursion.
>>
>> It is impossible for an x86 emulator to detect infinite recursion as 
>> any such emulator will be emulating a FINITE STACK SIZE; your emulator 
>> doesn't have infinite RAM, mate, and even if it did you still couldn't 
>> detect infinite recursion as it would require being run for an 
>> infinite amount of time.
>>
>> Please GET A FUCKING CLUE AND THEN FUCK OFF.  YOUR SPAM IS GETTING 
>> VERY TEDIOUS NOW.
> 
> To be clear: you also need to be able to detect "infinite recursion" 
> which DOES HAVE conditionals being called inbetween the same function 
> being called from the same machine address.
> 
> YOU HAVE REFUTED *NOTHING* JUST WASTED A LOT OF YOUR TIME AND THE TIME 
> OF OTHERS.
> 
> /Flibble
> 

To solve the halting problem I would have to do this. To refute (Linz, 
Sipser and Kozen} I do not have to do this.

-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2169 — Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-10 08:20 -0600
SubjectRe: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)
Message-ID<YfednTtYwK0ps0_CnZ2dnUU7-WHNnZ2d@giganews.com>
In reply to#2167
On 12/10/2020 6:13 AM, Mr Flibble wrote:
> On 10/12/2020 04: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.
>>
>>> 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.
>>
>>> You'd need to then invoke your master UTM with an input of the above 
>>> H_Hat, H_Hat (not of main, NULL). If you don't do this, your alleged 
>>> 'solution' has nothing to do with Linz's proof.
>>>
>>> André
>>>
>>
>> Think of this is simpler terms:
>> I have an x86 emulator that aborts infinite loops and infinite recursion.
> 
> It is impossible for an x86 emulator to detect infinite recursion as any 
> such emulator will be emulating a FINITE STACK SIZE; your emulator 
> doesn't have infinite RAM, mate, and even if it did you still couldn't 
> detect infinite recursion as it would require being run for an infinite 
> amount of time.
> 
> Please GET A FUCKING CLUE AND THEN FUCK OFF.  YOUR SPAM IS GETTING VERY 
> TEDIOUS NOW.
> 
> /Flibble
> 

The UTM equivalent computation of the computation that I am modeling in 
the x86 language is literally infinite recursion.

-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2172 — Re: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)

Fromolcott <NoOne@NoWhere.com>
Date2020-12-10 08:44 -0600
SubjectRe: Refuting the Peter Linz HP Proof (Kaz agrees that I am correct)
Message-ID<k-mdnbejZqXEqU_CnZ2dnUU7-enNnZ2d@giganews.com>
In reply to#2166
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.

>>> You'd need to then invoke your master UTM with an input of the above 
>>> H_Hat, H_Hat (not of main, NULL). If you don't do this, your alleged 
>>> 'solution' has nothing to do with Linz's proof.
>>>
>>> André
>>>
>>
>> Think of this is simpler terms:
>> I have an x86 emulator that aborts infinite loops and infinite recursion.
> 
> Which *claims* to do this. You have not proven that it actually does 
> this reliably, 

Sure I have immediately above you just didn't bother to pay attention or 
the x86 language is over your head.

> nor have you shown that this has any relevance to Linz 
> given that you are not deriving your H_Hat from your halt decider 
> correctly.
> 
> André
> 


-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2179 — Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-10 15:02 -0600
SubjectRe: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ]
Message-ID<76GdnQTUwcFuEU_CnZ2dnUU7-bXNnZ2d@giganews.com>
In reply to#2172
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.


-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2180 — Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ]

FromMr Flibble <flibble@i42.REMOVETHISBIT.co.uk>
Date2020-12-10 21:19 +0000
SubjectRe: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ]
Message-ID<mhwAH.251259$YVH9.206866@fx06.ams4>
In reply to#2179
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

-- 
😎

[toc] | [prev] | [next] | [standalone]


#2181 — Re: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-10 15:53 -0600
SubjectRe: Refuting the Peter Linz HP Proof [ Most important words that I have ever said on the HP ]
Message-ID<XIqdnQbh5p1WBU_CnZ2dnUU7-bOdnZ2d@giganews.com>
In reply to#2180
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.

-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


Page 6 of 21 — ← Prev page 1 … 4 5 [6] 7 8 … 21  Next page →

Back to top | Article view | comp.software-eng


csiph-web