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


#2107 — Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-05 15:21 -0600
SubjectRe: Renaming DebugTrace() to H or Halts[ Effective Presentation ]
Message-ID<WoidnWwtnf5fZFbCnZ2dnUU7-fHNnZ2d@giganews.com>
In reply to#2106
On 12/5/2020 3:11 PM, Mr Flibble wrote:
> On 05/12/2020 21:07, olcott wrote:
>> On 12/5/2020 2:59 PM, Richard Damon wrote:
>>> On 12/5/20 3:15 PM, olcott wrote:
>>>> On 12/5/2020 2:05 PM, Richard Damon wrote:
>>>>> On 12/5/20 2:24 PM, olcott wrote:
>>>>>> On 12/5/2020 1:16 PM, Richard Damon wrote:
>>>>>
>>>>>>> NO. To Test, you need to run the code AS A TURING MACHINE, NO OUTER
>>>>>>> HALT
>>>>>>> DECIDER.
>>>>>> All the Turing Machine descriptions are simulated in a UTM that 
>>>>>> has been
>>>>>> adapted to become a halt decider, thus H_Hat(H_Hat) is directly 
>>>>>> decided
>>>>>> to be infinitely recursive in this machine.
>>>>> For someone who complains that other don't read what you say, you 
>>>>> don't
>>>>> read what others say very well do you.
>>>>>
>>>>> The ultimate test of the Halt Deciders decision is to actually run the
>>>>> Turing Machine, That means run it in a UTM that has NOT been 
>>>>> adapted to
>>>>> become a halt decider. PERIOD.
>>>>
>>>> H_Hat(H_Hat) would never halt under those circumstances and you already
>>>> know this yet continue to endlessly harp on and on...
>>>>
>>>
>>> Why? Does the Halt Detector not answer in finite time? 
>>
>> You just told me to remove the halt detector so I did.
>> Simulate returns true if and only if its input ever halts.
>>

#define HALT __asm hlt

>> void H_Hat(u32 P)
>> {
>>    u32 Input_Halts = Simulate(P, P);
>>    if (Input_Halts)
>>      HERE: goto HERE;
>>    else
>>      HALT
>> }
>>
>> int main()
>> {
>>    Simulate((u32)H_Hat, (u32)H_Hat);
>>    HALT;
>> }
> 
> What programming language is that meant to be? It certainly isn't legal 
> C or C++.

See the #define that I have added. It is the C input to the Microsoft C 
compiler COFF output.

> You only have to do ONE THING and that is provide the compilable source 
> code, on github, of what you claim implements your refutation of the 
> halting problem.  Until that happens you've got nothing.
> 
> /Flibble
> 

It may have seemed like I have nothing before you understood that the 
above is valid C input and this execution trace is of valid COFF file 
output.

Actual debug trace of H() deciding halting on H_Hat()

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)   EMU_Level(0) 55                  push ebp
[00000611](02)   EMU_Level(0) 8bec                mov ebp,esp
[00000613](05)   EMU_Level(0) 68e0050000          push 000005e0
[00000618](05)   EMU_Level(0) 68e0050000          push 000005e0
[0000061d](05)   EMU_Level(0) e84efdffff          call 00000370 
----CALL [00000370]
[000005e0](01)   EMU_Level(1) 55                  push ebp
[000005e1](02)   EMU_Level(1) 8bec                mov ebp,esp
[000005e3](01)   EMU_Level(1) 51                  push ecx
[000005e4](03)   EMU_Level(1) 8b4508              mov eax,[ebp+08]
[000005e7](01)   EMU_Level(1) 50                  push eax
[000005e8](03)   EMU_Level(1) 8b4d08              mov ecx,[ebp+08]
[000005eb](01)   EMU_Level(1) 51                  push ecx
[000005ec](05)   EMU_Level(1) e87ffdffff          call 00000370 
----CALL [00000370]
[000005e0](01)   EMU_Level(2) 55                  push ebp
[000005e1](02)   EMU_Level(2) 8bec                mov ebp,esp
[000005e3](01)   EMU_Level(2) 51                  push ecx
[000005e4](03)   EMU_Level(2) 8b4508              mov eax,[ebp+08]
[000005e7](01)   EMU_Level(2) 50                  push eax
[000005e8](03)   EMU_Level(2) 8b4d08              mov ecx,[ebp+08]
[000005eb](01)   EMU_Level(2) 51                  push ecx
[000005ec](05)   EMU_Level(2) e87ffdffff          call 00000370 
----CALL [00000370]
The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
Number of Instructions Executed(2777)


-- 
Copyright 2020 Pete Olcott

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

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


#2108 — Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-05 16:23 -0600
SubjectRe: Renaming DebugTrace() to H or Halts[ Effective Presentation ]
Message-ID<OOCdnbuYRO3HlVHCnZ2dnUU7-IfNnZ2d@giganews.com>
In reply to#2106
On 12/5/2020 3:42 PM, Richard Damon wrote:
> On 12/5/20 4:24 PM, olcott wrote:
>> On 12/5/2020 3:20 PM, Richard Damon wrote:
>>> On 12/5/20 4:04 PM, olcott wrote:
>>>> On 12/5/2020 2:59 PM, Richard Damon wrote:
>>>>> On 12/5/20 3:15 PM, olcott wrote:
>>>>>> On 12/5/2020 2:05 PM, Richard Damon wrote:
>>>>>>> On 12/5/20 2:24 PM, olcott wrote:
>>>>>>>> On 12/5/2020 1:16 PM, Richard Damon wrote:
>>>>>>>
>>>>>>>>> NO. To Test, you need to run the code AS A TURING MACHINE, NO OUTER
>>>>>>>>> HALT
>>>>>>>>> DECIDER.
>>>>>>>> All the Turing Machine descriptions are simulated in a UTM that has
>>>>>>>> been
>>>>>>>> adapted to become a halt decider, thus H_Hat(H_Hat) is directly
>>>>>>>> decided
>>>>>>>> to be infinitely recursive in this machine.
>>>>>>> For someone who complains that other don't read what you say, you
>>>>>>> don't
>>>>>>> read what others say very well do you.
>>>>>>>
>>>>>>> The ultimate test of the Halt Deciders decision is to actually run
>>>>>>> the
>>>>>>> Turing Machine, That means run it in a UTM that has NOT been
>>>>>>> adapted to
>>>>>>> become a halt decider. PERIOD.
>>>>>>
>>>>>> H_Hat(H_Hat) would never halt under those circumstances and you
>>>>>> already
>>>>>> know this yet continue to endlessly harp on and on...
>>>>>>
>>>>>
>>>>> Why? Does the Halt Detector not answer in finite time?
>>>>
>>>> You just told me to remove the halt detector so I did.
>>>>
>>>
>>> I told you to remove the outer wrapping halt detector, but leave the
>>> Halts function (or what ever it is called) intact.
>>>
>>> Note, if this is not possible, you have a computation equavlence issue.
>>
>> The fact that this is inherently infinitely recursive when executed with
>> itself as input must be over your head.
>>
>> void H_Hat(u32 P)
>> {
>>    u32 Input_Halts = Whatever_Simulator(P, P);
>>    if (Input_Halts)
>>      HERE: goto HERE;
>>    else
>>      HALT
>> }
>>
> 
> H_Hat does NOT call 'Whatever_Simulate', it calls the halt decider.
> 
> H_Hat for the test, needs to be run as a basic Turing Machine, i.e. its
> own execution (at the top level machine) is not affeted by any external
> influence like a Halt Decider.
> 
> IF your program can not create such an environment, you have an
> impropper computational equivalenct for the Linz proof. PERIOD.
> 
> I am quite sure that this is your case, and your obstinace in this is
> because you know that if you did things by the requirements, your sham
> would be immediately exposed.
> 
> Last chance, what is the error in this trace, operationg conditions,
> Main is not under the influence of an form of global halt decider, H_Hat
> calls a working halt decider.

THERE IS NO WAY AROUND THIS
THERE IS NO WAY AROUND THIS
THERE IS NO WAY AROUND THIS

Failing to find an error in this because it is correct
proves that H_Hat(H_Hat) is inherently infinitely recursive:

Actual debug trace of Halts() deciding halting on main()

Input to Microsoft C compiler:

#define HALT __asm hlt

void H_Hat(u32 P)
{
   u32 Input_Halts = Halts(P, P);
   if (Input_Halts)
     HERE: goto HERE;
   else
     HALT
}

int main()
{
   H_Hat((u32)H_Hat);
   HALT;
}

COFF output from Microsoft C Compiler:

_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)  e8c3ffffff          call 000005e0
[0000061d](03)  83c404              add esp,+04
[00000620](01)  f4                  hlt
[00000621](01)  5d                  pop ebp
[00000622](01)  c3                  ret

Execution trace by x86utm operating system:

Output_Debug_Trace() Trace_List.size(19)
[00000610](01)   EMU_Level(0) 55                  push ebp
[00000611](02)   EMU_Level(0) 8bec                mov ebp,esp
[00000613](05)   EMU_Level(0) 68e0050000          push 000005e0
[00000618](05)   EMU_Level(0) e8c3ffffff          call 000005e0 
----CALL [000005e0]
[000005e0](01)   EMU_Level(0) 55                  push ebp
[000005e1](02)   EMU_Level(0) 8bec                mov ebp,esp
[000005e3](01)   EMU_Level(0) 51                  push ecx
[000005e4](03)   EMU_Level(0) 8b4508              mov eax,[ebp+08]
[000005e7](01)   EMU_Level(0) 50                  push eax
[000005e8](03)   EMU_Level(0) 8b4d08              mov ecx,[ebp+08]
[000005eb](01)   EMU_Level(0) 51                  push ecx
[000005ec](05)   EMU_Level(0) e87ffdffff          call 00000370 
----CALL [00000370]
[000005e0](01)   EMU_Level(1) 55                  push ebp
[000005e1](02)   EMU_Level(1) 8bec                mov ebp,esp
[000005e3](01)   EMU_Level(1) 51                  push ecx
[000005e4](03)   EMU_Level(1) 8b4508              mov eax,[ebp+08]
[000005e7](01)   EMU_Level(1) 50                  push eax
[000005e8](03)   EMU_Level(1) 8b4d08              mov ecx,[ebp+08]
[000005eb](01)   EMU_Level(1) 51                  push ecx
[000005ec](05)   EMU_Level(1) e87ffdffff          call 00000370 
----CALL [00000370]
The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:




-- 
Copyright 2020 Pete Olcott

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

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


#2109 — Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-05 16:25 -0600
SubjectRe: Renaming DebugTrace() to H or Halts[ Effective Presentation ]
Message-ID<OOCdnbqYRO1tlVHCnZ2dnUU7-IednZ2d@giganews.com>
In reply to#2106
On 12/5/2020 3:45 PM, Richard Damon wrote:
> On 12/5/20 4:25 PM, olcott wrote:
> 
>>
>> The fact that this is inherently infinitely recursive when executed with
>> itself as input must be over your head.
>>
>> void H_Hat(u32 P)
>> {
>>    u32 Input_Halts = Whatever_Simulator(P, P);
>>    if (Input_Halts)
>>      HERE: goto HERE;
>>    else
>>      HALT
>> }
>>
>>
> 
> No, I admit that the above program will be infinitely recurcive, but the
> program is mis-named, as that is NOT the H_Hat of Linz, that uses a Halt
> Detector, not a simulator. (You are great at using bad terminology)
> 
> The fact that you don't understand that seems amazing.
> 

It is is inherently infinitely recursive by any simulator
then it is inherently infinitely recursive by a simulator
that has halt deciding features.

-- 
Copyright 2020 Pete Olcott

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

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


#2116 — Re: Renaming DebugTrace() to H or Halts[ Effective Presentation ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-05 22:40 -0600
SubjectRe: Renaming DebugTrace() to H or Halts[ Effective Presentation ]
Message-ID<8tGdnSuH2cE0_VHCnZ2dnUU7-UfNnZ2d@giganews.com>
In reply to#2109
On 12/5/2020 10:15 PM, Mike Terry wrote:
> On 06/12/2020 02:12, Richard Damon wrote:
>> On 12/5/20 8:49 PM, olcott wrote:
>>> On 12/5/2020 7:44 PM, Jeff Barnett wrote:
>>>> On 12/5/2020 4:35 PM, Richard Damon wrote:
>>>>> On 12/5/20 5:25 PM, olcott wrote:
>>>>>> On 12/5/2020 3:45 PM, Richard Damon wrote:
>>>>>>> On 12/5/20 4:25 PM, olcott wrote:
>>>>>>>
>>>>>>>>
>>>>>>>> The fact that this is inherently infinitely recursive when
>>>>>>>> executed with
>>>>>>>> itself as input must be over your head.
>>>>>>>>
>>>>>>>> void H_Hat(u32 P)
>>>>>>>> {
>>>>>>>>     u32 Input_Halts = Whatever_Simulator(P, P);
>>>>>>>>     if (Input_Halts)
>>>>>>>>       HERE: goto HERE;
>>>>>>>>     else
>>>>>>>>       HALT
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> No, I admit that the above program will be infinitely recurcive,
>>>>>>> but the
>>>>>>> program is mis-named, as that is NOT the H_Hat of Linz, that uses a
>>>>>>> Halt
>>>>>>> Detector, not a simulator. (You are great at using bad terminology)
>>>>>>>
>>>>>>> The fact that you don't understand that seems amazing.
>>>>>>>
>>>>>>
>>>>>> It is is inherently infinitely recursive by any simulator
>>>>>> then it is inherently infinitely recursive by a simulator
>>>>>> that has halt deciding features.
>>>>>>
>>>>>
>>>>> And this is your flaw. Any execution inside of a Halt Decider can NOT
>>>>> create non-halting execution to the machine that is calling that Halt
>>>>> Decider, or the Halt Decider has failed its requirement of deciding in
>>>>> Finite Time.
>>>>>
>>>>> Yes, A Halt Decider based on a simulator will create an infinite
>>>>> recursion INSIDE itself, but because of its requirements, it MUST 
>>>>> figure
>>>>> out how to handle this problem. You don't.
>>>>>
>>>>>  From the trace, your halt decider has detected an infinte recursion,
>>>>> true. Does this indicate non-halting behavior, unclear. There IS
>>>>> apparently a conditional in the loop, is it is happening inside the 
>>>>> Halt
>>>>> Decider, which if it works properly, will terminate the infinite
>>>>> recursion, and then return an answer to its caller (but it has no
>>>>> information to make a right decision). The other possibility is 
>>>>> that we
>>>>> don't count that and what we have detected is that the Halt Decider 
>>>>> has
>>>>> failed to make its decision and failed at being a decider.
>>>>>
>>>>> The fact that you abort the whole machine currently would seem to 
>>>>> imply
>>>>> the second case.
>>>>>
>>>>>
>>>>> A clearer example that make it obvious is a different recursive 
>>>>> machine:
>>>>>
>>>>> int H2(u32 P) {
>>>>>      return Halts(P, P);
>>>>> }
>>>>>
>>>>> This machiine CLEARLY has identical halting properties to Halts, it
>>>>> really has no significant code other than Halts. Running H2(H2) will
>>>>> give essentially the same trace as that of H_Hat (since Halts will 
>>>>> never
>>>>> return in any of the nested calls, so it can't see the difference). 
>>>>> The
>>>>> fact that this program shows non-halting behavior show that it is 
>>>>> Halts
>>>>> that has that problem. And per the problem definition, if it has this
>>>>> sort of problem, it isn't a valid halting decider.
>>>>>
>>>>>
>>>>> You may have had some idea that detecting this type of infinite
>>>>> recursion whould get your around the problem, the issue is that due to
>>>>> how the halting problem is stated, the onus of solving the 
>>>>> recursion is
>>>>> on the halt decider, so it doesn't provide an out.
>>>>>
>>>>> As I have mentioned at other times, you ARE free to adjust the 
>>>>> terms of
>>>>> the halting problem, just if you do that you lose all ability to claim
>>>>> that you answer applies to it.
>>>>
>>>> I think we have learned a few things from these all too similar
>>>> threads. The first is that PO is wrong in virtually all his claims,
>>>> and mostly incoherent in his arguments.
>>>
>>> If I was wrong you could point out a logic error:
>>>
>>> Actual debug trace of H() correctly deciding halting on H_Hat()
>>>
>>>
>>> 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)   EMU_Level(0) 55                  push ebp
>>> [00000611](02)   EMU_Level(0) 8bec                mov ebp,esp
>>> [00000613](05)   EMU_Level(0) 68e0050000          push 000005e0
>>> [00000618](05)   EMU_Level(0) 68e0050000          push 000005e0
>>> [0000061d](05)   EMU_Level(0) e84efdffff          call 00000370 ----CALL
>>> [00000370]
>>> [000005e0](01)   EMU_Level(1) 55                  push ebp
>>> [000005e1](02)   EMU_Level(1) 8bec                mov ebp,esp
>>> [000005e3](01)   EMU_Level(1) 51                  push ecx
>>> [000005e4](03)   EMU_Level(1) 8b4508              mov eax,[ebp+08]
>>> [000005e7](01)   EMU_Level(1) 50                  push eax
>>> [000005e8](03)   EMU_Level(1) 8b4d08              mov ecx,[ebp+08]
>>> [000005eb](01)   EMU_Level(1) 51                  push ecx
>>> [000005ec](05)   EMU_Level(1) e87ffdffff          call 00000370 ----CALL
>>> [00000370]
>>> [000005e0](01)   EMU_Level(2) 55                  push ebp
>>> [000005e1](02)   EMU_Level(2) 8bec                mov ebp,esp
>>> [000005e3](01)   EMU_Level(2) 51                  push ecx
>>> [000005e4](03)   EMU_Level(2) 8b4508              mov eax,[ebp+08]
>>> [000005e7](01)   EMU_Level(2) 50                  push eax
>>> [000005e8](03)   EMU_Level(2) 8b4d08              mov ecx,[ebp+08]
>>> [000005eb](01)   EMU_Level(2) 51                  push ecx
>>> [000005ec](05)   EMU_Level(2) e87ffdffff          call 00000370 ----CALL
>>> [00000370]
>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>> Number of Instructions Executed(2777)
> 
> @PO:
> Eh, what?  No it doesn't!!
> 
> The previous instruction "specifies" *call 00000370*.  It's only *YOU* 
> (aka your test in H's code) "specifying" that that means infinite 
> recursion.  You're ignoring the fact that your infinite recursion 
> detection test is UNSOUND.  (We've discussed this before.)

Yes you declared that is is "unsound" without any supporting thus your 
basis is less than unsound it is totally vacuous.

> Do you think that if your code contains a printf("The PRIOR Instruction 
> Specifies Infinite Recursion") that means there REALLY MUST BE infinite 
> recursion?  

We have been though this. each and every time that the same function is 
called from the same machine address without any conditional branch 
intstruction in-between a pair of calls it always specifies infinite 
recursion as a mathematical formalism.

> You can't magically make your claims true just be printing 
> them out from a program!
> 
> Hey, at least you took up my suggestion of including the emulation level 
> in the trace - that was pretty much essential for tracking what's going 
> on - but now it's obvious your calls are AT DIFFERENT EMULATION LEVELS - 
> not really part of a "single processor trace" at all!  (Before, that was 
> kind of obscured for readers not looking too closely, so it looked a bit 
> like a trace of a genuine infinite loop...)
> 
>>>
>>>
>>
>> The execution trace shows that apparently H has the unbounded execution
>> and thus fails to meet its requirements (thus it doesn't matter if the
>> answer we got elsewhere is right or wrong).
> 
> Well, we (really) can't tell that from the trace - what actually happens 
> depends on future trace entries at EL0 which occur AFTER the two calls 
> in the trace.  (And they wouldn't be in the trace anyway as PO 
> selectively filters the trace entries he shows, but that's not the point).
> 
> Anyway, the trace entries shown /don't imply/ infinite recursion - 
> that's just something PO repeats over and over, because he doesn't 
> understand why his test is fundamentally flawed.
> 

I see two possibilites neither one is plausible:
(1) You are lying
(2) This is over your head

Since it is probably not either one of those then I can't see why you 
are saying this. Since you won't explain your reasoning then it is 
correct to call you above statement vacuous.

>>
>> Another possible error is that the trace skips some logic, which appear
>> to contain a condition that is part of H, thus the requirements of
>> detection of infinite recursion by recursion with no conditionals in the
>> loop is not meet.
> 
> Or more simply, PO's infinite recursion test is UNSOUND.  (It simply 
> does not imply infinite recursion when applied to scenarios where the 
> two "call" trace entries BELONG TO DIFFERENT EMULATION LEVELS!  [As in 
> above trace])   The issue of "conditionals in the loop" is quite moot 
> here - even if there genuinely aren't any conditional branches "in the 
> loop" that doesn't imply infinite recursion.  (So no point in accusing 
> him of hiding them :) )

I don't see how this is over your head and I don't accept that you are 
lying. It is like I am saying that 2 + 3 = 5 and you say that what I 
said is unsound.

> I've told him that, but he just doesn't believe me.  

I never believe any damn thing any unproven assertion counts as an 
assertion that was never even made.

> Also, he is unable 
> to provide any coherent "proof" that his test works (of course, since it 
> doesn't) - he just repeats one of his mantras about equivalent 

You are acting like Ben. I am totally wrong because you really really 
don't believe me. That is not logic son, that is not even decent rhetoric.

> calculations without any understanding of what he's saying or what's 
> going on with the recursion.  It's one of his "magical phrases" he uses 
> to try to make objections "go away" so he doesn't have to deal with 
> them.  (Like the issue of the relationship between his computing model 
> and TMs is "magicked away" by talk of TM-equivalence, as though that 
> clarifies anything...)
> 
> Anyway, PO believes his infinite recursion test works the same in a 
> recursive EMULATION scenario as it is in a recursive CALL scenario - 
> when it patently DOES NOT:  

> the former can be "broken" by an outer level 
> emulation aborting the inner levels, 

This is the way that a halt decider decides infinite recursion.

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

So basically you are saying the my halt decider is incorrect entirely on 
the basis that it gets the right answer.

> which is not possible when the 
> trace is of a single processor running in one single "process" (no 
> emulated virtual process trace entries).
> 
> So we could say this is PO misunderstanding the differences between 
> CALLing a function and EMULATING a function.  (I think it's really funny 
> how he explains to other people that recursion can be tricky, and 
> perhaps they just don't get it etc..!)
> 
> 
> Mike.
> 


-- 
Copyright 2020 Pete Olcott

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

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


#2122 — Re: Refutation of Peter Linz HP proof [ Logical Necessity ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-06 13:18 -0600
SubjectRe: Refutation of Peter Linz HP proof [ Logical Necessity ]
Message-ID<EZWdnZP8FeLms1DCnZ2dnUU7-c_NnZ2d@giganews.com>
In reply to#2116
On 12/6/2020 12:46 PM, Mike Terry wrote:
> On 06/12/2020 04:40, olcott wrote:
>> On 12/5/2020 10:15 PM, Mike Terry wrote:
>>> On 06/12/2020 02:12, Richard Damon wrote:
>>>> On 12/5/20 8:49 PM, olcott wrote:
>>>>> On 12/5/2020 7:44 PM, Jeff Barnett wrote:
>>>>>> On 12/5/2020 4:35 PM, Richard Damon wrote:
>>>>>>> On 12/5/20 5:25 PM, olcott wrote:
>>>>>>>> On 12/5/2020 3:45 PM, Richard Damon wrote:
>>>>>>>>> On 12/5/20 4:25 PM, olcott wrote:
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The fact that this is inherently infinitely recursive when
>>>>>>>>>> executed with
>>>>>>>>>> itself as input must be over your head.
>>>>>>>>>>
>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>> {
>>>>>>>>>>     u32 Input_Halts = Whatever_Simulator(P, P);
>>>>>>>>>>     if (Input_Halts)
>>>>>>>>>>       HERE: goto HERE;
>>>>>>>>>>     else
>>>>>>>>>>       HALT
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, I admit that the above program will be infinitely recurcive,
>>>>>>>>> but the
>>>>>>>>> program is mis-named, as that is NOT the H_Hat of Linz, that 
>>>>>>>>> uses a
>>>>>>>>> Halt
>>>>>>>>> Detector, not a simulator. (You are great at using bad 
>>>>>>>>> terminology)
>>>>>>>>>
>>>>>>>>> The fact that you don't understand that seems amazing.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is is inherently infinitely recursive by any simulator
>>>>>>>> then it is inherently infinitely recursive by a simulator
>>>>>>>> that has halt deciding features.
>>>>>>>>
>>>>>>>
>>>>>>> And this is your flaw. Any execution inside of a Halt Decider can 
>>>>>>> NOT
>>>>>>> create non-halting execution to the machine that is calling that 
>>>>>>> Halt
>>>>>>> Decider, or the Halt Decider has failed its requirement of
>>>>>>> deciding in
>>>>>>> Finite Time.
>>>>>>>
>>>>>>> Yes, A Halt Decider based on a simulator will create an infinite
>>>>>>> recursion INSIDE itself, but because of its requirements, it MUST
>>>>>>> figure
>>>>>>> out how to handle this problem. You don't.
>>>>>>>
>>>>>>>  From the trace, your halt decider has detected an infinte 
>>>>>>> recursion,
>>>>>>> true. Does this indicate non-halting behavior, unclear. There IS
>>>>>>> apparently a conditional in the loop, is it is happening inside
>>>>>>> the Halt
>>>>>>> Decider, which if it works properly, will terminate the infinite
>>>>>>> recursion, and then return an answer to its caller (but it has no
>>>>>>> information to make a right decision). The other possibility is
>>>>>>> that we
>>>>>>> don't count that and what we have detected is that the Halt
>>>>>>> Decider has
>>>>>>> failed to make its decision and failed at being a decider.
>>>>>>>
>>>>>>> The fact that you abort the whole machine currently would seem to
>>>>>>> imply
>>>>>>> the second case.
>>>>>>>
>>>>>>>
>>>>>>> A clearer example that make it obvious is a different recursive
>>>>>>> machine:
>>>>>>>
>>>>>>> int H2(u32 P) {
>>>>>>>      return Halts(P, P);
>>>>>>> }
>>>>>>>
>>>>>>> This machiine CLEARLY has identical halting properties to Halts, it
>>>>>>> really has no significant code other than Halts. Running H2(H2) will
>>>>>>> give essentially the same trace as that of H_Hat (since Halts will
>>>>>>> never
>>>>>>> return in any of the nested calls, so it can't see the
>>>>>>> difference). The
>>>>>>> fact that this program shows non-halting behavior show that it is
>>>>>>> Halts
>>>>>>> that has that problem. And per the problem definition, if it has 
>>>>>>> this
>>>>>>> sort of problem, it isn't a valid halting decider.
>>>>>>>
>>>>>>>
>>>>>>> You may have had some idea that detecting this type of infinite
>>>>>>> recursion whould get your around the problem, the issue is that
>>>>>>> due to
>>>>>>> how the halting problem is stated, the onus of solving the
>>>>>>> recursion is
>>>>>>> on the halt decider, so it doesn't provide an out.
>>>>>>>
>>>>>>> As I have mentioned at other times, you ARE free to adjust the
>>>>>>> terms of
>>>>>>> the halting problem, just if you do that you lose all ability to
>>>>>>> claim
>>>>>>> that you answer applies to it.
>>>>>>
>>>>>> I think we have learned a few things from these all too similar
>>>>>> threads. The first is that PO is wrong in virtually all his claims,
>>>>>> and mostly incoherent in his arguments.
>>>>>
>>>>> If I was wrong you could point out a logic error:
>>>>>
>>>>> Actual debug trace of H() correctly deciding halting on H_Hat()
>>>>>
>>>>>
>>>>> 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)   EMU_Level(0) 55                  push ebp
>>>>> [00000611](02)   EMU_Level(0) 8bec                mov ebp,esp
>>>>> [00000613](05)   EMU_Level(0) 68e0050000          push 000005e0
>>>>> [00000618](05)   EMU_Level(0) 68e0050000          push 000005e0
>>>>> [0000061d](05)   EMU_Level(0) e84efdffff          call 00000370
>>>>> ----CALL
>>>>> [00000370]
>>>>> [000005e0](01)   EMU_Level(1) 55                  push ebp
>>>>> [000005e1](02)   EMU_Level(1) 8bec                mov ebp,esp
>>>>> [000005e3](01)   EMU_Level(1) 51                  push ecx
>>>>> [000005e4](03)   EMU_Level(1) 8b4508              mov eax,[ebp+08]
>>>>> [000005e7](01)   EMU_Level(1) 50                  push eax
>>>>> [000005e8](03)   EMU_Level(1) 8b4d08              mov ecx,[ebp+08]
>>>>> [000005eb](01)   EMU_Level(1) 51                  push ecx
>>>>> [000005ec](05)   EMU_Level(1) e87ffdffff          call 00000370
>>>>> ----CALL
>>>>> [00000370]
>>>>> [000005e0](01)   EMU_Level(2) 55                  push ebp
>>>>> [000005e1](02)   EMU_Level(2) 8bec                mov ebp,esp
>>>>> [000005e3](01)   EMU_Level(2) 51                  push ecx
>>>>> [000005e4](03)   EMU_Level(2) 8b4508              mov eax,[ebp+08]
>>>>> [000005e7](01)   EMU_Level(2) 50                  push eax
>>>>> [000005e8](03)   EMU_Level(2) 8b4d08              mov ecx,[ebp+08]
>>>>> [000005eb](01)   EMU_Level(2) 51                  push ecx
>>>>> [000005ec](05)   EMU_Level(2) e87ffdffff          call 00000370
>>>>> ----CALL
>>>>> [00000370]
>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation 
>>>>> Stopped:
>>>>> Number of Instructions Executed(2777)
>>>
>>> @PO:
>>> Eh, what?  No it doesn't!!
>>>
>>> The previous instruction "specifies" *call 00000370*.  It's only *YOU*
>>> (aka your test in H's code) "specifying" that that means infinite
>>> recursion.  You're ignoring the fact that your infinite recursion
>>> detection test is UNSOUND.  (We've discussed this before.)
>>
>> Yes you declared that is is "unsound" without any supporting thus your
>> basis is less than unsound it is totally vacuous.
> 
> But YOU are the one making the claim here - so it's YOU who have to 
> prove your claim.  I don't need to disprove it - claims are false by
> default.
> 
> The real problem here is that you are intellectually incapable of 
> proving anything, and that is bad news because without a proper proof 
> nobody will pay any serious attention to your claim.  This includes any 
> peer-reviewers for your final article - they'll glance at it and see 
> just a series of unproven claims, and quickly conclude "duffer!".
> 
> It doesn't matter that you don't believe your test is unsound - it's the 
> peer reviewers who count, and they will reject it since:
> a)  you don't have a proof.
> b)  it will be clear /to them/ that is false.
> 
>>
>>> Do you think that if your code contains a printf("The PRIOR
>>> Instruction Specifies Infinite Recursion") that means there REALLY
>>> MUST BE infinite recursion?
>>
>> We have been though this. each and every time that the same function is
>> called from the same machine address without any conditional branch
>> intstruction in-between a pair of calls it always specifies infinite
>> recursion as a mathematical formalism.
>>
> Hehe, another "magical phrase" : "..as a mathematical formalism".  That 
> just screams "crank".  You know that what you just said is not a proof, 
> right?  (You are doing exactly what I said - just repeating your claim 
> and sprinkling in some magical phrases in place of a proof.)
> 
> I note that your statement of the test makes no mention of the fact that 
> the pair of calls can be in different emulation levels.  Perhaps you're 
> trying to trick people into reading it as applying to a "single 
> processor" execution trace (no emulation trace entries), where your test 
> /would/ be sound?  Then having tricked people into accepting that, you 
> sneak in applications to an emulation environment where it doesn't work...
> 
> Maybe try to provide a proof for the scenario where your test works, viz 
> when there is no emulation.  Then try to apply the proof to the case 
> where the "call" instructions occur in different emulation levels, and 
> you should see where the proof breaks down.
> 
> Remember that "inner emulation trace entries" are not logically a part 
> of the outer processor execution trace.  It would be better to think of 
> them as interspersed "interpretations" that the outer emulation code is 
> making as it goes along.  The outer processor execution trace is still 
> continuing even if you choose to filter out those entries, and in fact 
> it is all that is driving the inner emulations.  But it can just decide 
> not emulate any more, effectively "aborting" the inner emulation.  That 
> aborting code need not be visible in the block of trace entries between 
> the two "call" instructions.
> 
>>> You can't magically make your claims true just be printing them out
>>> from a program!
>>>
>>> Hey, at least you took up my suggestion of including the emulation
>>> level in the trace - that was pretty much essential for tracking
>>> what's going on - but now it's obvious your calls are AT DIFFERENT
>>> EMULATION LEVELS - not really part of a "single processor trace" at
>>> all!  (Before, that was kind of obscured for readers not looking too
>>> closely, so it looked a bit like a trace of a genuine infinite loop...)
>>>
>>>>>
>>>>>
>>>>
>>>> The execution trace shows that apparently H has the unbounded execution
>>>> and thus fails to meet its requirements (thus it doesn't matter if the
>>>> answer we got elsewhere is right or wrong).
>>>
>>> Well, we (really) can't tell that from the trace - what actually
>>> happens depends on future trace entries at EL0 which occur AFTER the
>>> two calls in the trace.  (And they wouldn't be in the trace anyway as
>>> PO selectively filters the trace entries he shows, but that's not the
>>> point).
>>>
>>> Anyway, the trace entries shown /don't imply/ infinite recursion -
>>> that's just something PO repeats over and over, because he doesn't
>>> understand why his test is fundamentally flawed.
>>>
>>
>> I see two possibilites neither one is plausible:
>> (1) You are lying
>> (2) This is over your head
> 
> (3) This is over /your/ head
> 
> but of course you wouldn't consider that possibility.
> 
>>
>> Since it is probably not either one of those then I can't see why you
>> are saying this. Since you won't explain your reasoning then it is
>> correct to call you above statement vacuous.
>>
>>>>
>>>> Another possible error is that the trace skips some logic, which appear
>>>> to contain a condition that is part of H, thus the requirements of
>>>> detection of infinite recursion by recursion with no conditionals in 
>>>> the
>>>> loop is not meet.
>>>
>>> Or more simply, PO's infinite recursion test is UNSOUND.  (It simply
>>> does not imply infinite recursion when applied to scenarios where the
>>> two "call" trace entries BELONG TO DIFFERENT EMULATION LEVELS!  [As in
>>> above trace])   The issue of "conditionals in the loop" is quite moot
>>> here - even if there genuinely aren't any conditional branches "in the
>>> loop" that doesn't imply infinite recursion.  (So no point in accusing
>>> him of hiding them :) )
>>
>> I don't see how this is over your head and I don't accept that you are
>> lying. It is like I am saying that 2 + 3 = 5 and you say that what I
>> said is unsound.
>>
>>> I've told him that, but he just doesn't believe me.
>>
>> I never believe any damn thing any unproven assertion counts as an
>> assertion that was never even made.
>>
> You believe your own assertions, but are unable to prove them.  :)
> 
>>> Also, he is unable to provide any coherent "proof" that his test works
>>> (of course, since it doesn't) - he just repeats one of his mantras
>>> about equivalent
>>
>> You are acting like Ben. I am totally wrong because you really really
>> don't believe me. That is not logic son, that is not even decent 
>> rhetoric.
> 
> People do not have to accept what you say without you providing proof. 
> You are unable to do that.  (That will be the key point, when it comes 
> to how reviewers will treat your claims.)
> 
> Mike.
> 

If it is clear to them that it is false on the basis of lack of proof 
this is a logic error known as ad  ignorantiam.

I. Argumentum ad Ignorantiam: (appeal to ignorance) the fallacy that a 
proposition is true simply on the basis that it has not been proved 
false or that it is false simply because it has not been proved true. 
This error in reasoning is often expressed with influential rhetoric.
https://philosophy.lander.edu/logic/ignorance.html

The proof (that you already acknowledged) is that any function call from 
the same machine address in the user code to the same function in the 
user code without any conditional branch instructions in-between does 
unequivocally specify infinite recursion in this user code execution trace.

This is a logical necessity thus not correctly deniable.

-- 
Copyright 2020 Pete Olcott

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

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


#2124 — Re: Refutation of Peter Linz HP proof [ Logical Necessity ]

FromMr Flibble <flibble@i42.REMOVETHISBIT.co.uk>
Date2020-12-06 19:59 +0000
SubjectRe: Refutation of Peter Linz HP proof [ Logical Necessity ]
Message-ID<XKazH.99365$SiR9.40771@fx11.ams4>
In reply to#2122
On 06/12/2020 19:18, olcott wrote:
> On 12/6/2020 12:46 PM, Mike Terry wrote:
>> On 06/12/2020 04:40, olcott wrote:
>>> On 12/5/2020 10:15 PM, Mike Terry wrote:
>>>> On 06/12/2020 02:12, Richard Damon wrote:
>>>>> On 12/5/20 8:49 PM, olcott wrote:
>>>>>> On 12/5/2020 7:44 PM, Jeff Barnett wrote:
>>>>>>> On 12/5/2020 4:35 PM, Richard Damon wrote:
>>>>>>>> On 12/5/20 5:25 PM, olcott wrote:
>>>>>>>>> On 12/5/2020 3:45 PM, Richard Damon wrote:
>>>>>>>>>> On 12/5/20 4:25 PM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The fact that this is inherently infinitely recursive when
>>>>>>>>>>> executed with
>>>>>>>>>>> itself as input must be over your head.
>>>>>>>>>>>
>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>> {
>>>>>>>>>>>     u32 Input_Halts = Whatever_Simulator(P, P);
>>>>>>>>>>>     if (Input_Halts)
>>>>>>>>>>>       HERE: goto HERE;
>>>>>>>>>>>     else
>>>>>>>>>>>       HALT
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, I admit that the above program will be infinitely recurcive,
>>>>>>>>>> but the
>>>>>>>>>> program is mis-named, as that is NOT the H_Hat of Linz, that uses a
>>>>>>>>>> Halt
>>>>>>>>>> Detector, not a simulator. (You are great at using bad terminology)
>>>>>>>>>>
>>>>>>>>>> The fact that you don't understand that seems amazing.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is is inherently infinitely recursive by any simulator
>>>>>>>>> then it is inherently infinitely recursive by a simulator
>>>>>>>>> that has halt deciding features.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And this is your flaw. Any execution inside of a Halt Decider can NOT
>>>>>>>> create non-halting execution to the machine that is calling that Halt
>>>>>>>> Decider, or the Halt Decider has failed its requirement of
>>>>>>>> deciding in
>>>>>>>> Finite Time.
>>>>>>>>
>>>>>>>> Yes, A Halt Decider based on a simulator will create an infinite
>>>>>>>> recursion INSIDE itself, but because of its requirements, it MUST
>>>>>>>> figure
>>>>>>>> out how to handle this problem. You don't.
>>>>>>>>
>>>>>>>>  From the trace, your halt decider has detected an infinte recursion,
>>>>>>>> true. Does this indicate non-halting behavior, unclear. There IS
>>>>>>>> apparently a conditional in the loop, is it is happening inside
>>>>>>>> the Halt
>>>>>>>> Decider, which if it works properly, will terminate the infinite
>>>>>>>> recursion, and then return an answer to its caller (but it has no
>>>>>>>> information to make a right decision). The other possibility is
>>>>>>>> that we
>>>>>>>> don't count that and what we have detected is that the Halt
>>>>>>>> Decider has
>>>>>>>> failed to make its decision and failed at being a decider.
>>>>>>>>
>>>>>>>> The fact that you abort the whole machine currently would seem to
>>>>>>>> imply
>>>>>>>> the second case.
>>>>>>>>
>>>>>>>>
>>>>>>>> A clearer example that make it obvious is a different recursive
>>>>>>>> machine:
>>>>>>>>
>>>>>>>> int H2(u32 P) {
>>>>>>>>      return Halts(P, P);
>>>>>>>> }
>>>>>>>>
>>>>>>>> This machiine CLEARLY has identical halting properties to Halts, it
>>>>>>>> really has no significant code other than Halts. Running H2(H2) will
>>>>>>>> give essentially the same trace as that of H_Hat (since Halts will
>>>>>>>> never
>>>>>>>> return in any of the nested calls, so it can't see the
>>>>>>>> difference). The
>>>>>>>> fact that this program shows non-halting behavior show that it is
>>>>>>>> Halts
>>>>>>>> that has that problem. And per the problem definition, if it has this
>>>>>>>> sort of problem, it isn't a valid halting decider.
>>>>>>>>
>>>>>>>>
>>>>>>>> You may have had some idea that detecting this type of infinite
>>>>>>>> recursion whould get your around the problem, the issue is that
>>>>>>>> due to
>>>>>>>> how the halting problem is stated, the onus of solving the
>>>>>>>> recursion is
>>>>>>>> on the halt decider, so it doesn't provide an out.
>>>>>>>>
>>>>>>>> As I have mentioned at other times, you ARE free to adjust the
>>>>>>>> terms of
>>>>>>>> the halting problem, just if you do that you lose all ability to
>>>>>>>> claim
>>>>>>>> that you answer applies to it.
>>>>>>>
>>>>>>> I think we have learned a few things from these all too similar
>>>>>>> threads. The first is that PO is wrong in virtually all his claims,
>>>>>>> and mostly incoherent in his arguments.
>>>>>>
>>>>>> If I was wrong you could point out a logic error:
>>>>>>
>>>>>> Actual debug trace of H() correctly deciding halting on H_Hat()
>>>>>>
>>>>>>
>>>>>> 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)   EMU_Level(0) 55                  push ebp
>>>>>> [00000611](02)   EMU_Level(0) 8bec                mov ebp,esp
>>>>>> [00000613](05)   EMU_Level(0) 68e0050000          push 000005e0
>>>>>> [00000618](05)   EMU_Level(0) 68e0050000          push 000005e0
>>>>>> [0000061d](05)   EMU_Level(0) e84efdffff          call 00000370
>>>>>> ----CALL
>>>>>> [00000370]
>>>>>> [000005e0](01)   EMU_Level(1) 55                  push ebp
>>>>>> [000005e1](02)   EMU_Level(1) 8bec                mov ebp,esp
>>>>>> [000005e3](01)   EMU_Level(1) 51                  push ecx
>>>>>> [000005e4](03)   EMU_Level(1) 8b4508              mov eax,[ebp+08]
>>>>>> [000005e7](01)   EMU_Level(1) 50                  push eax
>>>>>> [000005e8](03)   EMU_Level(1) 8b4d08              mov ecx,[ebp+08]
>>>>>> [000005eb](01)   EMU_Level(1) 51                  push ecx
>>>>>> [000005ec](05)   EMU_Level(1) e87ffdffff          call 00000370
>>>>>> ----CALL
>>>>>> [00000370]
>>>>>> [000005e0](01)   EMU_Level(2) 55                  push ebp
>>>>>> [000005e1](02)   EMU_Level(2) 8bec                mov ebp,esp
>>>>>> [000005e3](01)   EMU_Level(2) 51                  push ecx
>>>>>> [000005e4](03)   EMU_Level(2) 8b4508              mov eax,[ebp+08]
>>>>>> [000005e7](01)   EMU_Level(2) 50                  push eax
>>>>>> [000005e8](03)   EMU_Level(2) 8b4d08              mov ecx,[ebp+08]
>>>>>> [000005eb](01)   EMU_Level(2) 51                  push ecx
>>>>>> [000005ec](05)   EMU_Level(2) e87ffdffff          call 00000370
>>>>>> ----CALL
>>>>>> [00000370]
>>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>>>>> Number of Instructions Executed(2777)
>>>>
>>>> @PO:
>>>> Eh, what?  No it doesn't!!
>>>>
>>>> The previous instruction "specifies" *call 00000370*.  It's only *YOU*
>>>> (aka your test in H's code) "specifying" that that means infinite
>>>> recursion.  You're ignoring the fact that your infinite recursion
>>>> detection test is UNSOUND.  (We've discussed this before.)
>>>
>>> Yes you declared that is is "unsound" without any supporting thus your
>>> basis is less than unsound it is totally vacuous.
>>
>> But YOU are the one making the claim here - so it's YOU who have to prove your claim.  I don't need to disprove it - claims are false by
>> default.
>>
>> The real problem here is that you are intellectually incapable of proving anything, and that is bad news because without a proper proof nobody will pay any serious attention to your claim.  This includes any peer-reviewers for your final article - they'll glance at it and see just a series of unproven claims, and quickly conclude "duffer!".
>>
>> It doesn't matter that you don't believe your test is unsound - it's the peer reviewers who count, and they will reject it since:
>> a)  you don't have a proof.
>> b)  it will be clear /to them/ that is false.
>>
>>>
>>>> Do you think that if your code contains a printf("The PRIOR
>>>> Instruction Specifies Infinite Recursion") that means there REALLY
>>>> MUST BE infinite recursion?
>>>
>>> We have been though this. each and every time that the same function is
>>> called from the same machine address without any conditional branch
>>> intstruction in-between a pair of calls it always specifies infinite
>>> recursion as a mathematical formalism.
>>>
>> Hehe, another "magical phrase" : "..as a mathematical formalism".  That just screams "crank".  You know that what you just said is not a proof, right?  (You are doing exactly what I said - just repeating your claim and sprinkling in some magical phrases in place of a proof.)
>>
>> I note that your statement of the test makes no mention of the fact that the pair of calls can be in different emulation levels.  Perhaps you're trying to trick people into reading it as applying to a "single processor" execution trace (no emulation trace entries), where your test /would/ be sound?  Then having tricked people into accepting that, you sneak in applications to an emulation environment where it doesn't work...
>>
>> Maybe try to provide a proof for the scenario where your test works, viz when there is no emulation.  Then try to apply the proof to the case where the "call" instructions occur in different emulation levels, and you should see where the proof breaks down.
>>
>> Remember that "inner emulation trace entries" are not logically a part of the outer processor execution trace.  It would be better to think of them as interspersed "interpretations" that the outer emulation code is making as it goes along.  The outer processor execution trace is still continuing even if you choose to filter out those entries, and in fact it is all that is driving the inner emulations.  But it can just decide not emulate any more, effectively "aborting" the inner emulation.  That aborting code need not be visible in the block of trace entries between the two "call" instructions.
>>
>>>> You can't magically make your claims true just be printing them out
>>>> from a program!
>>>>
>>>> Hey, at least you took up my suggestion of including the emulation
>>>> level in the trace - that was pretty much essential for tracking
>>>> what's going on - but now it's obvious your calls are AT DIFFERENT
>>>> EMULATION LEVELS - not really part of a "single processor trace" at
>>>> all!  (Before, that was kind of obscured for readers not looking too
>>>> closely, so it looked a bit like a trace of a genuine infinite loop...)
>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> The execution trace shows that apparently H has the unbounded execution
>>>>> and thus fails to meet its requirements (thus it doesn't matter if the
>>>>> answer we got elsewhere is right or wrong).
>>>>
>>>> Well, we (really) can't tell that from the trace - what actually
>>>> happens depends on future trace entries at EL0 which occur AFTER the
>>>> two calls in the trace.  (And they wouldn't be in the trace anyway as
>>>> PO selectively filters the trace entries he shows, but that's not the
>>>> point).
>>>>
>>>> Anyway, the trace entries shown /don't imply/ infinite recursion -
>>>> that's just something PO repeats over and over, because he doesn't
>>>> understand why his test is fundamentally flawed.
>>>>
>>>
>>> I see two possibilites neither one is plausible:
>>> (1) You are lying
>>> (2) This is over your head
>>
>> (3) This is over /your/ head
>>
>> but of course you wouldn't consider that possibility.
>>
>>>
>>> Since it is probably not either one of those then I can't see why you
>>> are saying this. Since you won't explain your reasoning then it is
>>> correct to call you above statement vacuous.
>>>
>>>>>
>>>>> Another possible error is that the trace skips some logic, which appear
>>>>> to contain a condition that is part of H, thus the requirements of
>>>>> detection of infinite recursion by recursion with no conditionals in the
>>>>> loop is not meet.
>>>>
>>>> Or more simply, PO's infinite recursion test is UNSOUND.  (It simply
>>>> does not imply infinite recursion when applied to scenarios where the
>>>> two "call" trace entries BELONG TO DIFFERENT EMULATION LEVELS!  [As in
>>>> above trace])   The issue of "conditionals in the loop" is quite moot
>>>> here - even if there genuinely aren't any conditional branches "in the
>>>> loop" that doesn't imply infinite recursion.  (So no point in accusing
>>>> him of hiding them :) )
>>>
>>> I don't see how this is over your head and I don't accept that you are
>>> lying. It is like I am saying that 2 + 3 = 5 and you say that what I
>>> said is unsound.
>>>
>>>> I've told him that, but he just doesn't believe me.
>>>
>>> I never believe any damn thing any unproven assertion counts as an
>>> assertion that was never even made.
>>>
>> You believe your own assertions, but are unable to prove them.  :)
>>
>>>> Also, he is unable to provide any coherent "proof" that his test works
>>>> (of course, since it doesn't) - he just repeats one of his mantras
>>>> about equivalent
>>>
>>> You are acting like Ben. I am totally wrong because you really really
>>> don't believe me. That is not logic son, that is not even decent rhetoric.
>>
>> People do not have to accept what you say without you providing proof. You are unable to do that.  (That will be the key point, when it comes to how reviewers will treat your claims.)
>>
>> Mike.
>>
> 
> If it is clear to them that it is false on the basis of lack of proof this is a logic error known as ad  ignorantiam.
> 
> I. Argumentum ad Ignorantiam: (appeal to ignorance) the fallacy that a proposition is true simply on the basis that it has not been proved false or that it is false simply because it has not been proved true. This error in reasoning is often expressed with influential rhetoric.
> https://philosophy.lander.edu/logic/ignorance.html
> 
> The proof (that you already acknowledged) is that any function call from the same machine address in the user code to the same function in the user code without any conditional branch instructions in-between does unequivocally specify infinite recursion in this user code execution trace.
> 
> This is a logical necessity thus not correctly deniable.

The term "fractal wrongness" may also be used to refer to someone who is consistently wrong on nearly everything they predict or claim. Repeatedly failing predictions is one of the best ways of revealing fractal wrongness, because while an idiotic worldview may work in someone's head, it can be seen failing when actually put to the test. Hilariously, people who are consistently wrong tend to be quite confident in their position while championing it.

/Flibble

-- 
😎

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


#2125 — Re: Refutation of Peter Linz HP proof [ Logical Necessity ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-06 14:07 -0600
SubjectRe: Refutation of Peter Linz HP proof [ Logical Necessity ]
Message-ID<xa6dncbcoKd3pFDCnZ2dnUU7-dudnZ2d@giganews.com>
In reply to#2124
On 12/6/2020 1:59 PM, Mr Flibble wrote:
> On 06/12/2020 19:18, olcott wrote:
>> On 12/6/2020 12:46 PM, Mike Terry wrote:
>>> On 06/12/2020 04:40, olcott wrote:
>>>> On 12/5/2020 10:15 PM, Mike Terry wrote:
>>>>> On 06/12/2020 02:12, Richard Damon wrote:
>>>>>> On 12/5/20 8:49 PM, olcott wrote:
>>>>>>> On 12/5/2020 7:44 PM, Jeff Barnett wrote:
>>>>>>>> On 12/5/2020 4:35 PM, Richard Damon wrote:
>>>>>>>>> On 12/5/20 5:25 PM, olcott wrote:
>>>>>>>>>> On 12/5/2020 3:45 PM, Richard Damon wrote:
>>>>>>>>>>> On 12/5/20 4:25 PM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that this is inherently infinitely recursive when
>>>>>>>>>>>> executed with
>>>>>>>>>>>> itself as input must be over your head.
>>>>>>>>>>>>
>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>> {
>>>>>>>>>>>>     u32 Input_Halts = Whatever_Simulator(P, P);
>>>>>>>>>>>>     if (Input_Halts)
>>>>>>>>>>>>       HERE: goto HERE;
>>>>>>>>>>>>     else
>>>>>>>>>>>>       HALT
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, I admit that the above program will be infinitely recurcive,
>>>>>>>>>>> but the
>>>>>>>>>>> program is mis-named, as that is NOT the H_Hat of Linz, that 
>>>>>>>>>>> uses a
>>>>>>>>>>> Halt
>>>>>>>>>>> Detector, not a simulator. (You are great at using bad 
>>>>>>>>>>> terminology)
>>>>>>>>>>>
>>>>>>>>>>> The fact that you don't understand that seems amazing.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is is inherently infinitely recursive by any simulator
>>>>>>>>>> then it is inherently infinitely recursive by a simulator
>>>>>>>>>> that has halt deciding features.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And this is your flaw. Any execution inside of a Halt Decider 
>>>>>>>>> can NOT
>>>>>>>>> create non-halting execution to the machine that is calling 
>>>>>>>>> that Halt
>>>>>>>>> Decider, or the Halt Decider has failed its requirement of
>>>>>>>>> deciding in
>>>>>>>>> Finite Time.
>>>>>>>>>
>>>>>>>>> Yes, A Halt Decider based on a simulator will create an infinite
>>>>>>>>> recursion INSIDE itself, but because of its requirements, it MUST
>>>>>>>>> figure
>>>>>>>>> out how to handle this problem. You don't.
>>>>>>>>>
>>>>>>>>>  From the trace, your halt decider has detected an infinte 
>>>>>>>>> recursion,
>>>>>>>>> true. Does this indicate non-halting behavior, unclear. There IS
>>>>>>>>> apparently a conditional in the loop, is it is happening inside
>>>>>>>>> the Halt
>>>>>>>>> Decider, which if it works properly, will terminate the infinite
>>>>>>>>> recursion, and then return an answer to its caller (but it has no
>>>>>>>>> information to make a right decision). The other possibility is
>>>>>>>>> that we
>>>>>>>>> don't count that and what we have detected is that the Halt
>>>>>>>>> Decider has
>>>>>>>>> failed to make its decision and failed at being a decider.
>>>>>>>>>
>>>>>>>>> The fact that you abort the whole machine currently would seem to
>>>>>>>>> imply
>>>>>>>>> the second case.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> A clearer example that make it obvious is a different recursive
>>>>>>>>> machine:
>>>>>>>>>
>>>>>>>>> int H2(u32 P) {
>>>>>>>>>      return Halts(P, P);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> This machiine CLEARLY has identical halting properties to 
>>>>>>>>> Halts, it
>>>>>>>>> really has no significant code other than Halts. Running H2(H2) 
>>>>>>>>> will
>>>>>>>>> give essentially the same trace as that of H_Hat (since Halts will
>>>>>>>>> never
>>>>>>>>> return in any of the nested calls, so it can't see the
>>>>>>>>> difference). The
>>>>>>>>> fact that this program shows non-halting behavior show that it is
>>>>>>>>> Halts
>>>>>>>>> that has that problem. And per the problem definition, if it 
>>>>>>>>> has this
>>>>>>>>> sort of problem, it isn't a valid halting decider.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You may have had some idea that detecting this type of infinite
>>>>>>>>> recursion whould get your around the problem, the issue is that
>>>>>>>>> due to
>>>>>>>>> how the halting problem is stated, the onus of solving the
>>>>>>>>> recursion is
>>>>>>>>> on the halt decider, so it doesn't provide an out.
>>>>>>>>>
>>>>>>>>> As I have mentioned at other times, you ARE free to adjust the
>>>>>>>>> terms of
>>>>>>>>> the halting problem, just if you do that you lose all ability to
>>>>>>>>> claim
>>>>>>>>> that you answer applies to it.
>>>>>>>>
>>>>>>>> I think we have learned a few things from these all too similar
>>>>>>>> threads. The first is that PO is wrong in virtually all his claims,
>>>>>>>> and mostly incoherent in his arguments.
>>>>>>>
>>>>>>> If I was wrong you could point out a logic error:
>>>>>>>
>>>>>>> Actual debug trace of H() correctly deciding halting on H_Hat()
>>>>>>>
>>>>>>>
>>>>>>> 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)   EMU_Level(0) 55                  push ebp
>>>>>>> [00000611](02)   EMU_Level(0) 8bec                mov ebp,esp
>>>>>>> [00000613](05)   EMU_Level(0) 68e0050000          push 000005e0
>>>>>>> [00000618](05)   EMU_Level(0) 68e0050000          push 000005e0
>>>>>>> [0000061d](05)   EMU_Level(0) e84efdffff          call 00000370
>>>>>>> ----CALL
>>>>>>> [00000370]
>>>>>>> [000005e0](01)   EMU_Level(1) 55                  push ebp
>>>>>>> [000005e1](02)   EMU_Level(1) 8bec                mov ebp,esp
>>>>>>> [000005e3](01)   EMU_Level(1) 51                  push ecx
>>>>>>> [000005e4](03)   EMU_Level(1) 8b4508              mov eax,[ebp+08]
>>>>>>> [000005e7](01)   EMU_Level(1) 50                  push eax
>>>>>>> [000005e8](03)   EMU_Level(1) 8b4d08              mov ecx,[ebp+08]
>>>>>>> [000005eb](01)   EMU_Level(1) 51                  push ecx
>>>>>>> [000005ec](05)   EMU_Level(1) e87ffdffff          call 00000370
>>>>>>> ----CALL
>>>>>>> [00000370]
>>>>>>> [000005e0](01)   EMU_Level(2) 55                  push ebp
>>>>>>> [000005e1](02)   EMU_Level(2) 8bec                mov ebp,esp
>>>>>>> [000005e3](01)   EMU_Level(2) 51                  push ecx
>>>>>>> [000005e4](03)   EMU_Level(2) 8b4508              mov eax,[ebp+08]
>>>>>>> [000005e7](01)   EMU_Level(2) 50                  push eax
>>>>>>> [000005e8](03)   EMU_Level(2) 8b4d08              mov ecx,[ebp+08]
>>>>>>> [000005eb](01)   EMU_Level(2) 51                  push ecx
>>>>>>> [000005ec](05)   EMU_Level(2) e87ffdffff          call 00000370
>>>>>>> ----CALL
>>>>>>> [00000370]
>>>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation 
>>>>>>> Stopped:
>>>>>>> Number of Instructions Executed(2777)
>>>>>
>>>>> @PO:
>>>>> Eh, what?  No it doesn't!!
>>>>>
>>>>> The previous instruction "specifies" *call 00000370*.  It's only *YOU*
>>>>> (aka your test in H's code) "specifying" that that means infinite
>>>>> recursion.  You're ignoring the fact that your infinite recursion
>>>>> detection test is UNSOUND.  (We've discussed this before.)
>>>>
>>>> Yes you declared that is is "unsound" without any supporting thus your
>>>> basis is less than unsound it is totally vacuous.
>>>
>>> But YOU are the one making the claim here - so it's YOU who have to 
>>> prove your claim.  I don't need to disprove it - claims are false by
>>> default.
>>>
>>> The real problem here is that you are intellectually incapable of 
>>> proving anything, and that is bad news because without a proper proof 
>>> nobody will pay any serious attention to your claim.  This includes 
>>> any peer-reviewers for your final article - they'll glance at it and 
>>> see just a series of unproven claims, and quickly conclude "duffer!".
>>>
>>> It doesn't matter that you don't believe your test is unsound - it's 
>>> the peer reviewers who count, and they will reject it since:
>>> a)  you don't have a proof.
>>> b)  it will be clear /to them/ that is false.
>>>
>>>>
>>>>> Do you think that if your code contains a printf("The PRIOR
>>>>> Instruction Specifies Infinite Recursion") that means there REALLY
>>>>> MUST BE infinite recursion?
>>>>
>>>> We have been though this. each and every time that the same function is
>>>> called from the same machine address without any conditional branch
>>>> intstruction in-between a pair of calls it always specifies infinite
>>>> recursion as a mathematical formalism.
>>>>
>>> Hehe, another "magical phrase" : "..as a mathematical formalism".  
>>> That just screams "crank".  You know that what you just said is not a 
>>> proof, right?  (You are doing exactly what I said - just repeating 
>>> your claim and sprinkling in some magical phrases in place of a proof.)
>>>
>>> I note that your statement of the test makes no mention of the fact 
>>> that the pair of calls can be in different emulation levels.  Perhaps 
>>> you're trying to trick people into reading it as applying to a 
>>> "single processor" execution trace (no emulation trace entries), 
>>> where your test /would/ be sound?  Then having tricked people into 
>>> accepting that, you sneak in applications to an emulation environment 
>>> where it doesn't work...
>>>
>>> Maybe try to provide a proof for the scenario where your test works, 
>>> viz when there is no emulation.  Then try to apply the proof to the 
>>> case where the "call" instructions occur in different emulation 
>>> levels, and you should see where the proof breaks down.
>>>
>>> Remember that "inner emulation trace entries" are not logically a 
>>> part of the outer processor execution trace.  It would be better to 
>>> think of them as interspersed "interpretations" that the outer 
>>> emulation code is making as it goes along.  The outer processor 
>>> execution trace is still continuing even if you choose to filter out 
>>> those entries, and in fact it is all that is driving the inner 
>>> emulations.  But it can just decide not emulate any more, effectively 
>>> "aborting" the inner emulation.  That aborting code need not be 
>>> visible in the block of trace entries between the two "call" 
>>> instructions.
>>>
>>>>> You can't magically make your claims true just be printing them out
>>>>> from a program!
>>>>>
>>>>> Hey, at least you took up my suggestion of including the emulation
>>>>> level in the trace - that was pretty much essential for tracking
>>>>> what's going on - but now it's obvious your calls are AT DIFFERENT
>>>>> EMULATION LEVELS - not really part of a "single processor trace" at
>>>>> all!  (Before, that was kind of obscured for readers not looking too
>>>>> closely, so it looked a bit like a trace of a genuine infinite 
>>>>> loop...)
>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> The execution trace shows that apparently H has the unbounded 
>>>>>> execution
>>>>>> and thus fails to meet its requirements (thus it doesn't matter if 
>>>>>> the
>>>>>> answer we got elsewhere is right or wrong).
>>>>>
>>>>> Well, we (really) can't tell that from the trace - what actually
>>>>> happens depends on future trace entries at EL0 which occur AFTER the
>>>>> two calls in the trace.  (And they wouldn't be in the trace anyway as
>>>>> PO selectively filters the trace entries he shows, but that's not the
>>>>> point).
>>>>>
>>>>> Anyway, the trace entries shown /don't imply/ infinite recursion -
>>>>> that's just something PO repeats over and over, because he doesn't
>>>>> understand why his test is fundamentally flawed.
>>>>>
>>>>
>>>> I see two possibilites neither one is plausible:
>>>> (1) You are lying
>>>> (2) This is over your head
>>>
>>> (3) This is over /your/ head
>>>
>>> but of course you wouldn't consider that possibility.
>>>
>>>>
>>>> Since it is probably not either one of those then I can't see why you
>>>> are saying this. Since you won't explain your reasoning then it is
>>>> correct to call you above statement vacuous.
>>>>
>>>>>>
>>>>>> Another possible error is that the trace skips some logic, which 
>>>>>> appear
>>>>>> to contain a condition that is part of H, thus the requirements of
>>>>>> detection of infinite recursion by recursion with no conditionals 
>>>>>> in the
>>>>>> loop is not meet.
>>>>>
>>>>> Or more simply, PO's infinite recursion test is UNSOUND.  (It simply
>>>>> does not imply infinite recursion when applied to scenarios where the
>>>>> two "call" trace entries BELONG TO DIFFERENT EMULATION LEVELS!  [As in
>>>>> above trace])   The issue of "conditionals in the loop" is quite moot
>>>>> here - even if there genuinely aren't any conditional branches "in the
>>>>> loop" that doesn't imply infinite recursion.  (So no point in accusing
>>>>> him of hiding them :) )
>>>>
>>>> I don't see how this is over your head and I don't accept that you are
>>>> lying. It is like I am saying that 2 + 3 = 5 and you say that what I
>>>> said is unsound.
>>>>
>>>>> I've told him that, but he just doesn't believe me.
>>>>
>>>> I never believe any damn thing any unproven assertion counts as an
>>>> assertion that was never even made.
>>>>
>>> You believe your own assertions, but are unable to prove them.  :)
>>>
>>>>> Also, he is unable to provide any coherent "proof" that his test works
>>>>> (of course, since it doesn't) - he just repeats one of his mantras
>>>>> about equivalent
>>>>
>>>> You are acting like Ben. I am totally wrong because you really really
>>>> don't believe me. That is not logic son, that is not even decent 
>>>> rhetoric.
>>>
>>> People do not have to accept what you say without you providing 
>>> proof. You are unable to do that.  (That will be the key point, when 
>>> it comes to how reviewers will treat your claims.)
>>>
>>> Mike.
>>>
>>
>> If it is clear to them that it is false on the basis of lack of proof 
>> this is a logic error known as ad  ignorantiam.
>>
>> I. Argumentum ad Ignorantiam: (appeal to ignorance) the fallacy that a 
>> proposition is true simply on the basis that it has not been proved 
>> false or that it is false simply because it has not been proved true. 
>> This error in reasoning is often expressed with influential rhetoric.
>> https://philosophy.lander.edu/logic/ignorance.html
>>
>> The proof (that you already acknowledged) is that any function call 
>> from the same machine address in the user code to the same function in 
>> the user code without any conditional branch instructions in-between 
>> does unequivocally specify infinite recursion in this user code 
>> execution trace.
>>
>> This is a logical necessity thus not correctly deniable.
> 
> The term "fractal wrongness" may also be used to refer to someone who is 
> consistently wrong on nearly everything they predict or claim. 
> Repeatedly failing predictions is one of the best ways of revealing 
> fractal wrongness, because while an idiotic worldview may work in 
> someone's head, it can be seen failing when actually put to the test. 
> Hilariously, people who are consistently wrong tend to be quite 
> confident in their position while championing it.
> 
> /Flibble
> 

So in other words the proof that I provided was beyond your technical 
skill level to comprehend so you are basing you assessment on what 
others seems to be saying, and not even what they actually are saying.

-- 
Copyright 2020 Pete Olcott

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

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


#2133 — Re: Refutation of Peter Linz HP proof [ Logical Necessity ]

FromJeff Barnett <jbb@notatt.com>
Date2020-12-06 16:59 -0700
SubjectRe: Refutation of Peter Linz HP proof [ Logical Necessity ]
Message-ID<rqjr8m$qet$1@dont-email.me>
In reply to#2125
On 12/6/2020 1:07 PM, olcott wrote:
> On 12/6/2020 1:59 PM, Mr Flibble wrote:
>> On 06/12/2020 19:18, olcott wrote:
>>> On 12/6/2020 12:46 PM, Mike Terry wrote:
>>>> On 06/12/2020 04:40, olcott wrote:
>>>>> On 12/5/2020 10:15 PM, Mike Terry wrote:
>>>>>> On 06/12/2020 02:12, Richard Damon wrote:
>>>>>>> On 12/5/20 8:49 PM, olcott wrote:
>>>>>>>> On 12/5/2020 7:44 PM, Jeff Barnett wrote:
>>>>>>>>> On 12/5/2020 4:35 PM, Richard Damon wrote:
>>>>>>>>>> On 12/5/20 5:25 PM, olcott wrote:
>>>>>>>>>>> On 12/5/2020 3:45 PM, Richard Damon wrote:
>>>>>>>>>>>> On 12/5/20 4:25 PM, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The fact that this is inherently infinitely recursive when
>>>>>>>>>>>>> executed with
>>>>>>>>>>>>> itself as input must be over your head.
>>>>>>>>>>>>>
>>>>>>>>>>>>> void H_Hat(u32 P)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>     u32 Input_Halts = Whatever_Simulator(P, P);
>>>>>>>>>>>>>     if (Input_Halts)
>>>>>>>>>>>>>       HERE: goto HERE;
>>>>>>>>>>>>>     else
>>>>>>>>>>>>>       HALT
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> No, I admit that the above program will be infinitely 
>>>>>>>>>>>> recurcive,
>>>>>>>>>>>> but the
>>>>>>>>>>>> program is mis-named, as that is NOT the H_Hat of Linz, that 
>>>>>>>>>>>> uses a
>>>>>>>>>>>> Halt
>>>>>>>>>>>> Detector, not a simulator. (You are great at using bad 
>>>>>>>>>>>> terminology)
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that you don't understand that seems amazing.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is is inherently infinitely recursive by any simulator
>>>>>>>>>>> then it is inherently infinitely recursive by a simulator
>>>>>>>>>>> that has halt deciding features.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And this is your flaw. Any execution inside of a Halt Decider 
>>>>>>>>>> can NOT
>>>>>>>>>> create non-halting execution to the machine that is calling 
>>>>>>>>>> that Halt
>>>>>>>>>> Decider, or the Halt Decider has failed its requirement of
>>>>>>>>>> deciding in
>>>>>>>>>> Finite Time.
>>>>>>>>>>
>>>>>>>>>> Yes, A Halt Decider based on a simulator will create an infinite
>>>>>>>>>> recursion INSIDE itself, but because of its requirements, it MUST
>>>>>>>>>> figure
>>>>>>>>>> out how to handle this problem. You don't.
>>>>>>>>>>
>>>>>>>>>>  From the trace, your halt decider has detected an infinte 
>>>>>>>>>> recursion,
>>>>>>>>>> true. Does this indicate non-halting behavior, unclear. There IS
>>>>>>>>>> apparently a conditional in the loop, is it is happening inside
>>>>>>>>>> the Halt
>>>>>>>>>> Decider, which if it works properly, will terminate the infinite
>>>>>>>>>> recursion, and then return an answer to its caller (but it has no
>>>>>>>>>> information to make a right decision). The other possibility is
>>>>>>>>>> that we
>>>>>>>>>> don't count that and what we have detected is that the Halt
>>>>>>>>>> Decider has
>>>>>>>>>> failed to make its decision and failed at being a decider.
>>>>>>>>>>
>>>>>>>>>> The fact that you abort the whole machine currently would seem to
>>>>>>>>>> imply
>>>>>>>>>> the second case.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> A clearer example that make it obvious is a different recursive
>>>>>>>>>> machine:
>>>>>>>>>>
>>>>>>>>>> int H2(u32 P) {
>>>>>>>>>>      return Halts(P, P);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> This machiine CLEARLY has identical halting properties to 
>>>>>>>>>> Halts, it
>>>>>>>>>> really has no significant code other than Halts. Running 
>>>>>>>>>> H2(H2) will
>>>>>>>>>> give essentially the same trace as that of H_Hat (since Halts 
>>>>>>>>>> will
>>>>>>>>>> never
>>>>>>>>>> return in any of the nested calls, so it can't see the
>>>>>>>>>> difference). The
>>>>>>>>>> fact that this program shows non-halting behavior show that it is
>>>>>>>>>> Halts
>>>>>>>>>> that has that problem. And per the problem definition, if it 
>>>>>>>>>> has this
>>>>>>>>>> sort of problem, it isn't a valid halting decider.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You may have had some idea that detecting this type of infinite
>>>>>>>>>> recursion whould get your around the problem, the issue is that
>>>>>>>>>> due to
>>>>>>>>>> how the halting problem is stated, the onus of solving the
>>>>>>>>>> recursion is
>>>>>>>>>> on the halt decider, so it doesn't provide an out.
>>>>>>>>>>
>>>>>>>>>> As I have mentioned at other times, you ARE free to adjust the
>>>>>>>>>> terms of
>>>>>>>>>> the halting problem, just if you do that you lose all ability to
>>>>>>>>>> claim
>>>>>>>>>> that you answer applies to it.
>>>>>>>>>
>>>>>>>>> I think we have learned a few things from these all too similar
>>>>>>>>> threads. The first is that PO is wrong in virtually all his 
>>>>>>>>> claims,
>>>>>>>>> and mostly incoherent in his arguments.
>>>>>>>>
>>>>>>>> If I was wrong you could point out a logic error:
>>>>>>>>
>>>>>>>> Actual debug trace of H() correctly deciding halting on H_Hat()
>>>>>>>>
>>>>>>>>
>>>>>>>> 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)   EMU_Level(0) 55                  push ebp
>>>>>>>> [00000611](02)   EMU_Level(0) 8bec                mov ebp,esp
>>>>>>>> [00000613](05)   EMU_Level(0) 68e0050000          push 000005e0
>>>>>>>> [00000618](05)   EMU_Level(0) 68e0050000          push 000005e0
>>>>>>>> [0000061d](05)   EMU_Level(0) e84efdffff          call 00000370
>>>>>>>> ----CALL
>>>>>>>> [00000370]
>>>>>>>> [000005e0](01)   EMU_Level(1) 55                  push ebp
>>>>>>>> [000005e1](02)   EMU_Level(1) 8bec                mov ebp,esp
>>>>>>>> [000005e3](01)   EMU_Level(1) 51                  push ecx
>>>>>>>> [000005e4](03)   EMU_Level(1) 8b4508              mov eax,[ebp+08]
>>>>>>>> [000005e7](01)   EMU_Level(1) 50                  push eax
>>>>>>>> [000005e8](03)   EMU_Level(1) 8b4d08              mov ecx,[ebp+08]
>>>>>>>> [000005eb](01)   EMU_Level(1) 51                  push ecx
>>>>>>>> [000005ec](05)   EMU_Level(1) e87ffdffff          call 00000370
>>>>>>>> ----CALL
>>>>>>>> [00000370]
>>>>>>>> [000005e0](01)   EMU_Level(2) 55                  push ebp
>>>>>>>> [000005e1](02)   EMU_Level(2) 8bec                mov ebp,esp
>>>>>>>> [000005e3](01)   EMU_Level(2) 51                  push ecx
>>>>>>>> [000005e4](03)   EMU_Level(2) 8b4508              mov eax,[ebp+08]
>>>>>>>> [000005e7](01)   EMU_Level(2) 50                  push eax
>>>>>>>> [000005e8](03)   EMU_Level(2) 8b4d08              mov ecx,[ebp+08]
>>>>>>>> [000005eb](01)   EMU_Level(2) 51                  push ecx
>>>>>>>> [000005ec](05)   EMU_Level(2) e87ffdffff          call 00000370
>>>>>>>> ----CALL
>>>>>>>> [00000370]
>>>>>>>> The PRIOR Instruction Specifies Infinite Recursion: Simulation 
>>>>>>>> Stopped:
>>>>>>>> Number of Instructions Executed(2777)
>>>>>>
>>>>>> @PO:
>>>>>> Eh, what?  No it doesn't!!
>>>>>>
>>>>>> The previous instruction "specifies" *call 00000370*.  It's only 
>>>>>> *YOU*
>>>>>> (aka your test in H's code) "specifying" that that means infinite
>>>>>> recursion.  You're ignoring the fact that your infinite recursion
>>>>>> detection test is UNSOUND.  (We've discussed this before.)
>>>>>
>>>>> Yes you declared that is is "unsound" without any supporting thus your
>>>>> basis is less than unsound it is totally vacuous.
>>>>
>>>> But YOU are the one making the claim here - so it's YOU who have to 
>>>> prove your claim.  I don't need to disprove it - claims are false by
>>>> default.
>>>>
>>>> The real problem here is that you are intellectually incapable of 
>>>> proving anything, and that is bad news because without a proper 
>>>> proof nobody will pay any serious attention to your claim.  This 
>>>> includes any peer-reviewers for your final article - they'll glance 
>>>> at it and see just a series of unproven claims, and quickly conclude 
>>>> "duffer!".
>>>>
>>>> It doesn't matter that you don't believe your test is unsound - it's 
>>>> the peer reviewers who count, and they will reject it since:
>>>> a)  you don't have a proof.
>>>> b)  it will be clear /to them/ that is false.
>>>>
>>>>>
>>>>>> Do you think that if your code contains a printf("The PRIOR
>>>>>> Instruction Specifies Infinite Recursion") that means there REALLY
>>>>>> MUST BE infinite recursion?
>>>>>
>>>>> We have been though this. each and every time that the same 
>>>>> function is
>>>>> called from the same machine address without any conditional branch
>>>>> intstruction in-between a pair of calls it always specifies infinite
>>>>> recursion as a mathematical formalism.
>>>>>
>>>> Hehe, another "magical phrase" : "..as a mathematical formalism". 
>>>> That just screams "crank".  You know that what you just said is not 
>>>> a proof, right?  (You are doing exactly what I said - just repeating 
>>>> your claim and sprinkling in some magical phrases in place of a proof.)
>>>>
>>>> I note that your statement of the test makes no mention of the fact 
>>>> that the pair of calls can be in different emulation levels.  
>>>> Perhaps you're trying to trick people into reading it as applying to 
>>>> a "single processor" execution trace (no emulation trace entries), 
>>>> where your test /would/ be sound?  Then having tricked people into 
>>>> accepting that, you sneak in applications to an emulation 
>>>> environment where it doesn't work...
>>>>
>>>> Maybe try to provide a proof for the scenario where your test works, 
>>>> viz when there is no emulation.  Then try to apply the proof to the 
>>>> case where the "call" instructions occur in different emulation 
>>>> levels, and you should see where the proof breaks down.
>>>>
>>>> Remember that "inner emulation trace entries" are not logically a 
>>>> part of the outer processor execution trace.  It would be better to 
>>>> think of them as interspersed "interpretations" that the outer 
>>>> emulation code is making as it goes along.  The outer processor 
>>>> execution trace is still continuing even if you choose to filter out 
>>>> those entries, and in fact it is all that is driving the inner 
>>>> emulations.  But it can just decide not emulate any more, 
>>>> effectively "aborting" the inner emulation.  That aborting code need 
>>>> not be visible in the block of trace entries between the two "call" 
>>>> instructions.
>>>>
>>>>>> You can't magically make your claims true just be printing them out
>>>>>> from a program!
>>>>>>
>>>>>> Hey, at least you took up my suggestion of including the emulation
>>>>>> level in the trace - that was pretty much essential for tracking
>>>>>> what's going on - but now it's obvious your calls are AT DIFFERENT
>>>>>> EMULATION LEVELS - not really part of a "single processor trace" at
>>>>>> all!  (Before, that was kind of obscured for readers not looking too
>>>>>> closely, so it looked a bit like a trace of a genuine infinite 
>>>>>> loop...)
>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> The execution trace shows that apparently H has the unbounded 
>>>>>>> execution
>>>>>>> and thus fails to meet its requirements (thus it doesn't matter 
>>>>>>> if the
>>>>>>> answer we got elsewhere is right or wrong).
>>>>>>
>>>>>> Well, we (really) can't tell that from the trace - what actually
>>>>>> happens depends on future trace entries at EL0 which occur AFTER the
>>>>>> two calls in the trace.  (And they wouldn't be in the trace anyway as
>>>>>> PO selectively filters the trace entries he shows, but that's not the
>>>>>> point).
>>>>>>
>>>>>> Anyway, the trace entries shown /don't imply/ infinite recursion -
>>>>>> that's just something PO repeats over and over, because he doesn't
>>>>>> understand why his test is fundamentally flawed.
>>>>>>
>>>>>
>>>>> I see two possibilites neither one is plausible:
>>>>> (1) You are lying
>>>>> (2) This is over your head
>>>>
>>>> (3) This is over /your/ head
>>>>
>>>> but of course you wouldn't consider that possibility.
>>>>
>>>>>
>>>>> Since it is probably not either one of those then I can't see why you
>>>>> are saying this. Since you won't explain your reasoning then it is
>>>>> correct to call you above statement vacuous.
>>>>>
>>>>>>>
>>>>>>> Another possible error is that the trace skips some logic, which 
>>>>>>> appear
>>>>>>> to contain a condition that is part of H, thus the requirements of
>>>>>>> detection of infinite recursion by recursion with no conditionals 
>>>>>>> in the
>>>>>>> loop is not meet.
>>>>>>
>>>>>> Or more simply, PO's infinite recursion test is UNSOUND.  (It simply
>>>>>> does not imply infinite recursion when applied to scenarios where the
>>>>>> two "call" trace entries BELONG TO DIFFERENT EMULATION LEVELS!  
>>>>>> [As in
>>>>>> above trace])   The issue of "conditionals in the loop" is quite moot
>>>>>> here - even if there genuinely aren't any conditional branches "in 
>>>>>> the
>>>>>> loop" that doesn't imply infinite recursion.  (So no point in 
>>>>>> accusing
>>>>>> him of hiding them :) )
>>>>>
>>>>> I don't see how this is over your head and I don't accept that you are
>>>>> lying. It is like I am saying that 2 + 3 = 5 and you say that what I
>>>>> said is unsound.
>>>>>
>>>>>> I've told him that, but he just doesn't believe me.
>>>>>
>>>>> I never believe any damn thing any unproven assertion counts as an
>>>>> assertion that was never even made.
>>>>>
>>>> You believe your own assertions, but are unable to prove them.  :)
>>>>
>>>>>> Also, he is unable to provide any coherent "proof" that his test 
>>>>>> works
>>>>>> (of course, since it doesn't) - he just repeats one of his mantras
>>>>>> about equivalent
>>>>>
>>>>> You are acting like Ben. I am totally wrong because you really really
>>>>> don't believe me. That is not logic son, that is not even decent 
>>>>> rhetoric.
>>>>
>>>> People do not have to accept what you say without you providing 
>>>> proof. You are unable to do that.  (That will be the key point, when 
>>>> it comes to how reviewers will treat your claims.)
>>>>
>>>> Mike.
>>>>
>>>
>>> If it is clear to them that it is false on the basis of lack of proof 
>>> this is a logic error known as ad  ignorantiam.
>>>
>>> I. Argumentum ad Ignorantiam: (appeal to ignorance) the fallacy that 
>>> a proposition is true simply on the basis that it has not been proved 
>>> false or that it is false simply because it has not been proved true. 
>>> This error in reasoning is often expressed with influential rhetoric.
>>> https://philosophy.lander.edu/logic/ignorance.html
>>>
>>> The proof (that you already acknowledged) is that any function call 
>>> from the same machine address in the user code to the same function 
>>> in the user code without any conditional branch instructions 
>>> in-between does unequivocally specify infinite recursion in this user 
>>> code execution trace.
>>>
>>> This is a logical necessity thus not correctly deniable.
>>
>> The term "fractal wrongness" may also be used to refer to someone who 
>> is consistently wrong on nearly everything they predict or claim. 
>> Repeatedly failing predictions is one of the best ways of revealing 
>> fractal wrongness, because while an idiotic worldview may work in 
>> someone's head, it can be seen failing when actually put to the test. 
>> Hilariously, people who are consistently wrong tend to be quite 
>> confident in their position while championing it.
>>
>> /Flibble
>>
> 
> So in other words the proof that I provided was beyond your technical 
> skill level to comprehend so you are basing you assessment on what 
> others seems to be saying, and not even what they actually are saying.

Mr. Fibble forgot to mention one of the more important (telling?) 
attributes of fractal wrongness: As a dialogue burrows down into more 
and smaller details, the sufferer continues to be wrong at every level 
while confidence grows. That's really an important part of the 
definition. Without the level concept, the person is merely called a 
fucktard. As we can see, over the decades PO has progressed from the 
latter to the former. Perhaps we should trow him a celebration (virtual 
of course with the current pandemic) to honor his progression over the 
decades from a dull troll to a moron of distinction! Is it Zoom for all 
of us? Or?
-- 
Jeff Barnett

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


#2126 — Re: Refutation of Peter Linz HP proof [ Logical Necessity ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-06 14:29 -0600
SubjectRe: Refutation of Peter Linz HP proof [ Logical Necessity ]
Message-ID<5cudnbP1pqalolDCnZ2dnUU7-XnNnZ2d@giganews.com>
In reply to#2122
On 12/6/2020 2:10 PM, Mike Terry wrote:
> On 06/12/2020 19:18, olcott wrote:
>> On 12/6/2020 12:46 PM, Mike Terry wrote:
>>> On 06/12/2020 04:40, olcott wrote:
>>>> On 12/5/2020 10:15 PM, Mike Terry wrote:
> <.. snip ..>
>>>>>
>>>>> Or more simply, PO's infinite recursion test is UNSOUND.  (It simply
>>>>> does not imply infinite recursion when applied to scenarios where the
>>>>> two "call" trace entries BELONG TO DIFFERENT EMULATION LEVELS!  [As in
>>>>> above trace])   The issue of "conditionals in the loop" is quite moot
>>>>> here - even if there genuinely aren't any conditional branches "in the
>>>>> loop" that doesn't imply infinite recursion.  (So no point in accusing
>>>>> him of hiding them :) )
>>>>
>>>> I don't see how this is over your head and I don't accept that you are
>>>> lying. It is like I am saying that 2 + 3 = 5 and you say that what I
>>>> said is unsound.
>>>>
>>>>> I've told him that, but he just doesn't believe me.
>>>>
>>>> I never believe any damn thing any unproven assertion counts as an
>>>> assertion that was never even made.
>>>>
>>> You believe your own assertions, but are unable to prove them.  :)
>>>
>>>>> Also, he is unable to provide any coherent "proof" that his test works
>>>>> (of course, since it doesn't) - he just repeats one of his mantras
>>>>> about equivalent
>>>>
>>>> You are acting like Ben. I am totally wrong because you really really
>>>> don't believe me. That is not logic son, that is not even decent
>>>> rhetoric.
>>>
>>> People do not have to accept what you say without you providing proof.
>>> You are unable to do that.  (That will be the key point, when it comes
>>> to how reviewers will treat your claims.)
>>>
>>> Mike.
>>>
>>
>> If it is clear to them that it is false on the basis of lack of proof
>> this is a logic error known as ad  ignorantiam.
> 
> I never said that was the basis.
> 
> <.. snip ..>
>> The proof (that you already acknowledged) is that any function call from
>> the same machine address in the user code to the same function in the
>> user code without any conditional branch instructions in-between does
>> unequivocally specify infinite recursion in this user code execution 
>> trace.
> 
> 1)  That is not a proof of anything - it's A CLAIM.

Within the x86 language and the scope of the execution trace of the 
local code being examined it is a logical necessity and you know this.

>      Boy, you're dumber than a really dumb dumbo.  Do you really
>      not understand that you've just repeated your claim word for
>      word?  How can that be a proof of your claim?

It is like I am talking to someone that disagrees with arithmetic.
Disagreement does not change the logical necessity.

> 2)  I never acknowledged that claim.  You would have to add
>      more than one qualification to get anywhere close to something
>      I agreed with.

So you are claiming now that there is no objective measure to determine 
infinite recursion and thus infinite recursion is only in the mind of 
the beholder? (not a wise position to take).

> Look, you're not capable of understanding what other people agree or 
> disagree with, or what they've previously acknowledged etc. so you would 
> do well to simply avoid introducing any such concerns into your arguments.
> 
>>
>> This is a logical necessity thus not correctly deniable.
>>
> 
> It's not a proof of anything, just a claim.  NOT a logical necessity. 

So you are claiming now that there is no objective measure to determine 
infinite recursion and thus infinite recursion is only in the mind of 
the beholder? (not a wise position to take).

> You are showing that you don't understand "proof" or "logical 
> necessity", so how on earth do you expect to convince anyone you've 
> understood the HP/Linz proof, let alone "refuted" it!
> 
> 
> Mike.
> 


-- 
Copyright 2020 Pete Olcott

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

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


#2136 — Re: Refutation of Peter Linz HP proof [ Logical Necessity ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-07 14:16 -0600
SubjectRe: Refutation of Peter Linz HP proof [ Logical Necessity ]
Message-ID<or6dnTmhC-kfEFPCnZ2dnUU7-VfNnZ2d@giganews.com>
In reply to#2126
On 12/7/2020 1:40 PM, Kaz Kylheku wrote:
> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>> On 12/7/2020 11:37 AM, Mike Terry wrote:
>>> On 07/12/2020 17:28, olcott wrote:
>>>> On 12/7/2020 11:22 AM, Mike Terry wrote:
>>>>> On 07/12/2020 04:17, olcott wrote:
>>>>>> On 12/6/2020 5:36 PM, Mike Terry wrote:
>>>>>>> On 06/12/2020 20:29, olcott wrote:
>>>>>>>> On 12/6/2020 2:10 PM, Mike Terry wrote:
>>>>>>>>> On 06/12/2020 19:18, olcott wrote:
>>>>>>>>>> On 12/6/2020 12:46 PM, Mike Terry wrote:
>>>>>>>>>>> On 06/12/2020 04:40, olcott wrote:
>>>>>>>>>>>> On 12/5/2020 10:15 PM, Mike Terry wrote:
>>>>>>>>> <.. snip ..>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Or more simply, PO's infinite recursion test is UNSOUND.  (It
>>>>>>>>>>>>> simply
>>>>>>>>>>>>> does not imply infinite recursion when applied to scenarios
>>>>>>>>>>>>> where the
>>>>>>>>>>>>> two "call" trace entries BELONG TO DIFFERENT EMULATION LEVELS!
>>>>>>>>>>>>> [As in
>>>>>>>>>>>>> above trace])   The issue of "conditionals in the loop" is quite
>>>>>>>>>>>>> moot
>>>>>>>>>>>>> here - even if there genuinely aren't any conditional branches
>>>>>>>>>>>>> "in
>>>>>>>>>>>>> the
>>>>>>>>>>>>> loop" that doesn't imply infinite recursion.  (So no point in
>>>>>>>>>>>>> accusing
>>>>>>>>>>>>> him of hiding them :) )
>>>>>>>>>>>>
>>>>>>>>>>>> I don't see how this is over your head and I don't accept that
>>>>>>>>>>>> you are
>>>>>>>>>>>> lying. It is like I am saying that 2 + 3 = 5 and you say that
>>>>>>>>>>>> what I
>>>>>>>>>>>> said is unsound.
>>>>>>>>>>>>
>>>>>>>>>>>>> I've told him that, but he just doesn't believe me.
>>>>>>>>>>>>
>>>>>>>>>>>> I never believe any damn thing any unproven assertion counts
>>>>>>>>>>>> as an
>>>>>>>>>>>> assertion that was never even made.
>>>>>>>>>>>>
>>>>>>>>>>> You believe your own assertions, but are unable to prove them.  :)
>>>>>>>>>>>
>>>>>>>>>>>>> Also, he is unable to provide any coherent "proof" that his test
>>>>>>>>>>>>> works
>>>>>>>>>>>>> (of course, since it doesn't) - he just repeats one of his
>>>>>>>>>>>>> mantras
>>>>>>>>>>>>> about equivalent
>>>>>>>>>>>>
>>>>>>>>>>>> You are acting like Ben. I am totally wrong because you really
>>>>>>>>>>>> really
>>>>>>>>>>>> don't believe me. That is not logic son, that is not even decent
>>>>>>>>>>>> rhetoric.
>>>>>>>>>>>
>>>>>>>>>>> People do not have to accept what you say without you providing
>>>>>>>>>>> proof.
>>>>>>>>>>> You are unable to do that.  (That will be the key point, when it
>>>>>>>>>>> comes
>>>>>>>>>>> to how reviewers will treat your claims.)
>>>>>>>>>>>
>>>>>>>>>>> Mike.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If it is clear to them that it is false on the basis of lack of
>>>>>>>>>> proof
>>>>>>>>>> this is a logic error known as ad  ignorantiam.
>>>>>>>>>
>>>>>>>>> I never said that was the basis.
>>>>>>>>>
>>>>>>>>> <.. snip ..>
>>>>>>>>>> The proof (that you already acknowledged) is that any function call
>>>>>>>>>> from
>>>>>>>>>> the same machine address in the user code to the same function in
>>>>>>>>>> the
>>>>>>>>>> user code without any conditional branch instructions in-between
>>>>>>>>>> does
>>>>>>>>>> unequivocally specify infinite recursion in this user code
>>>>>>>>>> execution
>>>>>>>>>> trace.
>>>>>>>>>
>>>>>>>>> 1)  That is not a proof of anything - it's A CLAIM.
>>>>>>>>
>>>>>>>> Within the x86 language and the scope of the execution trace of the
>>>>>>>> local code being examined it is a logical necessity and you know
>>>>>>>> this.
>>>>>>>>
>>>>>>>
>>>>>>> It is not a logical necessity.  The fact that you can't give any
>>>>>>> reason for your belief other than "it's a logical necessity" must give
>>>>>>> you cause for concern - why don't you prove it?
>>>>>>
>>>>>>
>>>>>> // This code specifies an infinite loop
>>>>>> int main()
>>>>>> {
>>>>>>    HERE: goto HERE;
>>>>>> }
>>>>>
>>>>> Yes.
>>>>>
>>>>>>
>>>>>>
>>>>>> // This code specifies infinite recursion until stack space is
>>>>>> exhausted
>>>>>> void Recursion()
>>>>>> {
>>>>>>    Recursion();
>>>>>> }
>>>>>
>>>>> Yes.  (But maybe the compiler will optimise this in a way you don't
>>>>> expect, as Ben pointed out.)
>>>>>
>>>> So you agree that the minimal cases of an infinite loops and infinite
>>>> recursion can be detected without waiting forever and then AFTER forever
>>>> deciding that these were actually infinite.
>>>>
>>>> What about this:
>>>>
>>>> This is my 2018-12-13 solution: Every time the same function is called a
>>>> second time from the same machine address with no control flow
>>>> instructions** in-between we can know that this is definitely infinite
>>>> recursion.
>>>>
>>>> ** A simplification of the original criteria to make my proof easier to
>>>> understand.
>>>
>>> Are you saying the block of trace entries under consideration (bracketed
>>> by the two call instructions) ARE ALL WITHIN A SINGLE EMULATION LEVEL?
>>>
>>> If yes, then as I said, I would probably agree that the test is sound
>>> (subject to detailed wording etc.).
>>>
>>> If no, then as I said, that test is unsound.
>>>
>>>
>>> Mike.
>>>
>>
>> Yes and by unsound you means something is wrong with it somewhere but
>> you cannot say what or why because you are bypassing logic and leaping
>> to intuition with no reasoning in-between.
> 
> The thing which is wrong with your test apparatus is that you're only
> showing that trivial looping/recursion behavior in the test case is
> detectable by some easy tests that can be done in the virtual machine.
> 
> Your execution runs are certainly showing that something is possible,
> but that something is not the object of the halting proofs. Those
> proofs say that something else is impossible, namely that Halts
> can the correct value.
> 
> Your test setup does not show that Halt can be defined in a way that it
> returns the correct value; i.e does not refute this core proposition.
> 
> You have acknowledged this issue, but are bizarrely downplaying its
> importance, promising that you will have a fix for it in about a week,
> and that in spite of this problem, you insist that, already today, you
> have a "correct refutation".

It <is> only an interface issue and nothing more.

> How is it that you can believe you have "correct refutation" now, if the
> core proposition isn't being addressed???
> 
> If you don't believe the halting theorem, then having a working machine
> that can detect loops and recursions may feel emboldening and
> encouraging, sure. But, by itself, that machinery does not amount to a
> "correct refutation" of anything.

An actual Turing machine based on adapting a UTM to become a halt 
decider does correctly decide the essential Ĥ template used by Linz and 
apparently also Sipser when applying my model of halt deciding.

This actual Turing machine would be able to transition to its 
appropriate final state.

Since the C programming language has main() as its top level when my 
halt decider correctly decides not halting on main() it has no where to 
return a value to because it must return its answer to a level higher 
than main().

> You seem to believe that, since CS has something to do with computers,
> doing CS academics can be conducted like a software project. You can
> ship a prototype which you believe sort of works, make wild claims
> about it, and then just quietly work out some bugs in the next release
> without substantially changing the structure: the users will hardly
> notice anything had changed!
> 


-- 
Copyright 2020 Pete Olcott

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

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


#2138 — Re: Refutation of Peter Linz HP proof [ Logical Necessity ]

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-07 21:16 +0000
SubjectRe: Refutation of Peter Linz HP proof [ Logical Necessity ]
Message-ID<20201207124616.535@kylheku.com>
In reply to#2136
On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
> On 12/7/2020 1:40 PM, Kaz Kylheku wrote:
>> Your test setup does not show that Halt can be defined in a way that it
>> returns the correct value; i.e does not refute this core proposition.
>> 
>> You have acknowledged this issue, but are bizarrely downplaying its
>> importance, promising that you will have a fix for it in about a week,
>> and that in spite of this problem, you insist that, already today, you
>> have a "correct refutation".
>
> It <is> only an interface issue and nothing more.

Is it? Can you describe the issue as an interface issue? I mean using
sentences that refer to interfaces and their properties, articulating
what is wrong or missing?

What is the first step toward solving or eliminating the interface
issue?

Do you have everything you need to solve the problem? Or is it necessary
to investigate, in order to obtain some information?

How did you estimate seven days for solving it?

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


#2139 — Re: Refutation of Peter Linz HP proof [ Logical Necessity ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-07 15:21 -0600
SubjectRe: Refutation of Peter Linz HP proof [ Logical Necessity ]
Message-ID<3sednStk-M1RAVPCnZ2dnUU7-QfNnZ2d@giganews.com>
In reply to#2138
On 12/7/2020 3:16 PM, Kaz Kylheku wrote:
> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>> On 12/7/2020 1:40 PM, Kaz Kylheku wrote:
>>> Your test setup does not show that Halt can be defined in a way that it
>>> returns the correct value; i.e does not refute this core proposition.
>>>
>>> You have acknowledged this issue, but are bizarrely downplaying its
>>> importance, promising that you will have a fix for it in about a week,
>>> and that in spite of this problem, you insist that, already today, you
>>> have a "correct refutation".
>>
>> It <is> only an interface issue and nothing more.
> 
> Is it? Can you describe the issue as an interface issue? I mean using
> sentences that refer to interfaces and their properties, articulating
> what is wrong or missing?
> 
> What is the first step toward solving or eliminating the interface
> issue?
> 
> Do you have everything you need to solve the problem? Or is it necessary
> to investigate, in order to obtain some information?
> 
> How did you estimate seven days for solving it?
> 

I will be able to simply return an integer value
to an invocation of Halts in main() like this:

int main()
{
   u32 Input_Halted = Halts((u32)H_Hat, (u32)H_Hat);
   Output("Input_Halted =", Input_Halted);
}

-- 
Copyright 2020 Pete Olcott

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

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


#2140 — Re: Refutation of Peter Linz HP proof [ Logical Necessity ]

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-07 22:10 +0000
SubjectRe: Refutation of Peter Linz HP proof [ Logical Necessity ]
Message-ID<20201207135654.873@kylheku.com>
In reply to#2139
On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
> On 12/7/2020 3:16 PM, Kaz Kylheku wrote:
>> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>>> On 12/7/2020 1:40 PM, Kaz Kylheku wrote:
>>>> Your test setup does not show that Halt can be defined in a way that it
>>>> returns the correct value; i.e does not refute this core proposition.
>>>>
>>>> You have acknowledged this issue, but are bizarrely downplaying its
>>>> importance, promising that you will have a fix for it in about a week,
>>>> and that in spite of this problem, you insist that, already today, you
>>>> have a "correct refutation".
>>>
>>> It <is> only an interface issue and nothing more.
>> 
>> Is it? Can you describe the issue as an interface issue? I mean using
>> sentences that refer to interfaces and their properties, articulating
>> what is wrong or missing?
>> 
>> What is the first step toward solving or eliminating the interface
>> issue?
>> 
>> Do you have everything you need to solve the problem? Or is it necessary
>> to investigate, in order to obtain some information?
>> 
>> How did you estimate seven days for solving it?
>> 
>
> I will be able to simply return an integer value
> to an invocation of Halts in main() like this:
>
> int main()
> {
>    u32 Input_Halted = Halts((u32)H_Hat, (u32)H_Hat);
>    Output("Input_Halted =", Input_Halted);
> }

OK that would be a fine top-level driver program. But then H_Hat itself
also internally calls

  Halts((u32)H_Hat, (u32)H_Hat).

right? That function is necessarily the same Halts and is receiving the
same argumenst, so it is required to return exactly the same value that
is seen in main.

(These are all pure functions; they can't be procedures that return
different values at different times for he same arguments; that would be
completely invalid.)

And H_Hat uses that value to behave in the opposite manner to what that
value says; it doesn't halt when the value says halt.

But, never mind, you've "correctly refuted" all that; it's just an
interface problem to solve, which you're sure you can pull off by next
weekend.

-- 
TXR Programming Language: http://nongnu.org/txr

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


#2141 — Re: Refutation of Peter Linz HP proof [ Logical Necessity ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-07 16:26 -0600
SubjectRe: Refutation of Peter Linz HP proof [ Logical Necessity ]
Message-ID<R9ydnSCS65S2MVPCnZ2dnUU7-T_NnZ2d@giganews.com>
In reply to#2140
On 12/7/2020 4:10 PM, Kaz Kylheku wrote:
> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>> On 12/7/2020 3:16 PM, Kaz Kylheku wrote:
>>> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>>>> On 12/7/2020 1:40 PM, Kaz Kylheku wrote:
>>>>> Your test setup does not show that Halt can be defined in a way that it
>>>>> returns the correct value; i.e does not refute this core proposition.
>>>>>
>>>>> You have acknowledged this issue, but are bizarrely downplaying its
>>>>> importance, promising that you will have a fix for it in about a week,
>>>>> and that in spite of this problem, you insist that, already today, you
>>>>> have a "correct refutation".
>>>>
>>>> It <is> only an interface issue and nothing more.
>>>
>>> Is it? Can you describe the issue as an interface issue? I mean using
>>> sentences that refer to interfaces and their properties, articulating
>>> what is wrong or missing?
>>>
>>> What is the first step toward solving or eliminating the interface
>>> issue?
>>>
>>> Do you have everything you need to solve the problem? Or is it necessary
>>> to investigate, in order to obtain some information?
>>>
>>> How did you estimate seven days for solving it?
>>>
>>
>> I will be able to simply return an integer value
>> to an invocation of Halts in main() like this:
>>
>> int main()
>> {
>>     u32 Input_Halted = Halts((u32)H_Hat, (u32)H_Hat);
>>     Output("Input_Halted =", Input_Halted);
>> }
> 
> OK that would be a fine top-level driver program. But then H_Hat itself
> also internally calls
> 
>    Halts((u32)H_Hat, (u32)H_Hat).
> 
> right? That function is necessarily the same Halts and is receiving the
> same argumenst, so it is required to return exactly the same value that
> is seen in main.
> 

No, not at all, not in the least little bit.

My key innovation is to abort the simulation of an infinitely recursive 
invocation. Infinitely recursive invocations never receive any return 
value.

On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
 > A computation that would not halt if its simulation were not
 > halted is indeed a non-halting computation.

On Saturday, November 28, 2020 at 2:00:28 PM UTC-8, olcott wrote:
 > Every computation that would not halt if its simulation
 > were not halted is by logical necessity a non-halting computation.



-- 
Copyright 2020 Pete Olcott

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

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


#2143 — Re: Refutation of Peter Linz HP proof [ Logical Necessity ]

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-08 02:03 +0000
SubjectRe: Refutation of Peter Linz HP proof [ Logical Necessity ]
Message-ID<20201207170742.79@kylheku.com>
In reply to#2141
["Followup-To:" header set to comp.theory.]
On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
> On 12/7/2020 4:10 PM, Kaz Kylheku wrote:
>> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>>> On 12/7/2020 3:16 PM, Kaz Kylheku wrote:
>>>> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 12/7/2020 1:40 PM, Kaz Kylheku wrote:
>>>>>> Your test setup does not show that Halt can be defined in a way that it
>>>>>> returns the correct value; i.e does not refute this core proposition.
>>>>>>
>>>>>> You have acknowledged this issue, but are bizarrely downplaying its
>>>>>> importance, promising that you will have a fix for it in about a week,
>>>>>> and that in spite of this problem, you insist that, already today, you
>>>>>> have a "correct refutation".
>>>>>
>>>>> It <is> only an interface issue and nothing more.
>>>>
>>>> Is it? Can you describe the issue as an interface issue? I mean using
>>>> sentences that refer to interfaces and their properties, articulating
>>>> what is wrong or missing?
>>>>
>>>> What is the first step toward solving or eliminating the interface
>>>> issue?
>>>>
>>>> Do you have everything you need to solve the problem? Or is it necessary
>>>> to investigate, in order to obtain some information?
>>>>
>>>> How did you estimate seven days for solving it?
>>>>
>>>
>>> I will be able to simply return an integer value
>>> to an invocation of Halts in main() like this:
>>>
>>> int main()
>>> {
>>>     u32 Input_Halted = Halts((u32)H_Hat, (u32)H_Hat);
>>>     Output("Input_Halted =", Input_Halted);
>>> }
>> 
>> OK that would be a fine top-level driver program. But then H_Hat itself
>> also internally calls
>> 
>>    Halts((u32)H_Hat, (u32)H_Hat).
>> 
>> right? That function is necessarily the same Halts and is receiving the
>> same argumenst, so it is required to return exactly the same value that
>> is seen in main.
>> 
>
> No, not at all, not in the least little bit.
>
> My key innovation is to abort the simulation of an infinitely recursive 
> invocation. Infinitely recursive invocations never receive any return 
> value.

Right, so if Halts(H_Hat, H_Hat) doesn't return when called by H_Hat,
since it doesn't return at all, then H_Hat has no opportunity to
misbehave: H_Hat cannot "do the opposite" until it receives a return
value.

However, note that if Halts(H_Hat, H_Hat) doesn't return when called by H_Hat,
it also doesn't return when called by main():

 int main()
 {
   u32 Input_Halted = Halts((u32)H_Hat, (u32)H_Hat);

   // Does not reach here

   Output("Input_Halted =", Input_Halted);
 }

So that represents a failure to decide.

Halts is not only screwed in the situation when it stops and returns
a value to H_Hat, whereby H_Hat subsequently behaves otherwise.

It's also screwed in he situation when it doesn't return.

-- 
TXR Programming Language: http://nongnu.org/txr

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


#2146 — Re: Refutation of Peter Linz HP proof [ divide by zero error returns no value ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-07 20:22 -0600
SubjectRe: Refutation of Peter Linz HP proof [ divide by zero error returns no value ]
Message-ID<K5ydneuBEa3pflPCnZ2dnUU7-WnNnZ2d@giganews.com>
In reply to#2143
On 12/7/2020 8:03 PM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>> On 12/7/2020 4:10 PM, Kaz Kylheku wrote:
>>> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>>>> On 12/7/2020 3:16 PM, Kaz Kylheku wrote:
>>>>> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 12/7/2020 1:40 PM, Kaz Kylheku wrote:
>>>>>>> Your test setup does not show that Halt can be defined in a way that it
>>>>>>> returns the correct value; i.e does not refute this core proposition.
>>>>>>>
>>>>>>> You have acknowledged this issue, but are bizarrely downplaying its
>>>>>>> importance, promising that you will have a fix for it in about a week,
>>>>>>> and that in spite of this problem, you insist that, already today, you
>>>>>>> have a "correct refutation".
>>>>>>
>>>>>> It <is> only an interface issue and nothing more.
>>>>>
>>>>> Is it? Can you describe the issue as an interface issue? I mean using
>>>>> sentences that refer to interfaces and their properties, articulating
>>>>> what is wrong or missing?
>>>>>
>>>>> What is the first step toward solving or eliminating the interface
>>>>> issue?
>>>>>
>>>>> Do you have everything you need to solve the problem? Or is it necessary
>>>>> to investigate, in order to obtain some information?
>>>>>
>>>>> How did you estimate seven days for solving it?
>>>>>
>>>>
>>>> I will be able to simply return an integer value
>>>> to an invocation of Halts in main() like this:
>>>>
>>>> int main()
>>>> {
>>>>      u32 Input_Halted = Halts((u32)H_Hat, (u32)H_Hat);
>>>>      Output("Input_Halted =", Input_Halted);
>>>> }
>>>
>>> OK that would be a fine top-level driver program. But then H_Hat itself
>>> also internally calls
>>>
>>>     Halts((u32)H_Hat, (u32)H_Hat).
>>>
>>> right? That function is necessarily the same Halts and is receiving the
>>> same argumenst, so it is required to return exactly the same value that
>>> is seen in main.
>>>
>>
>> No, not at all, not in the least little bit.
>>
>> My key innovation is to abort the simulation of an infinitely recursive
>> invocation. Infinitely recursive invocations never receive any return
>> value.
> 
> Right, so if Halts(H_Hat, H_Hat) doesn't return when called by H_Hat,
> since it doesn't return at all, then H_Hat has no opportunity to
> misbehave: H_Hat cannot "do the opposite" until it receives a return
> value.
> 
> However, note that if Halts(H_Hat, H_Hat) doesn't return when called by H_Hat,
> it also doesn't return when called by main():
> 
>   int main()
>   {
>     u32 Input_Halted = Halts((u32)H_Hat, (u32)H_Hat);
> 
>     // Does not reach here
> 
>     Output("Input_Halted =", Input_Halted);
>   }
> 
> So that represents a failure to decide.

Like I already said and you simply ignored Halts() is invoked on main() 
at a level higher than main() so in the C model of computation is has no 
where to return to in the C program.

When the operating system terminates a program because of a divide by 
zero error we cannot correctly say that that the operating system did 
not make a decision or did not return a value. It is the same case with 
global halts.

> Halts is not only screwed in the situation when it stops and returns
> a value to H_Hat, whereby H_Hat subsequently behaves otherwise.
> 
> It's also screwed in he situation when it doesn't return.
> 


-- 
Copyright 2020 Pete Olcott

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

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


#2148 — Re: Refutation of Peter Linz HP proof [ divide by zero error returns no value ]

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-08 03:09 +0000
SubjectRe: Refutation of Peter Linz HP proof [ divide by zero error returns no value ]
Message-ID<20201207185749.493@kylheku.com>
In reply to#2146
["Followup-To:" header set to comp.theory.]
On 2020-12-08, olcott <NoOne@NoWhere.com> wrote:
> On 12/7/2020 8:03 PM, Kaz Kylheku wrote:
>> ["Followup-To:" header set to comp.theory.]
>> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>>> On 12/7/2020 4:10 PM, Kaz Kylheku wrote:
>>>> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 12/7/2020 3:16 PM, Kaz Kylheku wrote:
>>>>>> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 12/7/2020 1:40 PM, Kaz Kylheku wrote:
>>>>>>>> Your test setup does not show that Halt can be defined in a way that it
>>>>>>>> returns the correct value; i.e does not refute this core proposition.
>>>>>>>>
>>>>>>>> You have acknowledged this issue, but are bizarrely downplaying its
>>>>>>>> importance, promising that you will have a fix for it in about a week,
>>>>>>>> and that in spite of this problem, you insist that, already today, you
>>>>>>>> have a "correct refutation".
>>>>>>>
>>>>>>> It <is> only an interface issue and nothing more.
>>>>>>
>>>>>> Is it? Can you describe the issue as an interface issue? I mean using
>>>>>> sentences that refer to interfaces and their properties, articulating
>>>>>> what is wrong or missing?
>>>>>>
>>>>>> What is the first step toward solving or eliminating the interface
>>>>>> issue?
>>>>>>
>>>>>> Do you have everything you need to solve the problem? Or is it necessary
>>>>>> to investigate, in order to obtain some information?
>>>>>>
>>>>>> How did you estimate seven days for solving it?
>>>>>>
>>>>>
>>>>> I will be able to simply return an integer value
>>>>> to an invocation of Halts in main() like this:
>>>>>
>>>>> int main()
>>>>> {
>>>>>      u32 Input_Halted = Halts((u32)H_Hat, (u32)H_Hat);
>>>>>      Output("Input_Halted =", Input_Halted);
>>>>> }
>>>>
>>>> OK that would be a fine top-level driver program. But then H_Hat itself
>>>> also internally calls
>>>>
>>>>     Halts((u32)H_Hat, (u32)H_Hat).
>>>>
>>>> right? That function is necessarily the same Halts and is receiving the
>>>> same argumenst, so it is required to return exactly the same value that
>>>> is seen in main.
>>>>
>>>
>>> No, not at all, not in the least little bit.
>>>
>>> My key innovation is to abort the simulation of an infinitely recursive
>>> invocation. Infinitely recursive invocations never receive any return
>>> value.
>> 
>> Right, so if Halts(H_Hat, H_Hat) doesn't return when called by H_Hat,
>> since it doesn't return at all, then H_Hat has no opportunity to
>> misbehave: H_Hat cannot "do the opposite" until it receives a return
>> value.
>> 
>> However, note that if Halts(H_Hat, H_Hat) doesn't return when called by H_Hat,
>> it also doesn't return when called by main():
>> 
>>   int main()
>>   {
>>     u32 Input_Halted = Halts((u32)H_Hat, (u32)H_Hat);
>> 
>>     // Does not reach here
>> 
>>     Output("Input_Halted =", Input_Halted);
>>   }
>> 
>> So that represents a failure to decide.
>
> Like I already said and you simply ignored Halts() is invoked on main() 
> at a level higher than main() so in the C model of computation is has no 
> where to return to in the C program.

I tried no to ignore that, but I couldn't make sense of it. You've
not shown any code where Halts is called at a higher level than main.

Now I perfectly understand that your "global virtual machine" begins
execution above main. I.e. that whole program is run in a monitored way
which detects runaway recursion.

But that monitor isn't Halts. Or even if it is, it isn't Halts being
invoked on H_Hat. In other words, this Halts call above main is not
is not Halts(H_Hat, H_Hat). It doesn't rescue Halts(H_Hat, H_Hat)
from either failing to terminate or returning a wrong answer.

Suppose that the entire test case above, with main() and all, is called
H_Hat_Hat. H_Hat_Hat is a program which calls Halts(H_Hat, H_Hat)
and reports on it.

It could very well be that Halts(H_Hat_Hat, ...) decides this program!

But that doesn't rescue the Halts(H_Hat, H_Hat) case!

> When the operating system terminates a program because of a divide by 
> zero error we cannot correctly say that that the operating system did 
> not make a decision or did not return a value. It is the same case with 
> global halts.

Oh now we can't, the operating system and CPU certainly made a decision
in that case.

(However, if such an event happens to a Boolean function that is
supposed to decide something, it means that that function failed to
decide.)

-- 
TXR Programming Language: http://nongnu.org/txr

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


#2149 — Re: Refutation of Peter Linz HP proof [ divide by zero error returns no value ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-07 21:37 -0600
SubjectRe: Refutation of Peter Linz HP proof [ divide by zero error returns no value ]
Message-ID<KNydnRXg97lxaVPCnZ2dnUU7-T_NnZ2d@giganews.com>
In reply to#2148
On 12/7/2020 9:09 PM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2020-12-08, olcott <NoOne@NoWhere.com> wrote:
>> On 12/7/2020 8:03 PM, Kaz Kylheku wrote:
>>> ["Followup-To:" header set to comp.theory.]
>>> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>>>> On 12/7/2020 4:10 PM, Kaz Kylheku wrote:
>>>>> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 12/7/2020 3:16 PM, Kaz Kylheku wrote:
>>>>>>> On 2020-12-07, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> On 12/7/2020 1:40 PM, Kaz Kylheku wrote:
>>>>>>>>> Your test setup does not show that Halt can be defined in a way that it
>>>>>>>>> returns the correct value; i.e does not refute this core proposition.
>>>>>>>>>
>>>>>>>>> You have acknowledged this issue, but are bizarrely downplaying its
>>>>>>>>> importance, promising that you will have a fix for it in about a week,
>>>>>>>>> and that in spite of this problem, you insist that, already today, you
>>>>>>>>> have a "correct refutation".
>>>>>>>>
>>>>>>>> It <is> only an interface issue and nothing more.
>>>>>>>
>>>>>>> Is it? Can you describe the issue as an interface issue? I mean using
>>>>>>> sentences that refer to interfaces and their properties, articulating
>>>>>>> what is wrong or missing?
>>>>>>>
>>>>>>> What is the first step toward solving or eliminating the interface
>>>>>>> issue?
>>>>>>>
>>>>>>> Do you have everything you need to solve the problem? Or is it necessary
>>>>>>> to investigate, in order to obtain some information?
>>>>>>>
>>>>>>> How did you estimate seven days for solving it?
>>>>>>>
>>>>>>
>>>>>> I will be able to simply return an integer value
>>>>>> to an invocation of Halts in main() like this:
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>       u32 Input_Halted = Halts((u32)H_Hat, (u32)H_Hat);
>>>>>>       Output("Input_Halted =", Input_Halted);
>>>>>> }
>>>>>
>>>>> OK that would be a fine top-level driver program. But then H_Hat itself
>>>>> also internally calls
>>>>>
>>>>>      Halts((u32)H_Hat, (u32)H_Hat).
>>>>>
>>>>> right? That function is necessarily the same Halts and is receiving the
>>>>> same argumenst, so it is required to return exactly the same value that
>>>>> is seen in main.
>>>>>
>>>>
>>>> No, not at all, not in the least little bit.
>>>>
>>>> My key innovation is to abort the simulation of an infinitely recursive
>>>> invocation. Infinitely recursive invocations never receive any return
>>>> value.
>>>
>>> Right, so if Halts(H_Hat, H_Hat) doesn't return when called by H_Hat,
>>> since it doesn't return at all, then H_Hat has no opportunity to
>>> misbehave: H_Hat cannot "do the opposite" until it receives a return
>>> value.
>>>
>>> However, note that if Halts(H_Hat, H_Hat) doesn't return when called by H_Hat,
>>> it also doesn't return when called by main():
>>>
>>>    int main()
>>>    {
>>>      u32 Input_Halted = Halts((u32)H_Hat, (u32)H_Hat);
>>>
>>>      // Does not reach here
>>>
>>>      Output("Input_Halted =", Input_Halted);
>>>    }
>>>
>>> So that represents a failure to decide.
>>
>> Like I already said and you simply ignored Halts() is invoked on main()
>> at a level higher than main() so in the C model of computation is has no
>> where to return to in the C program.
> 
> I tried no to ignore that, but I couldn't make sense of it. You've
> not shown any code where Halts is called at a higher level than main.
> 

Where in this code do we call the check for divide by zero:

int main()
{
   int X = 5 / 0;
}

We don't the OS does.

> Now I perfectly understand that your "global virtual machine" begins
> execution above main. I.e. that whole program is run in a monitored way
> which detects runaway recursion.

Yeah !

> But that monitor isn't Halts. Or even if it is, it isn't Halts being
> invoked on H_Hat. 

I had to redefine the problem a little bit so that people would not get 
confused into believing that this is a finite computation:

int main()
{
   H_Hat((u32)H_Hat);
}

So I had to redefine the halt decider to have global scope.
I will allow it to revert to local scope for this:

int main()
{
   u32 Input_Halts = Halts((u32)H_Hat, (u32)H_Hat);
   Output("Input_Halts =", Input_Halts);
}

> In other words, this Halts call above main is not
> is not Halts(H_Hat, H_Hat). It doesn't rescue Halts(H_Hat, H_Hat)
> from either failing to terminate or returning a wrong answer.

It is like a compiler it will simply not run until the errors are fixed.

> Suppose that the entire test case above, with main() and all, is called
> H_Hat_Hat. H_Hat_Hat is a program which calls Halts(H_Hat, H_Hat)
> and reports on it.
> 
> It could very well be that Halts(H_Hat_Hat, ...) decides this program!
> 
> But that doesn't rescue the Halts(H_Hat, H_Hat) case!
> 

If you call Halts on a program that you do not know whether it halts or 
not it will report the answer. It is the same idea as wrapping a divide 
by zero error within a try catch block.

If you do not call Halts() to check if a program is infinite, it will be 
like an unwrapped divide by zero error the program crashes with a 
message from the OS.

>> When the operating system terminates a program because of a divide by
>> zero error we cannot correctly say that that the operating system did
>> not make a decision or did not return a value. It is the same case with
>> global halts.
> 
> Oh now we can't, the operating system and CPU certainly made a decision
> in that case.
> 

Yeah !

> (However, if such an event happens to a Boolean function that is
> supposed to decide something, it means that that function failed to
> decide.)
> 

It will be the wrapped / unwrapped divide by zero error that I described 
above. I just have to augment the interface to allow a return value.

-- 
Copyright 2020 Pete Olcott

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

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


#2137 — Re: Refutation of Peter Linz HP proof [ Logical Necessity ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-07 14:42 -0600
SubjectRe: Refutation of Peter Linz HP proof [ Logical Necessity ]
Message-ID<YrGdndLAW-NTDlPCnZ2dnUU7-afNnZ2d@giganews.com>
In reply to#2126
On 12/7/2020 1:37 PM, Mike Terry wrote:
> On 07/12/2020 18:59, olcott wrote:
>> On 12/7/2020 12:34 PM, Mike Terry wrote:
>>> On 07/12/2020 17:45, olcott wrote:
>>>> On 12/7/2020 11:37 AM, Mike Terry wrote:
>>>>> On 07/12/2020 17:28, olcott wrote:
>>>>>> On 12/7/2020 11:22 AM, Mike Terry wrote:
>>>>>>> On 07/12/2020 04:17, olcott wrote:
>>>>>>>> On 12/6/2020 5:36 PM, Mike Terry wrote:
>>>>>>>>> On 06/12/2020 20:29, olcott wrote:
>>>>>>>>>> On 12/6/2020 2:10 PM, Mike Terry wrote:
>>>>>>>>>>> On 06/12/2020 19:18, olcott wrote:
>>>>>>>>>>>> On 12/6/2020 12:46 PM, Mike Terry wrote:
>>>>>>>>>>>>> On 06/12/2020 04:40, olcott wrote:
>>>>>>>>>>>>>> On 12/5/2020 10:15 PM, Mike Terry wrote:
>>>>>>>>>>> <.. snip ..>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Or more simply, PO's infinite recursion test is UNSOUND.  
>>>>>>>>>>>>>>> (It
>>>>>>>>>>>>>>> simply
>>>>>>>>>>>>>>> does not imply infinite recursion when applied to scenarios
>>>>>>>>>>>>>>> where the
>>>>>>>>>>>>>>> two "call" trace entries BELONG TO DIFFERENT EMULATION
>>>>>>>>>>>>>>> LEVELS!
>>>>>>>>>>>>>>> [As in
>>>>>>>>>>>>>>> above trace])   The issue of "conditionals in the loop" is
>>>>>>>>>>>>>>> quite
>>>>>>>>>>>>>>> moot
>>>>>>>>>>>>>>> here - even if there genuinely aren't any conditional
>>>>>>>>>>>>>>> branches
>>>>>>>>>>>>>>> "in
>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>> loop" that doesn't imply infinite recursion.  (So no 
>>>>>>>>>>>>>>> point in
>>>>>>>>>>>>>>> accusing
>>>>>>>>>>>>>>> him of hiding them :) )
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I don't see how this is over your head and I don't accept 
>>>>>>>>>>>>>> that
>>>>>>>>>>>>>> you are
>>>>>>>>>>>>>> lying. It is like I am saying that 2 + 3 = 5 and you say that
>>>>>>>>>>>>>> what I
>>>>>>>>>>>>>> said is unsound.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I've told him that, but he just doesn't believe me.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I never believe any damn thing any unproven assertion counts
>>>>>>>>>>>>>> as an
>>>>>>>>>>>>>> assertion that was never even made.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> You believe your own assertions, but are unable to prove
>>>>>>>>>>>>> them.  :)
>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Also, he is unable to provide any coherent "proof" that his
>>>>>>>>>>>>>>> test
>>>>>>>>>>>>>>> works
>>>>>>>>>>>>>>> (of course, since it doesn't) - he just repeats one of his
>>>>>>>>>>>>>>> mantras
>>>>>>>>>>>>>>> about equivalent
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are acting like Ben. I am totally wrong because you 
>>>>>>>>>>>>>> really
>>>>>>>>>>>>>> really
>>>>>>>>>>>>>> don't believe me. That is not logic son, that is not even
>>>>>>>>>>>>>> decent
>>>>>>>>>>>>>> rhetoric.
>>>>>>>>>>>>>
>>>>>>>>>>>>> People do not have to accept what you say without you 
>>>>>>>>>>>>> providing
>>>>>>>>>>>>> proof.
>>>>>>>>>>>>> You are unable to do that.  (That will be the key point,
>>>>>>>>>>>>> when it
>>>>>>>>>>>>> comes
>>>>>>>>>>>>> to how reviewers will treat your claims.)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Mike.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If it is clear to them that it is false on the basis of lack of
>>>>>>>>>>>> proof
>>>>>>>>>>>> this is a logic error known as ad  ignorantiam.
>>>>>>>>>>>
>>>>>>>>>>> I never said that was the basis.
>>>>>>>>>>>
>>>>>>>>>>> <.. snip ..>
>>>>>>>>>>>> The proof (that you already acknowledged) is that any function
>>>>>>>>>>>> call
>>>>>>>>>>>> from
>>>>>>>>>>>> the same machine address in the user code to the same
>>>>>>>>>>>> function in
>>>>>>>>>>>> the
>>>>>>>>>>>> user code without any conditional branch instructions 
>>>>>>>>>>>> in-between
>>>>>>>>>>>> does
>>>>>>>>>>>> unequivocally specify infinite recursion in this user code
>>>>>>>>>>>> execution
>>>>>>>>>>>> trace.
>>>>>>>>>>>
>>>>>>>>>>> 1)  That is not a proof of anything - it's A CLAIM.
>>>>>>>>>>
>>>>>>>>>> Within the x86 language and the scope of the execution trace of
>>>>>>>>>> the
>>>>>>>>>> local code being examined it is a logical necessity and you know
>>>>>>>>>> this.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is not a logical necessity.  The fact that you can't give any
>>>>>>>>> reason for your belief other than "it's a logical necessity" must
>>>>>>>>> give
>>>>>>>>> you cause for concern - why don't you prove it?
>>>>>>>>
>>>>>>>>
>>>>>>>> // This code specifies an infinite loop
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>   HERE: goto HERE;
>>>>>>>> }
>>>>>>>
>>>>>>> Yes.
>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> // This code specifies infinite recursion until stack space is
>>>>>>>> exhausted
>>>>>>>> void Recursion()
>>>>>>>> {
>>>>>>>>   Recursion();
>>>>>>>> }
>>>>>>>
>>>>>>> Yes.  (But maybe the compiler will optimise this in a way you don't
>>>>>>> expect, as Ben pointed out.)
>>>>>>>
>>>>>> So you agree that the minimal cases of an infinite loops and infinite
>>>>>> recursion can be detected without waiting forever and then AFTER
>>>>>> forever
>>>>>> deciding that these were actually infinite.
>>>>>>
>>>>>> What about this:
>>>>>>
>>>>>> This is my 2018-12-13 solution: Every time the same function is
>>>>>> called a
>>>>>> second time from the same machine address with no control flow
>>>>>> instructions** in-between we can know that this is definitely 
>>>>>> infinite
>>>>>> recursion.
>>>>>>
>>>>>> ** A simplification of the original criteria to make my proof
>>>>>> easier to
>>>>>> understand.
>>>>>
>>>>> Are you saying the block of trace entries under consideration
>>>>> (bracketed by the two call instructions) ARE ALL WITHIN A SINGLE
>>>>> EMULATION LEVEL?
>>>>>
>>>>> If yes, then as I said, I would probably agree that the test is sound
>>>>> (subject to detailed wording etc.).
>>>>>
>>>>> If no, then as I said, that test is unsound.
>>>>>
>>>>>
>>>>> Mike.
>>>>>
>>>>
>>>> Yes and by unsound you means something is wrong with it somewhere but
>>>> you cannot say what or why because you are bypassing logic and leaping
>>>> to intuition with no reasoning in-between.
>>>>
>>>
>>> That sounds like you are saying "yes"?  I.e. the block of trace
>>> entries under consideration (bracketed by the two call instructions)
>>> ARE ALL WITHIN A SINGLE EMULATION LEVEL.
>>>
>>> So in that case the test is basically sound - but I suspect you are
>>> just lying here, so you can quote me out of context later on.  Maybe
>>> you're employing some cheap trick of the wording or something.
>>> (Because in previous traces you've shown, the block of trace entries
>>> DOES span multiple emulation levels!)
>>>
>>>
>>> Regarding the unsound version of the test - it's YOU who are claiming
>>> magical properties for that test without proof.
>>
>> 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
>> [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
>> [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
>> The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
>>
>> The empirical proof is that unless the halt decider terminates its
>> simulation of its input lines 13-21 of the execution trace endlessly
>> repeat.
>>
> 
> Rubbish.
> 
> 1)  You claim your test works generally, so there can be no such thing 
> an "empirical proof".  At best this could prove that the test works in 
> one specific case.

Which is by itself proof that the Linz Ĥ is decidable.

> 2)  You're using your weasil wording "..UNLESS..." again to try to hide 
> the cheat that you are going to CHANGE THE CODE of the input calculation 
> and then observe that THE NEW input calculation endlessly repeats. 
> (Well, that's my guess...).
> 
> 
> Mike.
> 


-- 
Copyright 2020 Pete Olcott

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

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


#2142 — Re: Refutation of Peter Linz HP proof [ Recursion with TMs ]

Fromolcott <NoOne@NoWhere.com>
Date2020-12-07 19:05 -0600
SubjectRe: Refutation of Peter Linz HP proof [ Recursion with TMs ]
Message-ID<K_CdnVI778_pTFPCnZ2dnUU7-aXNnZ2d@giganews.com>
In reply to#2126
On 12/7/2020 11:37 AM, Mike Terry wrote:
> On 07/12/2020 17:28, olcott wrote:
>> On 12/7/2020 11:22 AM, Mike Terry wrote:
>>> On 07/12/2020 04:17, olcott wrote:
>>>> On 12/6/2020 5:36 PM, Mike Terry wrote:
>>>>> On 06/12/2020 20:29, olcott wrote:
>>>>>> On 12/6/2020 2:10 PM, Mike Terry wrote:
>>>>>>> On 06/12/2020 19:18, olcott wrote:
>>>>>>>> On 12/6/2020 12:46 PM, Mike Terry wrote:
>>>>>>>>> On 06/12/2020 04:40, olcott wrote:
>>>>>>>>>> On 12/5/2020 10:15 PM, Mike Terry wrote:
>>>>>>> <.. snip ..>
>>>>>>>>>>>
>>>>>>>>>>> Or more simply, PO's infinite recursion test is UNSOUND.  (It
>>>>>>>>>>> simply
>>>>>>>>>>> does not imply infinite recursion when applied to scenarios
>>>>>>>>>>> where the
>>>>>>>>>>> two "call" trace entries BELONG TO DIFFERENT EMULATION LEVELS!
>>>>>>>>>>> [As in
>>>>>>>>>>> above trace])   The issue of "conditionals in the loop" is quite
>>>>>>>>>>> moot
>>>>>>>>>>> here - even if there genuinely aren't any conditional branches
>>>>>>>>>>> "in
>>>>>>>>>>> the
>>>>>>>>>>> loop" that doesn't imply infinite recursion.  (So no point in
>>>>>>>>>>> accusing
>>>>>>>>>>> him of hiding them :) )
>>>>>>>>>>
>>>>>>>>>> I don't see how this is over your head and I don't accept that
>>>>>>>>>> you are
>>>>>>>>>> lying. It is like I am saying that 2 + 3 = 5 and you say that
>>>>>>>>>> what I
>>>>>>>>>> said is unsound.
>>>>>>>>>>
>>>>>>>>>>> I've told him that, but he just doesn't believe me.
>>>>>>>>>>
>>>>>>>>>> I never believe any damn thing any unproven assertion counts 
>>>>>>>>>> as an
>>>>>>>>>> assertion that was never even made.
>>>>>>>>>>
>>>>>>>>> You believe your own assertions, but are unable to prove them.  :)
>>>>>>>>>
>>>>>>>>>>> Also, he is unable to provide any coherent "proof" that his test
>>>>>>>>>>> works
>>>>>>>>>>> (of course, since it doesn't) - he just repeats one of his
>>>>>>>>>>> mantras
>>>>>>>>>>> about equivalent
>>>>>>>>>>
>>>>>>>>>> You are acting like Ben. I am totally wrong because you really
>>>>>>>>>> really
>>>>>>>>>> don't believe me. That is not logic son, that is not even decent
>>>>>>>>>> rhetoric.
>>>>>>>>>
>>>>>>>>> People do not have to accept what you say without you providing
>>>>>>>>> proof.
>>>>>>>>> You are unable to do that.  (That will be the key point, when it
>>>>>>>>> comes
>>>>>>>>> to how reviewers will treat your claims.)
>>>>>>>>>
>>>>>>>>> Mike.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If it is clear to them that it is false on the basis of lack of
>>>>>>>> proof
>>>>>>>> this is a logic error known as ad  ignorantiam.
>>>>>>>
>>>>>>> I never said that was the basis.
>>>>>>>
>>>>>>> <.. snip ..>
>>>>>>>> The proof (that you already acknowledged) is that any function call
>>>>>>>> from
>>>>>>>> the same machine address in the user code to the same function in
>>>>>>>> the
>>>>>>>> user code without any conditional branch instructions in-between
>>>>>>>> does
>>>>>>>> unequivocally specify infinite recursion in this user code 
>>>>>>>> execution
>>>>>>>> trace.
>>>>>>>
>>>>>>> 1)  That is not a proof of anything - it's A CLAIM.
>>>>>>
>>>>>> Within the x86 language and the scope of the execution trace of the
>>>>>> local code being examined it is a logical necessity and you know 
>>>>>> this.
>>>>>>
>>>>>
>>>>> It is not a logical necessity.  The fact that you can't give any
>>>>> reason for your belief other than "it's a logical necessity" must give
>>>>> you cause for concern - why don't you prove it?
>>>>
>>>>
>>>> // This code specifies an infinite loop
>>>> int main()
>>>> {
>>>>   HERE: goto HERE;
>>>> }
>>>
>>> Yes.
>>>
>>>>
>>>>
>>>> // This code specifies infinite recursion until stack space is 
>>>> exhausted
>>>> void Recursion()
>>>> {
>>>>   Recursion();
>>>> }
>>>
>>> Yes.  (But maybe the compiler will optimise this in a way you don't
>>> expect, as Ben pointed out.)
>>>
>> So you agree that the minimal cases of an infinite loops and infinite
>> recursion can be detected without waiting forever and then AFTER forever
>> deciding that these were actually infinite.
>>
>> What about this:
>>
>> This is my 2018-12-13 solution: Every time the same function is called a
>> second time from the same machine address with no control flow
>> instructions** in-between we can know that this is definitely infinite
>> recursion.
>>
>> ** A simplification of the original criteria to make my proof easier to
>> understand.
> 
> Are you saying the block of trace entries under consideration (bracketed 
> by the two call instructions) ARE ALL WITHIN A SINGLE EMULATION LEVEL?
> 
> If yes, then as I said, I would probably agree that the test is sound 
> (subject to detailed wording etc.).
> 
> If no, then as I said, that test is unsound.
> 
> 
> Mike.
> 

I did the best that I could to recreate the equivalent infrastructure so 
that an x86utm based virtual machine executing its own x86 machine 
language executing its own x86 machine language is in every way the same 
as a UTM simulating the Turing machine description of itself simulating 
the Turing machine description of itself.  AKA recursive invocation.

If we hypothesize that I did do this correctly then we can conclude that 
because a UTM simulating the Turing machine description of TM is 
computationally equivalent to the direct execution of this TM then
that this same reasoning would apply to to multiple emulation levels.

X simulates Y simulating Z ≡ X invokes Y which invoke Z.

If you can answer this question:
What is the Turing machine equivalent of recursive invocation?
You should see that I am correct.

If you cannot answer that question then this topic may be too difficult 
for you. That you cannot understand a proof is no evidence that a proof 
has not been provided.


-- 
Copyright 2020 Pete Olcott

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

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


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

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


csiph-web