Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.lang.c++ > #85176 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2022-07-14 14:19 -0500 |
| Last post | 2022-07-15 13:19 -0700 |
| Articles | 20 on this page of 161 — 11 participants |
Back to article view | Back to comp.lang.c++
Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 14:19 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-14 20:28 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 15:02 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-14 21:22 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 16:02 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-14 23:30 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 17:41 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 07:23 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 01:46 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-15 07:48 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 13:06 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 09:19 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 15:32 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 10:07 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 16:18 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 10:27 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 16:29 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 16:49 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 10:58 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 17:03 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 12:00 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 18:08 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 12:26 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 18:28 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 12:39 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 18:46 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 12:57 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 19:04 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 13:17 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 19:23 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 13:34 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 19:46 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 13:31 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 19:41 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 14:04 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 20:11 +0100
Re: Halting problem proofs refuted on the basis of software engineering [ establishing my authorship and asserting my copyrights ] olcott <NoOne@NoWhere.com> - 2022-07-15 14:28 -0500
Re: Halting problem proofs refuted on the basis of software engineering [ establishing my authorship and asserting my copyrights ] Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 20:33 +0100
Re: Halting problem proofs refuted on the basis of software engineering [ establishing my authorship and asserting my copyrights ] Richard Damon <Richard@Damon-Family.org> - 2022-07-15 19:32 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 12:20 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 20:23 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 12:26 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 20:27 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) scott@slp53.sl.home (Scott Lurndal) - 2022-07-15 19:37 +0000
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 12:39 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 20:41 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 12:53 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 15:03 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 13:06 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 15:16 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 13:23 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 21:26 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 13:36 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 21:39 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 13:44 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 21:49 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 14:08 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 22:10 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 14:14 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 22:20 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 14:27 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 22:29 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 14:36 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 22:39 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 15:03 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 23:05 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick23@gmail.com> - 2022-07-15 15:43 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 23:47 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick23@gmail.com> - 2022-07-15 16:01 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-16 00:08 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick23@gmail.com> - 2022-07-15 16:18 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 18:12 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick23@gmail.com> - 2022-07-15 16:22 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 18:44 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick23@gmail.com> - 2022-07-15 16:51 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 18:59 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick23@gmail.com> - 2022-07-15 17:08 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-15 20:59 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 20:24 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-15 23:17 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 22:50 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-16 06:47 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-16 10:15 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-16 11:41 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick23@gmail.com> - 2022-07-15 16:34 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 18:54 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick23@gmail.com> - 2022-07-15 16:58 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 19:07 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick23@gmail.com> - 2022-07-15 17:17 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-15 19:44 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 17:50 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Big Dick <bigdick22@gmail.com> - 2022-07-15 22:42 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Big Dick <Big.Dick@olcott.crap> - 2022-07-15 21:22 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-15 19:49 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-15 19:38 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 18:56 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-15 21:05 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 20:36 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-15 21:47 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 20:57 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-15 22:12 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 21:27 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-15 22:39 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-16 00:15 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick23@gmail.com> - 2022-07-16 00:59 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-16 08:38 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-16 06:36 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-16 08:39 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-16 10:15 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-16 10:16 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-16 08:33 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-14 21:21 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 13:27 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Harnden <richard.nospam@gmail.com> - 2022-07-14 21:53 +0100
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 16:09 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 14:21 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 16:32 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-14 21:32 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 16:06 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 14:16 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 16:24 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 14:32 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 16:35 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 14:39 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 16:45 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 18:34 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 20:43 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 18:46 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 14:45 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 16:57 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 15:21 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 17:37 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 15:44 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 17:54 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 16:05 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 16:07 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 16:08 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 18:15 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 16:18 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 16:19 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 18:25 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 17:15 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Siri Cruise <chine.bleu@yahoo.com> - 2022-07-14 17:24 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 19:33 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-14 21:53 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-15 00:01 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Richard Damon <Richard@Damon-Family.org> - 2022-07-15 07:56 -0400
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 09:22 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 17:51 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 20:00 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 18:28 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 18:29 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Siri Cruise <chine.bleu@yahoo.com> - 2022-07-14 18:28 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 18:28 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-14 18:12 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2022-07-14 16:17 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 12:14 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 14:48 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 13:01 -0700
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) olcott <NoOne@NoWhere.com> - 2022-07-15 15:11 -0500
Re: Halting problem proofs refuted on the basis of software engineering (Simplified so that most anyone here can validate it) Skep Dick <skepdick22@gmail.com> - 2022-07-15 13:19 -0700
Page 2 of 9 — ← Prev page 1 [2] 3 4 5 6 7 8 9 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2022-07-15 12:00 -0500 |
| Message-ID | <aZudnWdIoajRAEz_nZ2dnUU7_8zNnZ2d@giganews.com> |
| In reply to | #85250 |
On 7/15/2022 11:03 AM, Mr Flibble wrote:
> On Fri, 15 Jul 2022 10:58:14 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
>>> On Fri, 15 Jul 2022 10:07:36 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This is an explanation of a key new insight into the
>>>>>>>>>>>>>>>> halting problem provided in the language of software
>>>>>>>>>>>>>>>> engineering. Technical computer science terms are
>>>>>>>>>>>>>>>> explained using software engineering terms. No
>>>>>>>>>>>>>>>> knowledge of the halting problem is required.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is based on fully operational software executed in
>>>>>>>>>>>>>>>> the x86utm operating system. The x86utm operating
>>>>>>>>>>>>>>>> system (based on an excellent open source x86
>>>>>>>>>>>>>>>> emulator) was created to study the details of the
>>>>>>>>>>>>>>>> halting problem proof counter-examples at the much
>>>>>>>>>>>>>>>> higher level of abstraction of C/x86.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt decider
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When simulating halt decider H(P,P) simulates its input
>>>>>>>>>>>>>>>> we can see that: (1) Function H() is called from P().
>>>>>>>>>>>>>>>> (2) With the same arguments to H().
>>>>>>>>>>>>>>>> (3) With no instructions in P preceding its invocation
>>>>>>>>>>>>>>>> of H(P,P).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The above shows that the simulated P cannot possibly
>>>>>>>>>>>>>>>> terminate normally. Because H can see the same
>>>>>>>>>>>>>>>> (1)(2)(3) that we see H aborts its simulation of P and
>>>>>>>>>>>>>>>> rejects P as non-halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> In computability theory, the halting
>>>>>>>>>>>>>>>> problem is the problem of determining, from a
>>>>>>>>>>>>>>>> description of an arbitrary computer program and an
>>>>>>>>>>>>>>>> input, whether the program will finish running, or
>>>>>>>>>>>>>>>> continue to run forever. Alan Turing proved in 1936
>>>>>>>>>>>>>>>> that a general algorithm to solve the halting problem
>>>>>>>>>>>>>>>> for all possible program- input pairs cannot exist.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> For any program H that might determine if
>>>>>>>>>>>>>>>> programs halt, a "pathological" program P, called with
>>>>>>>>>>>>>>>> some input, can pass its own source and its input to H
>>>>>>>>>>>>>>>> and then specifically do the opposite of what H
>>>>>>>>>>>>>>>> predicts P will do. No H can exist that handles this
>>>>>>>>>>>>>>>> case. https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H and P implement the exact pathological relationship
>>>>>>>>>>>>>>>> to each other as described above. Because H(P,P) does
>>>>>>>>>>>>>>>> handle this case the above halting problem undecidable
>>>>>>>>>>>>>>>> input template has been refuted.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *When this halt deciding principle understood to be
>>>>>>>>>>>>>>>> correct* A halt decider must compute the mapping from
>>>>>>>>>>>>>>>> its inputs to an accept or reject state on the basis
>>>>>>>>>>>>>>>> of the actual behavior that is actually specified by
>>>>>>>>>>>>>>>> these inputs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Then (by logical necessity) this implements that
>>>>>>>>>>>>>>>> principle* Every simulating halt decider that correctly
>>>>>>>>>>>>>>>> simulates its input until it correctly predicts that
>>>>>>>>>>>>>>>> this simulated input would never terminate normally,
>>>>>>>>>>>>>>>> correctly rejects this input as non-halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *H is a Pure function*
>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> thus implements a *Computable function*
>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus H is Turing computable.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the basis of
>>>>>>>>>>>>>>>> software engineering*
>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You forgot to mention infinite recursion which I suppose
>>>>>>>>>>>>>>> is progress.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I have shown that H/P does implement the HP's "impossible
>>>>>>>>>>>>>> input" template.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Therefore I have refuted all of the halting problem
>>>>>>>>>>>>>> proofs that rely on this template.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Equating pathological input with non-halting is erroneous:
>>>>>>>>>>>>> you are only doing that because your broken solution
>>>>>>>>>>>>> treats it as "infinite recursion". There is no recursion
>>>>>>>>>>>>> in [Strachey 1965] and the HP proofs based on it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> There is no recursion in any of the conventional proofs
>>>>>>>>>>>> only because no one ever previously bothered to fully
>>>>>>>>>>>> examine how a simulating halt decider would address these
>>>>>>>>>>>> otherwise "impossible" inputs.
>>>>>>>>>>>
>>>>>>>>>>> I have shown that a simulating halt decider needn't be
>>>>>>>>>>> recursive in nature:
>>>>>>>>>>>
>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You sure do make it easy to review your work.
>>>>>>>>>>
>>>>>>>>>> "When the simulator detects the call to H in P it
>>>>>>>>>> forks the simulation into a non-halting branch"
>>>>>>>>>>
>>>>>>>>>> There is an infinite set of cases where this overly
>>>>>>>>>> simplistic criteria gets the wrong answer.
>>>>>>>>>
>>>>>>>>> That is neither an honest review or any kind of rebuttal: I
>>>>>>>>> have told you before: assertions made without evidence can be
>>>>>>>>> dismissed without evidence.
>>>>>>>>>
>>>>>>>>> If you claim there are an infinite number of cases where it
>>>>>>>>> gets the wrong answer then it shouldn't be too hard for to
>>>>>>>>> provide ONE case backing up your claim.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>> Sure:
>>>>>>>>
>>>>>>>> void P(ptr x)
>>>>>>>> {
>>>>>>>> static int count = 3;
>>>>>>>> count--;
>>>>>>>> if (!count) goto exit;
>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>> if (Halt_Status)
>>>>>>>> HERE: goto HERE;
>>>>>>>> exit:
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>> }
>>>>>>>
>>>>>>> Nope; you seem to have forgotten that my decider is not
>>>>>>> recursive in nature: my decider will correctly determine that
>>>>>>> that input is pathological so will signal an exception.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> The above terminates normally so your decider gets the wrong
>>>>>> answer.
>>>>>
>>>>> It is a pathological input so neither halts nor doesn't halt:
>>>>> pathological input is INVALID so the correct "answer" is to signal
>>>>> an exception.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> So you don't know how static variables work?
>>>> I am not surprised.
>>>>
>>>>
>>>> void P(ptr x)
>>>> {
>>>> static int count = 0;
>>>> if (count++ >= 2) goto exit;
>>>> int Halt_Status = H(x, x);
>>>> if (Halt_Status)
>>>> HERE: goto HERE;
>>>> exit:
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(P,P));
>>>> }
>>>>
>>>> _Pm()
>>>> [0000141e](01) 55 push ebp
>>>> [0000141f](02) 8bec mov ebp,esp
>>>> [00001421](03) 83ec08 sub esp,+08
>>>> [00001424](05) a100000000 mov eax,[00000000]
>>>> [00001429](03) 8945fc mov [ebp-04],eax
>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
>>>> [00001432](03) 83c101 add ecx,+01
>>>> [00001435](06) 890d00000000 mov [00000000],ecx
>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
>>>> [0000143f](02) 7c02 jl 00001443
>>>> [00001441](02) eb1b jmp 0000145e
>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
>>>> [00001446](01) 52 push edx
>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
>>>> [0000144a](01) 50 push eax
>>>> [0000144b](05) e8defcffff call 0000112e
>>>> [00001450](03) 83c408 add esp,+08
>>>> [00001453](03) 8945f8 mov [ebp-08],eax
>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
>>>> [0000145a](02) 7402 jz 0000145e
>>>> [0000145c](02) ebfe jmp 0000145c
>>>> [0000145e](02) 8be5 mov esp,ebp
>>>> [00001460](01) 5d pop ebp
>>>> [00001461](01) c3 ret
>>>> Size in bytes:(0068) [00001461]
>>>>
>>>> _main()
>>>> [0000146e](01) 55 push ebp
>>>> [0000146f](02) 8bec mov ebp,esp
>>>> [00001471](05) 681e140000 push 0000141e
>>>> [00001476](05) 681e140000 push 0000141e
>>>> [0000147b](05) e8aefcffff call 0000112e
>>>> [00001480](03) 83c408 add esp,+08
>>>> [00001483](01) 50 push eax
>>>> [00001484](05) 685f050000 push 0000055f
>>>> [00001489](05) e820f1ffff call 000005ae
>>>> [0000148e](03) 83c408 add esp,+08
>>>> [00001491](02) 33c0 xor eax,eax
>>>> [00001493](01) 5d pop ebp
>>>> [00001494](01) c3 ret
>>>> Size in bytes:(0039) [00001494]
>>>>
>>>> machine stack stack machine assembly
>>>> address address data code language
>>>> ======== ======== ======== ========= =============
>>>> [0000146e][00102462][00000000] 55 push ebp
>>>> [0000146f][00102462][00000000] 8bec mov ebp,esp
>>>> [00001471][0010245e][0000141e] 681e140000 push 0000141e
>>>> [00001476][0010245a][0000141e] 681e140000 push 0000141e
>>>> [0000147b][00102456][00001480] e8aefcffff call 0000112e
>>>>
>>>> H: Begin Simulation Execution Trace Stored at:11250e
>>>> Address_of_H:112e
>>>> [0000141e][001124fa][001124fe] 55 push ebp
>>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
>>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
>>>> [00001424][001124f2][90909090] a100000000 mov eax,[00000000]
>>>> [00001429][001124f2][90909090] 8945fc mov [ebp-04],eax
>>>> [0000142c][001124f2][90909090] 8b0d00000000 mov ecx,[00000000]
>>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
>>>> [00001435][001124f2][90909090] 890d00000000 mov [00000000],ecx
>>>> [0000143b][001124f2][90909090] 837dfc02 cmp dword [ebp-04],+02
>>>> [0000143f][001124f2][90909090] 7c02 jl 00001443
>>>> [00001441][001124f2][90909090] eb1b jmp 0000145e
>>>> [0000145e][001124fa][001124fe] 8be5 mov esp,ebp
>>>> [00001460][001124fe][00001217] 5d pop ebp
>>>> [00001461][00112502][0000141e] c3 ret
>>>> H: End Simulation Input Terminated Normally
>>>>
>>>> [00001480][00102462][00000000] 83c408 add esp,+08
>>>> [00001483][0010245e][00000001] 50 push eax
>>>> [00001484][0010245a][0000055f] 685f050000 push 0000055f
>>>> [00001489][0010245a][0000055f] e820f1ffff call 000005ae
>>>> Input_Halts = 1
>>>> [0000148e][00102462][00000000] 83c408 add esp,+08
>>>> [00001491][00102462][00000000] 33c0 xor eax,eax
>>>> [00001493][00102466][00000018] 5d pop ebp
>>>> [00001494][0010246a][00000000] c3 ret
>>>> Number of Instructions Executed(1317) == 20 Pages
>>>
>>> For this particular stack trace I notice that the function symbol at
>>> the top of it is Pm not P which suggests to me one of two things:
>>>
>>
>> I already had a P so I renamed it to Pm so it would not disturb my
>> existing code. When I changed all the Pm references to your name I
>> forgot one.
>
> Then I suggest you check the output of compilation/linking is actually
> initializing static variables correctly. Are you even using a linker
> or are you just executing an object file? Static data normally goes
> into a separate data segment during the linking process.
>
> /Flibble
>
I haven't used static data in such a long time that I forgot the
compiler does not allocate any space for static variables unless they
have been initialized to a non-zero value.
void Pm(u32 x)
{
static int count = 0x777;
if (count++ > 0x777) goto exit;
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
exit:
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
}
_Pm()
[00000a1a](01) 55 push ebp
[00000a1b](02) 8bec mov ebp,esp
[00000a1d](03) 83ec08 sub esp,+08
[00000a20](05) a107030000 mov eax,[00000307]
[00000a25](03) 8945fc mov [ebp-04],eax
[00000a28](06) 8b0d07030000 mov ecx,[00000307]
[00000a2e](03) 83c101 add ecx,+01
[00000a31](06) 890d07030000 mov [00000307],ecx
[00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
[00000a3e](02) 7e02 jng 00000a42
[00000a40](02) eb1b jmp 00000a5d
[00000a42](03) 8b5508 mov edx,[ebp+08]
[00000a45](01) 52 push edx
[00000a46](03) 8b4508 mov eax,[ebp+08]
[00000a49](01) 50 push eax
[00000a4a](05) e8ebfdffff call 0000083a // call H
[00000a4f](03) 83c408 add esp,+08
[00000a52](03) 8945f8 mov [ebp-08],eax
[00000a55](04) 837df800 cmp dword [ebp-08],+00
[00000a59](02) 7402 jz 00000a5d
[00000a5b](02) ebfe jmp 00000a5b
[00000a5d](02) 8be5 mov esp,ebp
[00000a5f](01) 5d pop ebp
[00000a60](01) c3 ret
Size in bytes:(0071) [00000a60]
_main()
[00000a6a](01) 55 push ebp
[00000a6b](02) 8bec mov ebp,esp
[00000a6d](05) 681a0a0000 push 00000a1a // push address of P
[00000a72](05) 681a0a0000 push 00000a1a // push address of P
[00000a77](05) e8befdffff call 0000083a // call H
[00000a7c](03) 83c408 add esp,+08
[00000a7f](01) 50 push eax
[00000a80](05) 680b030000 push 0000030b
[00000a85](05) e8d0f8ffff call 0000035a
[00000a8a](03) 83c408 add esp,+08
[00000a8d](02) 33c0 xor eax,eax
[00000a8f](01) 5d pop ebp
[00000a90](01) c3 ret
Size in bytes:(0039) [00000a90]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
...[00000a6a][0010137b][00000000] 55 push ebp
...[00000a6b][0010137b][00000000] 8bec mov ebp,esp
...[00000a6d][00101377][00000a1a] 681a0a0000 push 00000a1a
...[00000a72][00101373][00000a1a] 681a0a0000 push 00000a1a
...[00000a77][0010136f][00000a7c] e8befdffff call 0000083a
New slave_stack at:201427
Begin Local Halt Decider Simulation Execution Trace Stored at:21142f
...[00000a1a][0021141b][0021141f] 55 push ebp
...[00000a1b][0021141b][0021141f] 8bec mov ebp,esp
...[00000a1d][00211413][90909090] 83ec08 sub esp,+08
...[00000a20][00211413][90909090] a107030000 mov eax,[00000307]
...[00000a25][00211413][90909090] 8945fc mov [ebp-04],eax
...[00000a28][00211413][90909090] 8b0d07030000 mov ecx,[00000307]
...[00000a2e][00211413][90909090] 83c101 add ecx,+01
...[00000a31][00211413][90909090] 890d07030000 mov [00000307],ecx
...[00000a37][00211413][90909090] 817dfc77070000 cmp dword
[ebp-04],00000777
...[00000a3e][00211413][90909090] 7e02 jng 00000a42
...[00000a42][00211413][90909090] 8b5508 mov edx,[ebp+08]
...[00000a45][0021140f][00000a1a] 52 push edx // push
address of P
...[00000a46][0021140f][00000a1a] 8b4508 mov eax,[ebp+08]
...[00000a49][0021140b][00000a1a] 50 push eax // push
address of P
...[00000a4a][00211407][00000a4f] e8ebfdffff call 0000083a // call H
New slave_stack at:24be4f
...[00000a1a][0025be43][0025be47] 55 push ebp
...[00000a1b][0025be43][0025be47] 8bec mov ebp,esp
...[00000a1d][0025be3b][90909090] 83ec08 sub esp,+08
...[00000a20][0025be3b][90909090] a107030000 mov eax,[00000307]
...[00000a25][0025be3b][90909090] 8945fc mov [ebp-04],eax
...[00000a28][0025be3b][90909090] 8b0d07030000 mov ecx,[00000307]
...[00000a2e][0025be3b][90909090] 83c101 add ecx,+01
...[00000a31][0025be3b][90909090] 890d07030000 mov [00000307],ecx
...[00000a37][0025be3b][90909090] 817dfc77070000 cmp dword
[ebp-04],00000777
...[00000a3e][0025be3b][90909090] 7e02 jng 00000a42
...[00000a40][0025be3b][90909090] eb1b jmp 00000a5d // jmp to
exit
...[00000a5d][0025be43][0025be47] 8be5 mov esp,ebp
...[00000a5f][0025be47][00000904] 5d pop ebp
...[00000a60][0025be4b][00000a1a] c3 ret
...[00000a7c][0010137b][00000000] 83c408 add esp,+08
...[00000a7f][00101377][00000001] 50 push eax
...[00000a80][00101373][0000030b] 680b030000 push 0000030b
---[00000a85][00101373][0000030b] e8d0f8ffff call 0000035a
Input_Halts = 1
...[00000a8a][0010137b][00000000] 83c408 add esp,+08
...[00000a8d][0010137b][00000000] 33c0 xor eax,eax
...[00000a8f][0010137f][00100000] 5d pop ebp
...[00000a90][00101383][00000004] c3 ret
Number of Instructions Executed(27278)
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-07-15 18:08 +0100 |
| Message-ID | <20220715180822.000061f6@reddwarf.jmc.corp> |
| In reply to | #85251 |
On Fri, 15 Jul 2022 12:00:59 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/15/2022 11:03 AM, Mr Flibble wrote:
> > On Fri, 15 Jul 2022 10:58:14 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 7/15/2022 10:49 AM, Mr Flibble wrote:
> >>> On Fri, 15 Jul 2022 10:07:36 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
> >>>>> On Fri, 15 Jul 2022 09:19:59 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
> >>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
> >>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
> >>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
> >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> This is an explanation of a key new insight into the
> >>>>>>>>>>>>>>>> halting problem provided in the language of software
> >>>>>>>>>>>>>>>> engineering. Technical computer science terms are
> >>>>>>>>>>>>>>>> explained using software engineering terms. No
> >>>>>>>>>>>>>>>> knowledge of the halting problem is required.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> It is based on fully operational software executed in
> >>>>>>>>>>>>>>>> the x86utm operating system. The x86utm operating
> >>>>>>>>>>>>>>>> system (based on an excellent open source x86
> >>>>>>>>>>>>>>>> emulator) was created to study the details of the
> >>>>>>>>>>>>>>>> halting problem proof counter-examples at the much
> >>>>>>>>>>>>>>>> higher level of abstraction of C/x86.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt decider
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> When simulating halt decider H(P,P) simulates its
> >>>>>>>>>>>>>>>> input we can see that: (1) Function H() is called
> >>>>>>>>>>>>>>>> from P(). (2) With the same arguments to H().
> >>>>>>>>>>>>>>>> (3) With no instructions in P preceding its
> >>>>>>>>>>>>>>>> invocation of H(P,P).
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> The above shows that the simulated P cannot possibly
> >>>>>>>>>>>>>>>> terminate normally. Because H can see the same
> >>>>>>>>>>>>>>>> (1)(2)(3) that we see H aborts its simulation of P
> >>>>>>>>>>>>>>>> and rejects P as non-halting.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> In computability theory, the halting
> >>>>>>>>>>>>>>>> problem is the problem of determining, from a
> >>>>>>>>>>>>>>>> description of an arbitrary computer program and an
> >>>>>>>>>>>>>>>> input, whether the program will finish running, or
> >>>>>>>>>>>>>>>> continue to run forever. Alan Turing proved in 1936
> >>>>>>>>>>>>>>>> that a general algorithm to solve the halting problem
> >>>>>>>>>>>>>>>> for all possible program- input pairs cannot exist.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> For any program H that might determine
> >>>>>>>>>>>>>>>> if programs halt, a "pathological" program P, called
> >>>>>>>>>>>>>>>> with some input, can pass its own source and its
> >>>>>>>>>>>>>>>> input to H and then specifically do the opposite of
> >>>>>>>>>>>>>>>> what H predicts P will do. No H can exist that
> >>>>>>>>>>>>>>>> handles this case.
> >>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> H and P implement the exact pathological relationship
> >>>>>>>>>>>>>>>> to each other as described above. Because H(P,P) does
> >>>>>>>>>>>>>>>> handle this case the above halting problem
> >>>>>>>>>>>>>>>> undecidable input template has been refuted.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> *When this halt deciding principle understood to be
> >>>>>>>>>>>>>>>> correct* A halt decider must compute the mapping from
> >>>>>>>>>>>>>>>> its inputs to an accept or reject state on the basis
> >>>>>>>>>>>>>>>> of the actual behavior that is actually specified by
> >>>>>>>>>>>>>>>> these inputs.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> *Then (by logical necessity) this implements that
> >>>>>>>>>>>>>>>> principle* Every simulating halt decider that
> >>>>>>>>>>>>>>>> correctly simulates its input until it correctly
> >>>>>>>>>>>>>>>> predicts that this simulated input would never
> >>>>>>>>>>>>>>>> terminate normally, correctly rejects this input as
> >>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> *H is a Pure function*
> >>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> thus implements a *Computable function*
> >>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Thus H is Turing computable.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> *Halting problem proofs refuted on the basis of
> >>>>>>>>>>>>>>>> software engineering*
> >>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> You forgot to mention infinite recursion which I
> >>>>>>>>>>>>>>> suppose is progress.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I have shown that H/P does implement the HP's
> >>>>>>>>>>>>>> "impossible input" template.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Therefore I have refuted all of the halting problem
> >>>>>>>>>>>>>> proofs that rely on this template.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Equating pathological input with non-halting is
> >>>>>>>>>>>>> erroneous: you are only doing that because your broken
> >>>>>>>>>>>>> solution treats it as "infinite recursion". There is
> >>>>>>>>>>>>> no recursion in [Strachey 1965] and the HP proofs based
> >>>>>>>>>>>>> on it.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> There is no recursion in any of the conventional proofs
> >>>>>>>>>>>> only because no one ever previously bothered to fully
> >>>>>>>>>>>> examine how a simulating halt decider would address these
> >>>>>>>>>>>> otherwise "impossible" inputs.
> >>>>>>>>>>>
> >>>>>>>>>>> I have shown that a simulating halt decider needn't be
> >>>>>>>>>>> recursive in nature:
> >>>>>>>>>>>
> >>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> You sure do make it easy to review your work.
> >>>>>>>>>>
> >>>>>>>>>> "When the simulator detects the call to H in P it
> >>>>>>>>>> forks the simulation into a non-halting branch"
> >>>>>>>>>>
> >>>>>>>>>> There is an infinite set of cases where this overly
> >>>>>>>>>> simplistic criteria gets the wrong answer.
> >>>>>>>>>
> >>>>>>>>> That is neither an honest review or any kind of rebuttal: I
> >>>>>>>>> have told you before: assertions made without evidence can
> >>>>>>>>> be dismissed without evidence.
> >>>>>>>>>
> >>>>>>>>> If you claim there are an infinite number of cases where it
> >>>>>>>>> gets the wrong answer then it shouldn't be too hard for to
> >>>>>>>>> provide ONE case backing up your claim.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>> Sure:
> >>>>>>>>
> >>>>>>>> void P(ptr x)
> >>>>>>>> {
> >>>>>>>> static int count = 3;
> >>>>>>>> count--;
> >>>>>>>> if (!count) goto exit;
> >>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>> if (Halt_Status)
> >>>>>>>> HERE: goto HERE;
> >>>>>>>> exit:
> >>>>>>>> return;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> int main()
> >>>>>>>> {
> >>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>> }
> >>>>>>>
> >>>>>>> Nope; you seem to have forgotten that my decider is not
> >>>>>>> recursive in nature: my decider will correctly determine that
> >>>>>>> that input is pathological so will signal an exception.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>>
> >>>>>>
> >>>>>> The above terminates normally so your decider gets the wrong
> >>>>>> answer.
> >>>>>
> >>>>> It is a pathological input so neither halts nor doesn't halt:
> >>>>> pathological input is INVALID so the correct "answer" is to
> >>>>> signal an exception.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> So you don't know how static variables work?
> >>>> I am not surprised.
> >>>>
> >>>>
> >>>> void P(ptr x)
> >>>> {
> >>>> static int count = 0;
> >>>> if (count++ >= 2) goto exit;
> >>>> int Halt_Status = H(x, x);
> >>>> if (Halt_Status)
> >>>> HERE: goto HERE;
> >>>> exit:
> >>>> return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H(P,P));
> >>>> }
> >>>>
> >>>> _Pm()
> >>>> [0000141e](01) 55 push ebp
> >>>> [0000141f](02) 8bec mov ebp,esp
> >>>> [00001421](03) 83ec08 sub esp,+08
> >>>> [00001424](05) a100000000 mov eax,[00000000]
> >>>> [00001429](03) 8945fc mov [ebp-04],eax
> >>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
> >>>> [00001432](03) 83c101 add ecx,+01
> >>>> [00001435](06) 890d00000000 mov [00000000],ecx
> >>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
> >>>> [0000143f](02) 7c02 jl 00001443
> >>>> [00001441](02) eb1b jmp 0000145e
> >>>> [00001443](03) 8b5508 mov edx,[ebp+08]
> >>>> [00001446](01) 52 push edx
> >>>> [00001447](03) 8b4508 mov eax,[ebp+08]
> >>>> [0000144a](01) 50 push eax
> >>>> [0000144b](05) e8defcffff call 0000112e
> >>>> [00001450](03) 83c408 add esp,+08
> >>>> [00001453](03) 8945f8 mov [ebp-08],eax
> >>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
> >>>> [0000145a](02) 7402 jz 0000145e
> >>>> [0000145c](02) ebfe jmp 0000145c
> >>>> [0000145e](02) 8be5 mov esp,ebp
> >>>> [00001460](01) 5d pop ebp
> >>>> [00001461](01) c3 ret
> >>>> Size in bytes:(0068) [00001461]
> >>>>
> >>>> _main()
> >>>> [0000146e](01) 55 push ebp
> >>>> [0000146f](02) 8bec mov ebp,esp
> >>>> [00001471](05) 681e140000 push 0000141e
> >>>> [00001476](05) 681e140000 push 0000141e
> >>>> [0000147b](05) e8aefcffff call 0000112e
> >>>> [00001480](03) 83c408 add esp,+08
> >>>> [00001483](01) 50 push eax
> >>>> [00001484](05) 685f050000 push 0000055f
> >>>> [00001489](05) e820f1ffff call 000005ae
> >>>> [0000148e](03) 83c408 add esp,+08
> >>>> [00001491](02) 33c0 xor eax,eax
> >>>> [00001493](01) 5d pop ebp
> >>>> [00001494](01) c3 ret
> >>>> Size in bytes:(0039) [00001494]
> >>>>
> >>>> machine stack stack machine assembly
> >>>> address address data code language
> >>>> ======== ======== ======== ========= =============
> >>>> [0000146e][00102462][00000000] 55 push ebp
> >>>> [0000146f][00102462][00000000] 8bec mov ebp,esp
> >>>> [00001471][0010245e][0000141e] 681e140000 push 0000141e
> >>>> [00001476][0010245a][0000141e] 681e140000 push 0000141e
> >>>> [0000147b][00102456][00001480] e8aefcffff call 0000112e
> >>>>
> >>>> H: Begin Simulation Execution Trace Stored at:11250e
> >>>> Address_of_H:112e
> >>>> [0000141e][001124fa][001124fe] 55 push ebp
> >>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
> >>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
> >>>> [00001424][001124f2][90909090] a100000000 mov eax,[00000000]
> >>>> [00001429][001124f2][90909090] 8945fc mov [ebp-04],eax
> >>>> [0000142c][001124f2][90909090] 8b0d00000000 mov ecx,[00000000]
> >>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
> >>>> [00001435][001124f2][90909090] 890d00000000 mov [00000000],ecx
> >>>> [0000143b][001124f2][90909090] 837dfc02 cmp dword
> >>>> [ebp-04],+02 [0000143f][001124f2][90909090] 7c02 jl
> >>>> 00001443 [00001441][001124f2][90909090] eb1b jmp 0000145e
> >>>> [0000145e][001124fa][001124fe] 8be5 mov esp,ebp
> >>>> [00001460][001124fe][00001217] 5d pop ebp
> >>>> [00001461][00112502][0000141e] c3 ret
> >>>> H: End Simulation Input Terminated Normally
> >>>>
> >>>> [00001480][00102462][00000000] 83c408 add esp,+08
> >>>> [00001483][0010245e][00000001] 50 push eax
> >>>> [00001484][0010245a][0000055f] 685f050000 push 0000055f
> >>>> [00001489][0010245a][0000055f] e820f1ffff call 000005ae
> >>>> Input_Halts = 1
> >>>> [0000148e][00102462][00000000] 83c408 add esp,+08
> >>>> [00001491][00102462][00000000] 33c0 xor eax,eax
> >>>> [00001493][00102466][00000018] 5d pop ebp
> >>>> [00001494][0010246a][00000000] c3 ret
> >>>> Number of Instructions Executed(1317) == 20 Pages
> >>>
> >>> For this particular stack trace I notice that the function symbol
> >>> at the top of it is Pm not P which suggests to me one of two
> >>> things:
> >>
> >> I already had a P so I renamed it to Pm so it would not disturb my
> >> existing code. When I changed all the Pm references to your name I
> >> forgot one.
> >
> > Then I suggest you check the output of compilation/linking is
> > actually initializing static variables correctly. Are you even
> > using a linker or are you just executing an object file? Static
> > data normally goes into a separate data segment during the linking
> > process.
> >
> > /Flibble
> >
>
> I haven't used static data in such a long time that I forgot the
> compiler does not allocate any space for static variables unless they
> have been initialized to a non-zero value.
>
> void Pm(u32 x)
> {
> static int count = 0x777;
> if (count++ > 0x777) goto exit;
> int Halt_Status = H(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> exit:
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
> }
>
>
> _Pm()
> [00000a1a](01) 55 push ebp
> [00000a1b](02) 8bec mov ebp,esp
> [00000a1d](03) 83ec08 sub esp,+08
> [00000a20](05) a107030000 mov eax,[00000307]
> [00000a25](03) 8945fc mov [ebp-04],eax
> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
> [00000a2e](03) 83c101 add ecx,+01
> [00000a31](06) 890d07030000 mov [00000307],ecx
> [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
> [00000a3e](02) 7e02 jng 00000a42
> [00000a40](02) eb1b jmp 00000a5d
> [00000a42](03) 8b5508 mov edx,[ebp+08]
> [00000a45](01) 52 push edx
> [00000a46](03) 8b4508 mov eax,[ebp+08]
> [00000a49](01) 50 push eax
> [00000a4a](05) e8ebfdffff call 0000083a // call H
> [00000a4f](03) 83c408 add esp,+08
> [00000a52](03) 8945f8 mov [ebp-08],eax
> [00000a55](04) 837df800 cmp dword [ebp-08],+00
> [00000a59](02) 7402 jz 00000a5d
> [00000a5b](02) ebfe jmp 00000a5b
> [00000a5d](02) 8be5 mov esp,ebp
> [00000a5f](01) 5d pop ebp
> [00000a60](01) c3 ret
> Size in bytes:(0071) [00000a60]
>
> _main()
> [00000a6a](01) 55 push ebp
> [00000a6b](02) 8bec mov ebp,esp
> [00000a6d](05) 681a0a0000 push 00000a1a // push address of P
> [00000a72](05) 681a0a0000 push 00000a1a // push address of P
> [00000a77](05) e8befdffff call 0000083a // call H
> [00000a7c](03) 83c408 add esp,+08
> [00000a7f](01) 50 push eax
> [00000a80](05) 680b030000 push 0000030b
> [00000a85](05) e8d0f8ffff call 0000035a
> [00000a8a](03) 83c408 add esp,+08
> [00000a8d](02) 33c0 xor eax,eax
> [00000a8f](01) 5d pop ebp
> [00000a90](01) c3 ret
> Size in bytes:(0039) [00000a90]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> ...[00000a6a][0010137b][00000000] 55 push ebp
> ...[00000a6b][0010137b][00000000] 8bec mov ebp,esp
> ...[00000a6d][00101377][00000a1a] 681a0a0000 push 00000a1a
> ...[00000a72][00101373][00000a1a] 681a0a0000 push 00000a1a
> ...[00000a77][0010136f][00000a7c] e8befdffff call 0000083a
> New slave_stack at:201427
>
> Begin Local Halt Decider Simulation Execution Trace Stored at:21142f
> ...[00000a1a][0021141b][0021141f] 55 push ebp
> ...[00000a1b][0021141b][0021141f] 8bec mov ebp,esp
> ...[00000a1d][00211413][90909090] 83ec08 sub esp,+08
> ...[00000a20][00211413][90909090] a107030000 mov eax,[00000307]
> ...[00000a25][00211413][90909090] 8945fc mov [ebp-04],eax
> ...[00000a28][00211413][90909090] 8b0d07030000 mov ecx,[00000307]
> ...[00000a2e][00211413][90909090] 83c101 add ecx,+01
> ...[00000a31][00211413][90909090] 890d07030000 mov [00000307],ecx
> ...[00000a37][00211413][90909090] 817dfc77070000 cmp dword
> [ebp-04],00000777
> ...[00000a3e][00211413][90909090] 7e02 jng 00000a42
> ...[00000a42][00211413][90909090] 8b5508 mov edx,[ebp+08]
> ...[00000a45][0021140f][00000a1a] 52 push edx //
> push address of P
> ...[00000a46][0021140f][00000a1a] 8b4508 mov eax,[ebp+08]
> ...[00000a49][0021140b][00000a1a] 50 push eax //
> push address of P
> ...[00000a4a][00211407][00000a4f] e8ebfdffff call 0000083a //
> call H New slave_stack at:24be4f
> ...[00000a1a][0025be43][0025be47] 55 push ebp
> ...[00000a1b][0025be43][0025be47] 8bec mov ebp,esp
> ...[00000a1d][0025be3b][90909090] 83ec08 sub esp,+08
> ...[00000a20][0025be3b][90909090] a107030000 mov eax,[00000307]
> ...[00000a25][0025be3b][90909090] 8945fc mov [ebp-04],eax
> ...[00000a28][0025be3b][90909090] 8b0d07030000 mov ecx,[00000307]
> ...[00000a2e][0025be3b][90909090] 83c101 add ecx,+01
> ...[00000a31][0025be3b][90909090] 890d07030000 mov [00000307],ecx
> ...[00000a37][0025be3b][90909090] 817dfc77070000 cmp dword
> [ebp-04],00000777
> ...[00000a3e][0025be3b][90909090] 7e02 jng 00000a42
> ...[00000a40][0025be3b][90909090] eb1b jmp 00000a5d // jmp
> to exit
> ...[00000a5d][0025be43][0025be47] 8be5 mov esp,ebp
> ...[00000a5f][0025be47][00000904] 5d pop ebp
> ...[00000a60][0025be4b][00000a1a] c3 ret
> ...[00000a7c][0010137b][00000000] 83c408 add esp,+08
> ...[00000a7f][00101377][00000001] 50 push eax
> ...[00000a80][00101373][0000030b] 680b030000 push 0000030b
> ---[00000a85][00101373][0000030b] e8d0f8ffff call 0000035a
> Input_Halts = 1
> ...[00000a8a][0010137b][00000000] 83c408 add esp,+08
> ...[00000a8d][0010137b][00000000] 33c0 xor eax,eax
> ...[00000a8f][0010137f][00100000] 5d pop ebp
> ...[00000a90][00101383][00000004] c3 ret
> Number of Instructions Executed(27278)
>
>
Still seems wrong: post increment of the static variable should ensure
that it does NOT goto exit but instead should call H which should
presumably cause your "infinite recursion detected" bollocks to
manifest.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2022-07-15 12:26 -0500 |
| Message-ID | <PrGdnQUtprD9Pkz_nZ2dnUU7_8zNnZ2d@giganews.com> |
| In reply to | #85252 |
On 7/15/2022 12:08 PM, Mr Flibble wrote:
> On Fri, 15 Jul 2022 12:00:59 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
void Pm(ptr x)
{
static int count = 0x777;
if (count++ > 0x777) goto exit;
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
exit:
return;
}
int main()
{
Output("Input_Halts = ", H(Pm,Pm));
}
_Pm()
[000013fa](01) 55 push ebp
[000013fb](02) 8bec mov ebp,esp
[000013fd](03) 83ec08 sub esp,+08
[00001400](05) a137050000 mov eax,[00000537]
[00001405](03) 8945fc mov [ebp-04],eax
[00001408](06) 8b0d37050000 mov ecx,[00000537]
[0000140e](03) 83c101 add ecx,+01
[00001411](06) 890d37050000 mov [00000537],ecx
[00001417](07) 817dfc77070000 cmp dword [ebp-04],00000777
[0000141e](02) 7e02 jng 00001422
[00001420](02) eb1b jmp 0000143d
[00001422](03) 8b5508 mov edx,[ebp+08]
[00001425](01) 52 push edx
[00001426](03) 8b4508 mov eax,[ebp+08]
[00001429](01) 50 push eax
[0000142a](05) e8dbfcffff call 0000110a
[0000142f](03) 83c408 add esp,+08
[00001432](03) 8945f8 mov [ebp-08],eax
[00001435](04) 837df800 cmp dword [ebp-08],+00
[00001439](02) 7402 jz 0000143d
[0000143b](02) ebfe jmp 0000143b
[0000143d](02) 8be5 mov esp,ebp
[0000143f](01) 5d pop ebp
[00001440](01) c3 ret
Size in bytes:(0071) [00001440]
_main()
[0000144a](01) 55 push ebp
[0000144b](02) 8bec mov ebp,esp
[0000144d](05) 68fa130000 push 000013fa
[00001452](05) 68fa130000 push 000013fa
[00001457](05) e8aefcffff call 0000110a
[0000145c](03) 83c408 add esp,+08
[0000145f](01) 50 push eax
[00001460](05) 683b050000 push 0000053b
[00001465](05) e820f1ffff call 0000058a
[0000146a](03) 83c408 add esp,+08
[0000146d](02) 33c0 xor eax,eax
[0000146f](01) 5d pop ebp
[00001470](01) c3 ret
Size in bytes:(0039) [00001470]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[0000144a][00102412][00000000] 55 push ebp
[0000144b][00102412][00000000] 8bec mov ebp,esp
[0000144d][0010240e][000013fa] 68fa130000 push 000013fa
[00001452][0010240a][000013fa] 68fa130000 push 000013fa
[00001457][00102406][0000145c] e8aefcffff call 0000110a
H: Begin Simulation Execution Trace Stored at:1124be
Address_of_H:110a
[000013fa][001124aa][001124ae] 55 push ebp
[000013fb][001124aa][001124ae] 8bec mov ebp,esp
[000013fd][001124a2][90909090] 83ec08 sub esp,+08
[00001400][001124a2][90909090] a137050000 mov eax,[00000537]
[00001405][001124a2][90909090] 8945fc mov [ebp-04],eax
[00001408][001124a2][90909090] 8b0d37050000 mov ecx,[00000537]
[0000140e][001124a2][90909090] 83c101 add ecx,+01
[00001411][001124a2][90909090] 890d37050000 mov [00000537],ecx
[00001417][001124a2][90909090] 817dfc77070000 cmp dword [ebp-04],00000777
[0000141e][001124a2][90909090] 7e02 jng 00001422
[00001422][001124a2][90909090] 8b5508 mov edx,[ebp+08]
[00001425][0011249e][000013fa] 52 push edx
[00001426][0011249e][000013fa] 8b4508 mov eax,[ebp+08]
[00001429][0011249a][000013fa] 50 push eax
[0000142a][00112496][0000142f] e8dbfcffff call 0000110a
H: Begin Simulation Execution Trace Stored at:15cee6
Address_of_H:110a
[000013fa][0015ced2][0015ced6] 55 push ebp
[000013fb][0015ced2][0015ced6] 8bec mov ebp,esp
[000013fd][0015ceca][90909090] 83ec08 sub esp,+08
[00001400][0015ceca][90909090] a137050000 mov eax,[00000537]
[00001405][0015ceca][90909090] 8945fc mov [ebp-04],eax
[00001408][0015ceca][90909090] 8b0d37050000 mov ecx,[00000537]
[0000140e][0015ceca][90909090] 83c101 add ecx,+01
[00001411][0015ceca][90909090] 890d37050000 mov [00000537],ecx
[00001417][0015ceca][90909090] 817dfc77070000 cmp dword [ebp-04],00000777
[0000141e][0015ceca][90909090] 7e02 jng 00001422
[00001420][0015ceca][90909090] eb1b jmp 0000143d
[0000143d][0015ced2][0015ced6] 8be5 mov esp,ebp
[0000143f][0015ced6][000011f3] 5d pop ebp
[00001440][0015ceda][000013fa] c3 ret
H: End Simulation Input Terminated Normally
[0000142f][001124a2][90909090] 83c408 add esp,+08
[00001432][001124a2][00000001] 8945f8 mov [ebp-08],eax
[00001435][001124a2][00000001] 837df800 cmp dword [ebp-08],+00
[00001439][001124a2][00000001] 7402 jz 0000143d
[0000143b][001124a2][00000001] ebfe jmp 0000143b
[0000143b][001124a2][00000001] ebfe jmp 0000143b
H: Infinite Loop Detected Simulation Stopped
[0000145c][00102412][00000000] 83c408 add esp,+08
[0000145f][0010240e][00000000] 50 push eax
[00001460][0010240a][0000053b] 683b050000 push 0000053b
[00001465][0010240a][0000053b] e820f1ffff call 0000058a
Input_Halts = 0
[0000146a][00102412][00000000] 83c408 add esp,+08
[0000146d][00102412][00000000] 33c0 xor eax,eax
[0000146f][00102416][00000018] 5d pop ebp
[00001470][0010241a][00000000] c3 ret
Number of Instructions Executed(887380) == 13244 Pages
> Still seems wrong: post increment of the static variable should ensure
> that it does NOT goto exit but instead should call H which should
> presumably cause your "infinite recursion detected" bollocks to
> manifest.
>
> /Flibble
>
I rewrote it so that my latest version of H could process it.
I was surprised and pleased that the version of H that has been
transformed into a computable function can still correctly perform
recursive emulation.
I was also surprised and pleased that H(Pm,Pm) determined that its input
is non-halting. It did not occur to me that the outer nested simulation
would return 1 to the inner nested simulation causing its P to get into
an infinite loop.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-07-15 18:28 +0100 |
| Message-ID | <20220715182802.0000170e@reddwarf.jmc.corp> |
| In reply to | #85252 |
On Fri, 15 Jul 2022 18:08:22 +0100
Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
> On Fri, 15 Jul 2022 12:00:59 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
> > On 7/15/2022 11:03 AM, Mr Flibble wrote:
> > > On Fri, 15 Jul 2022 10:58:14 -0500
> > > olcott <NoOne@NoWhere.com> wrote:
> > >
> > >> On 7/15/2022 10:49 AM, Mr Flibble wrote:
> > >>> On Fri, 15 Jul 2022 10:07:36 -0500
> > >>> olcott <NoOne@NoWhere.com> wrote:
> > >>>
> > >>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
> > >>>>> On Fri, 15 Jul 2022 09:19:59 -0500
> > >>>>> olcott <NoOne@NoWhere.com> wrote:
> > >>>>>
> > >>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
> > >>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
> > >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > >>>>>>>
> > >>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
> > >>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
> > >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > >>>>>>>>>
> > >>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
> > >>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
> > >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > >>>>>>>>>>>
> > >>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
> > >>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
> > >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
> > >>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
> > >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> This is an explanation of a key new insight into
> > >>>>>>>>>>>>>>>> the halting problem provided in the language of
> > >>>>>>>>>>>>>>>> software engineering. Technical computer science
> > >>>>>>>>>>>>>>>> terms are explained using software engineering
> > >>>>>>>>>>>>>>>> terms. No knowledge of the halting problem is
> > >>>>>>>>>>>>>>>> required.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> It is based on fully operational software executed
> > >>>>>>>>>>>>>>>> in the x86utm operating system. The x86utm
> > >>>>>>>>>>>>>>>> operating system (based on an excellent open
> > >>>>>>>>>>>>>>>> source x86 emulator) was created to study the
> > >>>>>>>>>>>>>>>> details of the halting problem proof
> > >>>>>>>>>>>>>>>> counter-examples at the much higher level of
> > >>>>>>>>>>>>>>>> abstraction of C/x86.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> typedef void (*ptr)();
> > >>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt decider
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> void P(ptr x)
> > >>>>>>>>>>>>>>>> {
> > >>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> > >>>>>>>>>>>>>>>> if (Halt_Status)
> > >>>>>>>>>>>>>>>> HERE: goto HERE;
> > >>>>>>>>>>>>>>>> return;
> > >>>>>>>>>>>>>>>> }
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> int main()
> > >>>>>>>>>>>>>>>> {
> > >>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> > >>>>>>>>>>>>>>>> }
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> When simulating halt decider H(P,P) simulates its
> > >>>>>>>>>>>>>>>> input we can see that: (1) Function H() is called
> > >>>>>>>>>>>>>>>> from P(). (2) With the same arguments to H().
> > >>>>>>>>>>>>>>>> (3) With no instructions in P preceding its
> > >>>>>>>>>>>>>>>> invocation of H(P,P).
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> The above shows that the simulated P cannot
> > >>>>>>>>>>>>>>>> possibly terminate normally. Because H can see the
> > >>>>>>>>>>>>>>>> same (1)(2)(3) that we see H aborts its simulation
> > >>>>>>>>>>>>>>>> of P and rejects P as non-halting.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> In computability theory, the halting
> > >>>>>>>>>>>>>>>> problem is the problem of determining, from a
> > >>>>>>>>>>>>>>>> description of an arbitrary computer program and an
> > >>>>>>>>>>>>>>>> input, whether the program will finish running, or
> > >>>>>>>>>>>>>>>> continue to run forever. Alan Turing proved in 1936
> > >>>>>>>>>>>>>>>> that a general algorithm to solve the halting
> > >>>>>>>>>>>>>>>> problem for all possible program- input pairs
> > >>>>>>>>>>>>>>>> cannot exist.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> For any program H that might
> > >>>>>>>>>>>>>>>> determine if programs halt, a "pathological"
> > >>>>>>>>>>>>>>>> program P, called with some input, can pass its
> > >>>>>>>>>>>>>>>> own source and its input to H and then
> > >>>>>>>>>>>>>>>> specifically do the opposite of what H predicts P
> > >>>>>>>>>>>>>>>> will do. No H can exist that handles this case.
> > >>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> H and P implement the exact pathological
> > >>>>>>>>>>>>>>>> relationship to each other as described above.
> > >>>>>>>>>>>>>>>> Because H(P,P) does handle this case the above
> > >>>>>>>>>>>>>>>> halting problem undecidable input template has
> > >>>>>>>>>>>>>>>> been refuted.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> *When this halt deciding principle understood to be
> > >>>>>>>>>>>>>>>> correct* A halt decider must compute the mapping
> > >>>>>>>>>>>>>>>> from its inputs to an accept or reject state on
> > >>>>>>>>>>>>>>>> the basis of the actual behavior that is actually
> > >>>>>>>>>>>>>>>> specified by these inputs.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> *Then (by logical necessity) this implements that
> > >>>>>>>>>>>>>>>> principle* Every simulating halt decider that
> > >>>>>>>>>>>>>>>> correctly simulates its input until it correctly
> > >>>>>>>>>>>>>>>> predicts that this simulated input would never
> > >>>>>>>>>>>>>>>> terminate normally, correctly rejects this input as
> > >>>>>>>>>>>>>>>> non-halting.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> *H is a Pure function*
> > >>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> thus implements a *Computable function*
> > >>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Thus H is Turing computable.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> *Halting problem proofs refuted on the basis of
> > >>>>>>>>>>>>>>>> software engineering*
> > >>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> You forgot to mention infinite recursion which I
> > >>>>>>>>>>>>>>> suppose is progress.
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> /Flibble
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> I have shown that H/P does implement the HP's
> > >>>>>>>>>>>>>> "impossible input" template.
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> Therefore I have refuted all of the halting problem
> > >>>>>>>>>>>>>> proofs that rely on this template.
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> Equating pathological input with non-halting is
> > >>>>>>>>>>>>> erroneous: you are only doing that because your broken
> > >>>>>>>>>>>>> solution treats it as "infinite recursion". There is
> > >>>>>>>>>>>>> no recursion in [Strachey 1965] and the HP proofs
> > >>>>>>>>>>>>> based on it.
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> /Flibble
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> There is no recursion in any of the conventional proofs
> > >>>>>>>>>>>> only because no one ever previously bothered to fully
> > >>>>>>>>>>>> examine how a simulating halt decider would address
> > >>>>>>>>>>>> these otherwise "impossible" inputs.
> > >>>>>>>>>>>
> > >>>>>>>>>>> I have shown that a simulating halt decider needn't be
> > >>>>>>>>>>> recursive in nature:
> > >>>>>>>>>>>
> > >>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> > >>>>>>>>>>>
> > >>>>>>>>>>> /Flibble
> > >>>>>>>>>>>
> > >>>>>>>>>>
> > >>>>>>>>>> You sure do make it easy to review your work.
> > >>>>>>>>>>
> > >>>>>>>>>> "When the simulator detects the call to H in P it
> > >>>>>>>>>> forks the simulation into a non-halting branch"
> > >>>>>>>>>>
> > >>>>>>>>>> There is an infinite set of cases where this overly
> > >>>>>>>>>> simplistic criteria gets the wrong answer.
> > >>>>>>>>>
> > >>>>>>>>> That is neither an honest review or any kind of rebuttal:
> > >>>>>>>>> I have told you before: assertions made without evidence
> > >>>>>>>>> can be dismissed without evidence.
> > >>>>>>>>>
> > >>>>>>>>> If you claim there are an infinite number of cases where
> > >>>>>>>>> it gets the wrong answer then it shouldn't be too hard
> > >>>>>>>>> for to provide ONE case backing up your claim.
> > >>>>>>>>>
> > >>>>>>>>> /Flibble
> > >>>>>>>>>
> > >>>>>>>> Sure:
> > >>>>>>>>
> > >>>>>>>> void P(ptr x)
> > >>>>>>>> {
> > >>>>>>>> static int count = 3;
> > >>>>>>>> count--;
> > >>>>>>>> if (!count) goto exit;
> > >>>>>>>> int Halt_Status = H(x, x);
> > >>>>>>>> if (Halt_Status)
> > >>>>>>>> HERE: goto HERE;
> > >>>>>>>> exit:
> > >>>>>>>> return;
> > >>>>>>>> }
> > >>>>>>>>
> > >>>>>>>> int main()
> > >>>>>>>> {
> > >>>>>>>> Output("Input_Halts = ", H(P, P));
> > >>>>>>>> }
> > >>>>>>>
> > >>>>>>> Nope; you seem to have forgotten that my decider is not
> > >>>>>>> recursive in nature: my decider will correctly determine
> > >>>>>>> that that input is pathological so will signal an exception.
> > >>>>>>>
> > >>>>>>> /Flibble
> > >>>>>>>
> > >>>>>>>
> > >>>>>>
> > >>>>>> The above terminates normally so your decider gets the wrong
> > >>>>>> answer.
> > >>>>>
> > >>>>> It is a pathological input so neither halts nor doesn't halt:
> > >>>>> pathological input is INVALID so the correct "answer" is to
> > >>>>> signal an exception.
> > >>>>>
> > >>>>> /Flibble
> > >>>>>
> > >>>>
> > >>>> So you don't know how static variables work?
> > >>>> I am not surprised.
> > >>>>
> > >>>>
> > >>>> void P(ptr x)
> > >>>> {
> > >>>> static int count = 0;
> > >>>> if (count++ >= 2) goto exit;
> > >>>> int Halt_Status = H(x, x);
> > >>>> if (Halt_Status)
> > >>>> HERE: goto HERE;
> > >>>> exit:
> > >>>> return;
> > >>>> }
> > >>>>
> > >>>> int main()
> > >>>> {
> > >>>> Output("Input_Halts = ", H(P,P));
> > >>>> }
> > >>>>
> > >>>> _Pm()
> > >>>> [0000141e](01) 55 push ebp
> > >>>> [0000141f](02) 8bec mov ebp,esp
> > >>>> [00001421](03) 83ec08 sub esp,+08
> > >>>> [00001424](05) a100000000 mov eax,[00000000]
> > >>>> [00001429](03) 8945fc mov [ebp-04],eax
> > >>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
> > >>>> [00001432](03) 83c101 add ecx,+01
> > >>>> [00001435](06) 890d00000000 mov [00000000],ecx
> > >>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
> > >>>> [0000143f](02) 7c02 jl 00001443
> > >>>> [00001441](02) eb1b jmp 0000145e
> > >>>> [00001443](03) 8b5508 mov edx,[ebp+08]
> > >>>> [00001446](01) 52 push edx
> > >>>> [00001447](03) 8b4508 mov eax,[ebp+08]
> > >>>> [0000144a](01) 50 push eax
> > >>>> [0000144b](05) e8defcffff call 0000112e
> > >>>> [00001450](03) 83c408 add esp,+08
> > >>>> [00001453](03) 8945f8 mov [ebp-08],eax
> > >>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
> > >>>> [0000145a](02) 7402 jz 0000145e
> > >>>> [0000145c](02) ebfe jmp 0000145c
> > >>>> [0000145e](02) 8be5 mov esp,ebp
> > >>>> [00001460](01) 5d pop ebp
> > >>>> [00001461](01) c3 ret
> > >>>> Size in bytes:(0068) [00001461]
> > >>>>
> > >>>> _main()
> > >>>> [0000146e](01) 55 push ebp
> > >>>> [0000146f](02) 8bec mov ebp,esp
> > >>>> [00001471](05) 681e140000 push 0000141e
> > >>>> [00001476](05) 681e140000 push 0000141e
> > >>>> [0000147b](05) e8aefcffff call 0000112e
> > >>>> [00001480](03) 83c408 add esp,+08
> > >>>> [00001483](01) 50 push eax
> > >>>> [00001484](05) 685f050000 push 0000055f
> > >>>> [00001489](05) e820f1ffff call 000005ae
> > >>>> [0000148e](03) 83c408 add esp,+08
> > >>>> [00001491](02) 33c0 xor eax,eax
> > >>>> [00001493](01) 5d pop ebp
> > >>>> [00001494](01) c3 ret
> > >>>> Size in bytes:(0039) [00001494]
> > >>>>
> > >>>> machine stack stack machine assembly
> > >>>> address address data code language
> > >>>> ======== ======== ======== ========= =============
> > >>>> [0000146e][00102462][00000000] 55 push ebp
> > >>>> [0000146f][00102462][00000000] 8bec mov ebp,esp
> > >>>> [00001471][0010245e][0000141e] 681e140000 push 0000141e
> > >>>> [00001476][0010245a][0000141e] 681e140000 push 0000141e
> > >>>> [0000147b][00102456][00001480] e8aefcffff call 0000112e
> > >>>>
> > >>>> H: Begin Simulation Execution Trace Stored at:11250e
> > >>>> Address_of_H:112e
> > >>>> [0000141e][001124fa][001124fe] 55 push ebp
> > >>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
> > >>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
> > >>>> [00001424][001124f2][90909090] a100000000 mov eax,[00000000]
> > >>>> [00001429][001124f2][90909090] 8945fc mov [ebp-04],eax
> > >>>> [0000142c][001124f2][90909090] 8b0d00000000 mov ecx,[00000000]
> > >>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
> > >>>> [00001435][001124f2][90909090] 890d00000000 mov [00000000],ecx
> > >>>> [0000143b][001124f2][90909090] 837dfc02 cmp dword
> > >>>> [ebp-04],+02 [0000143f][001124f2][90909090] 7c02 jl
> > >>>> 00001443 [00001441][001124f2][90909090] eb1b jmp
> > >>>> 0000145e [0000145e][001124fa][001124fe] 8be5 mov
> > >>>> esp,ebp [00001460][001124fe][00001217] 5d pop ebp
> > >>>> [00001461][00112502][0000141e] c3 ret
> > >>>> H: End Simulation Input Terminated Normally
> > >>>>
> > >>>> [00001480][00102462][00000000] 83c408 add esp,+08
> > >>>> [00001483][0010245e][00000001] 50 push eax
> > >>>> [00001484][0010245a][0000055f] 685f050000 push 0000055f
> > >>>> [00001489][0010245a][0000055f] e820f1ffff call 000005ae
> > >>>> Input_Halts = 1
> > >>>> [0000148e][00102462][00000000] 83c408 add esp,+08
> > >>>> [00001491][00102462][00000000] 33c0 xor eax,eax
> > >>>> [00001493][00102466][00000018] 5d pop ebp
> > >>>> [00001494][0010246a][00000000] c3 ret
> > >>>> Number of Instructions Executed(1317) == 20 Pages
> > >>>
> > >>> For this particular stack trace I notice that the function
> > >>> symbol at the top of it is Pm not P which suggests to me one of
> > >>> two things:
> > >>
> > >> I already had a P so I renamed it to Pm so it would not disturb
> > >> my existing code. When I changed all the Pm references to your
> > >> name I forgot one.
> > >
> > > Then I suggest you check the output of compilation/linking is
> > > actually initializing static variables correctly. Are you even
> > > using a linker or are you just executing an object file? Static
> > > data normally goes into a separate data segment during the linking
> > > process.
> > >
> > > /Flibble
> > >
> >
> > I haven't used static data in such a long time that I forgot the
> > compiler does not allocate any space for static variables unless
> > they have been initialized to a non-zero value.
> >
> > void Pm(u32 x)
> > {
> > static int count = 0x777;
> > if (count++ > 0x777) goto exit;
> > int Halt_Status = H(x, x);
> > if (Halt_Status)
> > HERE: goto HERE;
> > exit:
> > return;
> > }
> >
> > int main()
> > {
> > Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
> > }
> >
> >
> > _Pm()
> > [00000a1a](01) 55 push ebp
> > [00000a1b](02) 8bec mov ebp,esp
> > [00000a1d](03) 83ec08 sub esp,+08
> > [00000a20](05) a107030000 mov eax,[00000307]
> > [00000a25](03) 8945fc mov [ebp-04],eax
> > [00000a28](06) 8b0d07030000 mov ecx,[00000307]
> > [00000a2e](03) 83c101 add ecx,+01
> > [00000a31](06) 890d07030000 mov [00000307],ecx
> > [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
> > [00000a3e](02) 7e02 jng 00000a42
> > [00000a40](02) eb1b jmp 00000a5d
> > [00000a42](03) 8b5508 mov edx,[ebp+08]
> > [00000a45](01) 52 push edx
> > [00000a46](03) 8b4508 mov eax,[ebp+08]
> > [00000a49](01) 50 push eax
> > [00000a4a](05) e8ebfdffff call 0000083a // call H
> > [00000a4f](03) 83c408 add esp,+08
> > [00000a52](03) 8945f8 mov [ebp-08],eax
> > [00000a55](04) 837df800 cmp dword [ebp-08],+00
> > [00000a59](02) 7402 jz 00000a5d
> > [00000a5b](02) ebfe jmp 00000a5b
> > [00000a5d](02) 8be5 mov esp,ebp
> > [00000a5f](01) 5d pop ebp
> > [00000a60](01) c3 ret
> > Size in bytes:(0071) [00000a60]
> >
> > _main()
> > [00000a6a](01) 55 push ebp
> > [00000a6b](02) 8bec mov ebp,esp
> > [00000a6d](05) 681a0a0000 push 00000a1a // push address of P
> > [00000a72](05) 681a0a0000 push 00000a1a // push address of P
> > [00000a77](05) e8befdffff call 0000083a // call H
> > [00000a7c](03) 83c408 add esp,+08
> > [00000a7f](01) 50 push eax
> > [00000a80](05) 680b030000 push 0000030b
> > [00000a85](05) e8d0f8ffff call 0000035a
> > [00000a8a](03) 83c408 add esp,+08
> > [00000a8d](02) 33c0 xor eax,eax
> > [00000a8f](01) 5d pop ebp
> > [00000a90](01) c3 ret
> > Size in bytes:(0039) [00000a90]
> >
> > machine stack stack machine assembly
> > address address data code language
> > ======== ======== ======== ========= =============
> > ...[00000a6a][0010137b][00000000] 55 push ebp
> > ...[00000a6b][0010137b][00000000] 8bec mov ebp,esp
> > ...[00000a6d][00101377][00000a1a] 681a0a0000 push 00000a1a
> > ...[00000a72][00101373][00000a1a] 681a0a0000 push 00000a1a
> > ...[00000a77][0010136f][00000a7c] e8befdffff call 0000083a
> > New slave_stack at:201427
> >
> > Begin Local Halt Decider Simulation Execution Trace Stored
> > at:21142f ...[00000a1a][0021141b][0021141f] 55 push ebp
> > ...[00000a1b][0021141b][0021141f] 8bec mov ebp,esp
> > ...[00000a1d][00211413][90909090] 83ec08 sub esp,+08
> > ...[00000a20][00211413][90909090] a107030000 mov eax,[00000307]
> > ...[00000a25][00211413][90909090] 8945fc mov [ebp-04],eax
> > ...[00000a28][00211413][90909090] 8b0d07030000 mov ecx,[00000307]
> > ...[00000a2e][00211413][90909090] 83c101 add ecx,+01
> > ...[00000a31][00211413][90909090] 890d07030000 mov [00000307],ecx
> > ...[00000a37][00211413][90909090] 817dfc77070000 cmp dword
> > [ebp-04],00000777
> > ...[00000a3e][00211413][90909090] 7e02 jng 00000a42
> > ...[00000a42][00211413][90909090] 8b5508 mov edx,[ebp+08]
> > ...[00000a45][0021140f][00000a1a] 52 push edx //
> > push address of P
> > ...[00000a46][0021140f][00000a1a] 8b4508 mov eax,[ebp+08]
> > ...[00000a49][0021140b][00000a1a] 50 push eax //
> > push address of P
> > ...[00000a4a][00211407][00000a4f] e8ebfdffff call 0000083a //
> > call H New slave_stack at:24be4f
> > ...[00000a1a][0025be43][0025be47] 55 push ebp
> > ...[00000a1b][0025be43][0025be47] 8bec mov ebp,esp
> > ...[00000a1d][0025be3b][90909090] 83ec08 sub esp,+08
> > ...[00000a20][0025be3b][90909090] a107030000 mov eax,[00000307]
> > ...[00000a25][0025be3b][90909090] 8945fc mov [ebp-04],eax
> > ...[00000a28][0025be3b][90909090] 8b0d07030000 mov ecx,[00000307]
> > ...[00000a2e][0025be3b][90909090] 83c101 add ecx,+01
> > ...[00000a31][0025be3b][90909090] 890d07030000 mov [00000307],ecx
> > ...[00000a37][0025be3b][90909090] 817dfc77070000 cmp dword
> > [ebp-04],00000777
> > ...[00000a3e][0025be3b][90909090] 7e02 jng 00000a42
> > ...[00000a40][0025be3b][90909090] eb1b jmp 00000a5d //
> > jmp to exit
> > ...[00000a5d][0025be43][0025be47] 8be5 mov esp,ebp
> > ...[00000a5f][0025be47][00000904] 5d pop ebp
> > ...[00000a60][0025be4b][00000a1a] c3 ret
> > ...[00000a7c][0010137b][00000000] 83c408 add esp,+08
> > ...[00000a7f][00101377][00000001] 50 push eax
> > ...[00000a80][00101373][0000030b] 680b030000 push 0000030b
> > ---[00000a85][00101373][0000030b] e8d0f8ffff call 0000035a
> > Input_Halts = 1
> > ...[00000a8a][0010137b][00000000] 83c408 add esp,+08
> > ...[00000a8d][0010137b][00000000] 33c0 xor eax,eax
> > ...[00000a8f][0010137f][00100000] 5d pop ebp
> > ...[00000a90][00101383][00000004] c3 ret
> > Number of Instructions Executed(27278)
> >
> >
>
> Still seems wrong: post increment of the static variable should ensure
> that it does NOT goto exit but instead should call H which should
> presumably cause your "infinite recursion detected" bollocks to
> manifest.
OK, I've looked at your assembly trace and it is recursing into Pm from
H and then halting but I am not sure what you are trying to prove?
Again [Strachey 1965] and associated proofs are not recursive in nature.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2022-07-15 12:39 -0500 |
| Message-ID | <2KidnQBTRtnJO0z_nZ2dnUU7_83NnZ2d@giganews.com> |
| In reply to | #85256 |
On 7/15/2022 12:28 PM, Mr Flibble wrote:
> On Fri, 15 Jul 2022 18:08:22 +0100
> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
>
>> On Fri, 15 Jul 2022 12:00:59 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
>>>> On Fri, 15 Jul 2022 10:58:14 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>
>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>
>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>
>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This is an explanation of a key new insight into
>>>>>>>>>>>>>>>>>>> the halting problem provided in the language of
>>>>>>>>>>>>>>>>>>> software engineering. Technical computer science
>>>>>>>>>>>>>>>>>>> terms are explained using software engineering
>>>>>>>>>>>>>>>>>>> terms. No knowledge of the halting problem is
>>>>>>>>>>>>>>>>>>> required.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is based on fully operational software executed
>>>>>>>>>>>>>>>>>>> in the x86utm operating system. The x86utm
>>>>>>>>>>>>>>>>>>> operating system (based on an excellent open
>>>>>>>>>>>>>>>>>>> source x86 emulator) was created to study the
>>>>>>>>>>>>>>>>>>> details of the halting problem proof
>>>>>>>>>>>>>>>>>>> counter-examples at the much higher level of
>>>>>>>>>>>>>>>>>>> abstraction of C/x86.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt decider
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P) simulates its
>>>>>>>>>>>>>>>>>>> input we can see that: (1) Function H() is called
>>>>>>>>>>>>>>>>>>> from P(). (2) With the same arguments to H().
>>>>>>>>>>>>>>>>>>> (3) With no instructions in P preceding its
>>>>>>>>>>>>>>>>>>> invocation of H(P,P).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The above shows that the simulated P cannot
>>>>>>>>>>>>>>>>>>> possibly terminate normally. Because H can see the
>>>>>>>>>>>>>>>>>>> same (1)(2)(3) that we see H aborts its simulation
>>>>>>>>>>>>>>>>>>> of P and rejects P as non-halting.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> In computability theory, the halting
>>>>>>>>>>>>>>>>>>> problem is the problem of determining, from a
>>>>>>>>>>>>>>>>>>> description of an arbitrary computer program and an
>>>>>>>>>>>>>>>>>>> input, whether the program will finish running, or
>>>>>>>>>>>>>>>>>>> continue to run forever. Alan Turing proved in 1936
>>>>>>>>>>>>>>>>>>> that a general algorithm to solve the halting
>>>>>>>>>>>>>>>>>>> problem for all possible program- input pairs
>>>>>>>>>>>>>>>>>>> cannot exist.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> For any program H that might
>>>>>>>>>>>>>>>>>>> determine if programs halt, a "pathological"
>>>>>>>>>>>>>>>>>>> program P, called with some input, can pass its
>>>>>>>>>>>>>>>>>>> own source and its input to H and then
>>>>>>>>>>>>>>>>>>> specifically do the opposite of what H predicts P
>>>>>>>>>>>>>>>>>>> will do. No H can exist that handles this case.
>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
>>>>>>>>>>>>>>>>>>> relationship to each other as described above.
>>>>>>>>>>>>>>>>>>> Because H(P,P) does handle this case the above
>>>>>>>>>>>>>>>>>>> halting problem undecidable input template has
>>>>>>>>>>>>>>>>>>> been refuted.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *When this halt deciding principle understood to be
>>>>>>>>>>>>>>>>>>> correct* A halt decider must compute the mapping
>>>>>>>>>>>>>>>>>>> from its inputs to an accept or reject state on
>>>>>>>>>>>>>>>>>>> the basis of the actual behavior that is actually
>>>>>>>>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this implements that
>>>>>>>>>>>>>>>>>>> principle* Every simulating halt decider that
>>>>>>>>>>>>>>>>>>> correctly simulates its input until it correctly
>>>>>>>>>>>>>>>>>>> predicts that this simulated input would never
>>>>>>>>>>>>>>>>>>> terminate normally, correctly rejects this input as
>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *H is a Pure function*
>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the basis of
>>>>>>>>>>>>>>>>>>> software engineering*
>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion which I
>>>>>>>>>>>>>>>>>> suppose is progress.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I have shown that H/P does implement the HP's
>>>>>>>>>>>>>>>>> "impossible input" template.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting problem
>>>>>>>>>>>>>>>>> proofs that rely on this template.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Equating pathological input with non-halting is
>>>>>>>>>>>>>>>> erroneous: you are only doing that because your broken
>>>>>>>>>>>>>>>> solution treats it as "infinite recursion". There is
>>>>>>>>>>>>>>>> no recursion in [Strachey 1965] and the HP proofs
>>>>>>>>>>>>>>>> based on it.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> There is no recursion in any of the conventional proofs
>>>>>>>>>>>>>>> only because no one ever previously bothered to fully
>>>>>>>>>>>>>>> examine how a simulating halt decider would address
>>>>>>>>>>>>>>> these otherwise "impossible" inputs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I have shown that a simulating halt decider needn't be
>>>>>>>>>>>>>> recursive in nature:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You sure do make it easy to review your work.
>>>>>>>>>>>>>
>>>>>>>>>>>>> "When the simulator detects the call to H in P it
>>>>>>>>>>>>> forks the simulation into a non-halting branch"
>>>>>>>>>>>>>
>>>>>>>>>>>>> There is an infinite set of cases where this overly
>>>>>>>>>>>>> simplistic criteria gets the wrong answer.
>>>>>>>>>>>>
>>>>>>>>>>>> That is neither an honest review or any kind of rebuttal:
>>>>>>>>>>>> I have told you before: assertions made without evidence
>>>>>>>>>>>> can be dismissed without evidence.
>>>>>>>>>>>>
>>>>>>>>>>>> If you claim there are an infinite number of cases where
>>>>>>>>>>>> it gets the wrong answer then it shouldn't be too hard
>>>>>>>>>>>> for to provide ONE case backing up your claim.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>> Sure:
>>>>>>>>>>>
>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>> {
>>>>>>>>>>> static int count = 3;
>>>>>>>>>>> count--;
>>>>>>>>>>> if (!count) goto exit;
>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>> exit:
>>>>>>>>>>> return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Nope; you seem to have forgotten that my decider is not
>>>>>>>>>> recursive in nature: my decider will correctly determine
>>>>>>>>>> that that input is pathological so will signal an exception.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The above terminates normally so your decider gets the wrong
>>>>>>>>> answer.
>>>>>>>>
>>>>>>>> It is a pathological input so neither halts nor doesn't halt:
>>>>>>>> pathological input is INVALID so the correct "answer" is to
>>>>>>>> signal an exception.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> So you don't know how static variables work?
>>>>>>> I am not surprised.
>>>>>>>
>>>>>>>
>>>>>>> void P(ptr x)
>>>>>>> {
>>>>>>> static int count = 0;
>>>>>>> if (count++ >= 2) goto exit;
>>>>>>> int Halt_Status = H(x, x);
>>>>>>> if (Halt_Status)
>>>>>>> HERE: goto HERE;
>>>>>>> exit:
>>>>>>> return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> Output("Input_Halts = ", H(P,P));
>>>>>>> }
>>>>>>>
>>>>>>> _Pm()
>>>>>>> [0000141e](01) 55 push ebp
>>>>>>> [0000141f](02) 8bec mov ebp,esp
>>>>>>> [00001421](03) 83ec08 sub esp,+08
>>>>>>> [00001424](05) a100000000 mov eax,[00000000]
>>>>>>> [00001429](03) 8945fc mov [ebp-04],eax
>>>>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
>>>>>>> [00001432](03) 83c101 add ecx,+01
>>>>>>> [00001435](06) 890d00000000 mov [00000000],ecx
>>>>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
>>>>>>> [0000143f](02) 7c02 jl 00001443
>>>>>>> [00001441](02) eb1b jmp 0000145e
>>>>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
>>>>>>> [00001446](01) 52 push edx
>>>>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
>>>>>>> [0000144a](01) 50 push eax
>>>>>>> [0000144b](05) e8defcffff call 0000112e
>>>>>>> [00001450](03) 83c408 add esp,+08
>>>>>>> [00001453](03) 8945f8 mov [ebp-08],eax
>>>>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
>>>>>>> [0000145a](02) 7402 jz 0000145e
>>>>>>> [0000145c](02) ebfe jmp 0000145c
>>>>>>> [0000145e](02) 8be5 mov esp,ebp
>>>>>>> [00001460](01) 5d pop ebp
>>>>>>> [00001461](01) c3 ret
>>>>>>> Size in bytes:(0068) [00001461]
>>>>>>>
>>>>>>> _main()
>>>>>>> [0000146e](01) 55 push ebp
>>>>>>> [0000146f](02) 8bec mov ebp,esp
>>>>>>> [00001471](05) 681e140000 push 0000141e
>>>>>>> [00001476](05) 681e140000 push 0000141e
>>>>>>> [0000147b](05) e8aefcffff call 0000112e
>>>>>>> [00001480](03) 83c408 add esp,+08
>>>>>>> [00001483](01) 50 push eax
>>>>>>> [00001484](05) 685f050000 push 0000055f
>>>>>>> [00001489](05) e820f1ffff call 000005ae
>>>>>>> [0000148e](03) 83c408 add esp,+08
>>>>>>> [00001491](02) 33c0 xor eax,eax
>>>>>>> [00001493](01) 5d pop ebp
>>>>>>> [00001494](01) c3 ret
>>>>>>> Size in bytes:(0039) [00001494]
>>>>>>>
>>>>>>> machine stack stack machine assembly
>>>>>>> address address data code language
>>>>>>> ======== ======== ======== ========= =============
>>>>>>> [0000146e][00102462][00000000] 55 push ebp
>>>>>>> [0000146f][00102462][00000000] 8bec mov ebp,esp
>>>>>>> [00001471][0010245e][0000141e] 681e140000 push 0000141e
>>>>>>> [00001476][0010245a][0000141e] 681e140000 push 0000141e
>>>>>>> [0000147b][00102456][00001480] e8aefcffff call 0000112e
>>>>>>>
>>>>>>> H: Begin Simulation Execution Trace Stored at:11250e
>>>>>>> Address_of_H:112e
>>>>>>> [0000141e][001124fa][001124fe] 55 push ebp
>>>>>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
>>>>>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
>>>>>>> [00001424][001124f2][90909090] a100000000 mov eax,[00000000]
>>>>>>> [00001429][001124f2][90909090] 8945fc mov [ebp-04],eax
>>>>>>> [0000142c][001124f2][90909090] 8b0d00000000 mov ecx,[00000000]
>>>>>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
>>>>>>> [00001435][001124f2][90909090] 890d00000000 mov [00000000],ecx
>>>>>>> [0000143b][001124f2][90909090] 837dfc02 cmp dword
>>>>>>> [ebp-04],+02 [0000143f][001124f2][90909090] 7c02 jl
>>>>>>> 00001443 [00001441][001124f2][90909090] eb1b jmp
>>>>>>> 0000145e [0000145e][001124fa][001124fe] 8be5 mov
>>>>>>> esp,ebp [00001460][001124fe][00001217] 5d pop ebp
>>>>>>> [00001461][00112502][0000141e] c3 ret
>>>>>>> H: End Simulation Input Terminated Normally
>>>>>>>
>>>>>>> [00001480][00102462][00000000] 83c408 add esp,+08
>>>>>>> [00001483][0010245e][00000001] 50 push eax
>>>>>>> [00001484][0010245a][0000055f] 685f050000 push 0000055f
>>>>>>> [00001489][0010245a][0000055f] e820f1ffff call 000005ae
>>>>>>> Input_Halts = 1
>>>>>>> [0000148e][00102462][00000000] 83c408 add esp,+08
>>>>>>> [00001491][00102462][00000000] 33c0 xor eax,eax
>>>>>>> [00001493][00102466][00000018] 5d pop ebp
>>>>>>> [00001494][0010246a][00000000] c3 ret
>>>>>>> Number of Instructions Executed(1317) == 20 Pages
>>>>>>
>>>>>> For this particular stack trace I notice that the function
>>>>>> symbol at the top of it is Pm not P which suggests to me one of
>>>>>> two things:
>>>>>
>>>>> I already had a P so I renamed it to Pm so it would not disturb
>>>>> my existing code. When I changed all the Pm references to your
>>>>> name I forgot one.
>>>>
>>>> Then I suggest you check the output of compilation/linking is
>>>> actually initializing static variables correctly. Are you even
>>>> using a linker or are you just executing an object file? Static
>>>> data normally goes into a separate data segment during the linking
>>>> process.
>>>>
>>>> /Flibble
>>>>
>>>
>>> I haven't used static data in such a long time that I forgot the
>>> compiler does not allocate any space for static variables unless
>>> they have been initialized to a non-zero value.
>>>
>>> void Pm(u32 x)
>>> {
>>> static int count = 0x777;
>>> if (count++ > 0x777) goto exit;
>>> int Halt_Status = H(x, x);
>>> if (Halt_Status)
>>> HERE: goto HERE;
>>> exit:
>>> return;
>>> }
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
>>> }
>>>
>>>
>>> _Pm()
>>> [00000a1a](01) 55 push ebp
>>> [00000a1b](02) 8bec mov ebp,esp
>>> [00000a1d](03) 83ec08 sub esp,+08
>>> [00000a20](05) a107030000 mov eax,[00000307]
>>> [00000a25](03) 8945fc mov [ebp-04],eax
>>> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
>>> [00000a2e](03) 83c101 add ecx,+01
>>> [00000a31](06) 890d07030000 mov [00000307],ecx
>>> [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
>>> [00000a3e](02) 7e02 jng 00000a42
>>> [00000a40](02) eb1b jmp 00000a5d
>>> [00000a42](03) 8b5508 mov edx,[ebp+08]
>>> [00000a45](01) 52 push edx
>>> [00000a46](03) 8b4508 mov eax,[ebp+08]
>>> [00000a49](01) 50 push eax
>>> [00000a4a](05) e8ebfdffff call 0000083a // call H
>>> [00000a4f](03) 83c408 add esp,+08
>>> [00000a52](03) 8945f8 mov [ebp-08],eax
>>> [00000a55](04) 837df800 cmp dword [ebp-08],+00
>>> [00000a59](02) 7402 jz 00000a5d
>>> [00000a5b](02) ebfe jmp 00000a5b
>>> [00000a5d](02) 8be5 mov esp,ebp
>>> [00000a5f](01) 5d pop ebp
>>> [00000a60](01) c3 ret
>>> Size in bytes:(0071) [00000a60]
>>>
>>> _main()
>>> [00000a6a](01) 55 push ebp
>>> [00000a6b](02) 8bec mov ebp,esp
>>> [00000a6d](05) 681a0a0000 push 00000a1a // push address of P
>>> [00000a72](05) 681a0a0000 push 00000a1a // push address of P
>>> [00000a77](05) e8befdffff call 0000083a // call H
>>> [00000a7c](03) 83c408 add esp,+08
>>> [00000a7f](01) 50 push eax
>>> [00000a80](05) 680b030000 push 0000030b
>>> [00000a85](05) e8d0f8ffff call 0000035a
>>> [00000a8a](03) 83c408 add esp,+08
>>> [00000a8d](02) 33c0 xor eax,eax
>>> [00000a8f](01) 5d pop ebp
>>> [00000a90](01) c3 ret
>>> Size in bytes:(0039) [00000a90]
>>>
>>> machine stack stack machine assembly
>>> address address data code language
>>> ======== ======== ======== ========= =============
>>> ...[00000a6a][0010137b][00000000] 55 push ebp
>>> ...[00000a6b][0010137b][00000000] 8bec mov ebp,esp
>>> ...[00000a6d][00101377][00000a1a] 681a0a0000 push 00000a1a
>>> ...[00000a72][00101373][00000a1a] 681a0a0000 push 00000a1a
>>> ...[00000a77][0010136f][00000a7c] e8befdffff call 0000083a
>>> New slave_stack at:201427
>>>
>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>> at:21142f ...[00000a1a][0021141b][0021141f] 55 push ebp
>>> ...[00000a1b][0021141b][0021141f] 8bec mov ebp,esp
>>> ...[00000a1d][00211413][90909090] 83ec08 sub esp,+08
>>> ...[00000a20][00211413][90909090] a107030000 mov eax,[00000307]
>>> ...[00000a25][00211413][90909090] 8945fc mov [ebp-04],eax
>>> ...[00000a28][00211413][90909090] 8b0d07030000 mov ecx,[00000307]
>>> ...[00000a2e][00211413][90909090] 83c101 add ecx,+01
>>> ...[00000a31][00211413][90909090] 890d07030000 mov [00000307],ecx
>>> ...[00000a37][00211413][90909090] 817dfc77070000 cmp dword
>>> [ebp-04],00000777
>>> ...[00000a3e][00211413][90909090] 7e02 jng 00000a42
>>> ...[00000a42][00211413][90909090] 8b5508 mov edx,[ebp+08]
>>> ...[00000a45][0021140f][00000a1a] 52 push edx //
>>> push address of P
>>> ...[00000a46][0021140f][00000a1a] 8b4508 mov eax,[ebp+08]
>>> ...[00000a49][0021140b][00000a1a] 50 push eax //
>>> push address of P
>>> ...[00000a4a][00211407][00000a4f] e8ebfdffff call 0000083a //
>>> call H New slave_stack at:24be4f
>>> ...[00000a1a][0025be43][0025be47] 55 push ebp
>>> ...[00000a1b][0025be43][0025be47] 8bec mov ebp,esp
>>> ...[00000a1d][0025be3b][90909090] 83ec08 sub esp,+08
>>> ...[00000a20][0025be3b][90909090] a107030000 mov eax,[00000307]
>>> ...[00000a25][0025be3b][90909090] 8945fc mov [ebp-04],eax
>>> ...[00000a28][0025be3b][90909090] 8b0d07030000 mov ecx,[00000307]
>>> ...[00000a2e][0025be3b][90909090] 83c101 add ecx,+01
>>> ...[00000a31][0025be3b][90909090] 890d07030000 mov [00000307],ecx
>>> ...[00000a37][0025be3b][90909090] 817dfc77070000 cmp dword
>>> [ebp-04],00000777
>>> ...[00000a3e][0025be3b][90909090] 7e02 jng 00000a42
>>> ...[00000a40][0025be3b][90909090] eb1b jmp 00000a5d //
>>> jmp to exit
>>> ...[00000a5d][0025be43][0025be47] 8be5 mov esp,ebp
>>> ...[00000a5f][0025be47][00000904] 5d pop ebp
>>> ...[00000a60][0025be4b][00000a1a] c3 ret
>>> ...[00000a7c][0010137b][00000000] 83c408 add esp,+08
>>> ...[00000a7f][00101377][00000001] 50 push eax
>>> ...[00000a80][00101373][0000030b] 680b030000 push 0000030b
>>> ---[00000a85][00101373][0000030b] e8d0f8ffff call 0000035a
>>> Input_Halts = 1
>>> ...[00000a8a][0010137b][00000000] 83c408 add esp,+08
>>> ...[00000a8d][0010137b][00000000] 33c0 xor eax,eax
>>> ...[00000a8f][0010137f][00100000] 5d pop ebp
>>> ...[00000a90][00101383][00000004] c3 ret
>>> Number of Instructions Executed(27278)
>>>
>>>
>>
>> Still seems wrong: post increment of the static variable should ensure
>> that it does NOT goto exit but instead should call H which should
>> presumably cause your "infinite recursion detected" bollocks to
>> manifest.
>
> OK, I've looked at your assembly trace and it is recursing into Pm from
> H and then halting but I am not sure what you are trying to prove?
> Again [Strachey 1965] and associated proofs are not recursive in nature.
>
> /Flibble
>
(1) H cannot correctly determine the halt status of the HP
counter-examples unless H is a simulating halt decider.
(2) The claim of the halting problem proofs is that no H in the universe
can possibly correctly determine the halt status of its corresponding
pathological input.
(3) H(P,P) does correctly determine that its correponding pathological
input would never halt.
(4) It is ridiculously stupid of you to say that [Strachey 1965] does
not specify infinitely recursive simulation when it is an easily
verified fact that when Strachey T <is> a simulating halt decider that
Strachey P <does> specify infinitely recursive simulation.
It does not say this directly in [Strachey 1965] only because no one
ever previously bothered to fully examine the effect of a simulating
halt decider on the HP's pathological inputs.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-07-15 18:46 +0100 |
| Message-ID | <20220715184619.00003607@reddwarf.jmc.corp> |
| In reply to | #85257 |
On Fri, 15 Jul 2022 12:39:31 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/15/2022 12:28 PM, Mr Flibble wrote:
> > On Fri, 15 Jul 2022 18:08:22 +0100
> > Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
> >
> >> On Fri, 15 Jul 2022 12:00:59 -0500
> >> olcott <NoOne@NoWhere.com> wrote:
> >>
> >>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
> >>>> On Fri, 15 Jul 2022 10:58:14 -0500
> >>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>
> >>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
> >>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
> >>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>
> >>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
> >>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
> >>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>
> >>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
> >>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
> >>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>
> >>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
> >>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
> >>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>
> >>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
> >>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
> >>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
> >>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> This is an explanation of a key new insight into
> >>>>>>>>>>>>>>>>>>> the halting problem provided in the language of
> >>>>>>>>>>>>>>>>>>> software engineering. Technical computer science
> >>>>>>>>>>>>>>>>>>> terms are explained using software engineering
> >>>>>>>>>>>>>>>>>>> terms. No knowledge of the halting problem is
> >>>>>>>>>>>>>>>>>>> required.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> It is based on fully operational software executed
> >>>>>>>>>>>>>>>>>>> in the x86utm operating system. The x86utm
> >>>>>>>>>>>>>>>>>>> operating system (based on an excellent open
> >>>>>>>>>>>>>>>>>>> source x86 emulator) was created to study the
> >>>>>>>>>>>>>>>>>>> details of the halting problem proof
> >>>>>>>>>>>>>>>>>>> counter-examples at the much higher level of
> >>>>>>>>>>>>>>>>>>> abstraction of C/x86.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt decider
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P) simulates its
> >>>>>>>>>>>>>>>>>>> input we can see that: (1) Function H() is called
> >>>>>>>>>>>>>>>>>>> from P(). (2) With the same arguments to H().
> >>>>>>>>>>>>>>>>>>> (3) With no instructions in P preceding its
> >>>>>>>>>>>>>>>>>>> invocation of H(P,P).
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> The above shows that the simulated P cannot
> >>>>>>>>>>>>>>>>>>> possibly terminate normally. Because H can see the
> >>>>>>>>>>>>>>>>>>> same (1)(2)(3) that we see H aborts its simulation
> >>>>>>>>>>>>>>>>>>> of P and rejects P as non-halting.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> In computability theory, the
> >>>>>>>>>>>>>>>>>>> halting problem is the problem of determining,
> >>>>>>>>>>>>>>>>>>> from a description of an arbitrary computer
> >>>>>>>>>>>>>>>>>>> program and an input, whether the program will
> >>>>>>>>>>>>>>>>>>> finish running, or continue to run forever. Alan
> >>>>>>>>>>>>>>>>>>> Turing proved in 1936 that a general algorithm to
> >>>>>>>>>>>>>>>>>>> solve the halting problem for all possible
> >>>>>>>>>>>>>>>>>>> program- input pairs cannot exist.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> For any program H that might
> >>>>>>>>>>>>>>>>>>> determine if programs halt, a "pathological"
> >>>>>>>>>>>>>>>>>>> program P, called with some input, can pass its
> >>>>>>>>>>>>>>>>>>> own source and its input to H and then
> >>>>>>>>>>>>>>>>>>> specifically do the opposite of what H predicts P
> >>>>>>>>>>>>>>>>>>> will do. No H can exist that handles this case.
> >>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
> >>>>>>>>>>>>>>>>>>> relationship to each other as described above.
> >>>>>>>>>>>>>>>>>>> Because H(P,P) does handle this case the above
> >>>>>>>>>>>>>>>>>>> halting problem undecidable input template has
> >>>>>>>>>>>>>>>>>>> been refuted.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> *When this halt deciding principle understood to
> >>>>>>>>>>>>>>>>>>> be correct* A halt decider must compute the
> >>>>>>>>>>>>>>>>>>> mapping from its inputs to an accept or reject
> >>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior that is
> >>>>>>>>>>>>>>>>>>> actually specified by these inputs.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this implements that
> >>>>>>>>>>>>>>>>>>> principle* Every simulating halt decider that
> >>>>>>>>>>>>>>>>>>> correctly simulates its input until it correctly
> >>>>>>>>>>>>>>>>>>> predicts that this simulated input would never
> >>>>>>>>>>>>>>>>>>> terminate normally, correctly rejects this input
> >>>>>>>>>>>>>>>>>>> as non-halting.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> *H is a Pure function*
> >>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
> >>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the basis of
> >>>>>>>>>>>>>>>>>>> software engineering*
> >>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion which I
> >>>>>>>>>>>>>>>>>> suppose is progress.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> I have shown that H/P does implement the HP's
> >>>>>>>>>>>>>>>>> "impossible input" template.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting problem
> >>>>>>>>>>>>>>>>> proofs that rely on this template.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Equating pathological input with non-halting is
> >>>>>>>>>>>>>>>> erroneous: you are only doing that because your
> >>>>>>>>>>>>>>>> broken solution treats it as "infinite recursion".
> >>>>>>>>>>>>>>>> There is no recursion in [Strachey 1965] and the HP
> >>>>>>>>>>>>>>>> proofs based on it.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> There is no recursion in any of the conventional
> >>>>>>>>>>>>>>> proofs only because no one ever previously bothered
> >>>>>>>>>>>>>>> to fully examine how a simulating halt decider would
> >>>>>>>>>>>>>>> address these otherwise "impossible" inputs.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I have shown that a simulating halt decider needn't be
> >>>>>>>>>>>>>> recursive in nature:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> You sure do make it easy to review your work.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> "When the simulator detects the call to H in P
> >>>>>>>>>>>>> it forks the simulation into a non-halting branch"
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> There is an infinite set of cases where this overly
> >>>>>>>>>>>>> simplistic criteria gets the wrong answer.
> >>>>>>>>>>>>
> >>>>>>>>>>>> That is neither an honest review or any kind of rebuttal:
> >>>>>>>>>>>> I have told you before: assertions made without evidence
> >>>>>>>>>>>> can be dismissed without evidence.
> >>>>>>>>>>>>
> >>>>>>>>>>>> If you claim there are an infinite number of cases where
> >>>>>>>>>>>> it gets the wrong answer then it shouldn't be too hard
> >>>>>>>>>>>> for to provide ONE case backing up your claim.
> >>>>>>>>>>>>
> >>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>
> >>>>>>>>>>> Sure:
> >>>>>>>>>>>
> >>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>> {
> >>>>>>>>>>> static int count = 3;
> >>>>>>>>>>> count--;
> >>>>>>>>>>> if (!count) goto exit;
> >>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>> exit:
> >>>>>>>>>>> return;
> >>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>> int main()
> >>>>>>>>>>> {
> >>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> Nope; you seem to have forgotten that my decider is not
> >>>>>>>>>> recursive in nature: my decider will correctly determine
> >>>>>>>>>> that that input is pathological so will signal an
> >>>>>>>>>> exception.
> >>>>>>>>>>
> >>>>>>>>>> /Flibble
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> The above terminates normally so your decider gets the wrong
> >>>>>>>>> answer.
> >>>>>>>>
> >>>>>>>> It is a pathological input so neither halts nor doesn't halt:
> >>>>>>>> pathological input is INVALID so the correct "answer" is to
> >>>>>>>> signal an exception.
> >>>>>>>>
> >>>>>>>> /Flibble
> >>>>>>>>
> >>>>>>>
> >>>>>>> So you don't know how static variables work?
> >>>>>>> I am not surprised.
> >>>>>>>
> >>>>>>>
> >>>>>>> void P(ptr x)
> >>>>>>> {
> >>>>>>> static int count = 0;
> >>>>>>> if (count++ >= 2) goto exit;
> >>>>>>> int Halt_Status = H(x, x);
> >>>>>>> if (Halt_Status)
> >>>>>>> HERE: goto HERE;
> >>>>>>> exit:
> >>>>>>> return;
> >>>>>>> }
> >>>>>>>
> >>>>>>> int main()
> >>>>>>> {
> >>>>>>> Output("Input_Halts = ", H(P,P));
> >>>>>>> }
> >>>>>>>
> >>>>>>> _Pm()
> >>>>>>> [0000141e](01) 55 push ebp
> >>>>>>> [0000141f](02) 8bec mov ebp,esp
> >>>>>>> [00001421](03) 83ec08 sub esp,+08
> >>>>>>> [00001424](05) a100000000 mov eax,[00000000]
> >>>>>>> [00001429](03) 8945fc mov [ebp-04],eax
> >>>>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
> >>>>>>> [00001432](03) 83c101 add ecx,+01
> >>>>>>> [00001435](06) 890d00000000 mov [00000000],ecx
> >>>>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
> >>>>>>> [0000143f](02) 7c02 jl 00001443
> >>>>>>> [00001441](02) eb1b jmp 0000145e
> >>>>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
> >>>>>>> [00001446](01) 52 push edx
> >>>>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
> >>>>>>> [0000144a](01) 50 push eax
> >>>>>>> [0000144b](05) e8defcffff call 0000112e
> >>>>>>> [00001450](03) 83c408 add esp,+08
> >>>>>>> [00001453](03) 8945f8 mov [ebp-08],eax
> >>>>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
> >>>>>>> [0000145a](02) 7402 jz 0000145e
> >>>>>>> [0000145c](02) ebfe jmp 0000145c
> >>>>>>> [0000145e](02) 8be5 mov esp,ebp
> >>>>>>> [00001460](01) 5d pop ebp
> >>>>>>> [00001461](01) c3 ret
> >>>>>>> Size in bytes:(0068) [00001461]
> >>>>>>>
> >>>>>>> _main()
> >>>>>>> [0000146e](01) 55 push ebp
> >>>>>>> [0000146f](02) 8bec mov ebp,esp
> >>>>>>> [00001471](05) 681e140000 push 0000141e
> >>>>>>> [00001476](05) 681e140000 push 0000141e
> >>>>>>> [0000147b](05) e8aefcffff call 0000112e
> >>>>>>> [00001480](03) 83c408 add esp,+08
> >>>>>>> [00001483](01) 50 push eax
> >>>>>>> [00001484](05) 685f050000 push 0000055f
> >>>>>>> [00001489](05) e820f1ffff call 000005ae
> >>>>>>> [0000148e](03) 83c408 add esp,+08
> >>>>>>> [00001491](02) 33c0 xor eax,eax
> >>>>>>> [00001493](01) 5d pop ebp
> >>>>>>> [00001494](01) c3 ret
> >>>>>>> Size in bytes:(0039) [00001494]
> >>>>>>>
> >>>>>>> machine stack stack machine assembly
> >>>>>>> address address data code language
> >>>>>>> ======== ======== ======== ========= =============
> >>>>>>> [0000146e][00102462][00000000] 55 push ebp
> >>>>>>> [0000146f][00102462][00000000] 8bec mov ebp,esp
> >>>>>>> [00001471][0010245e][0000141e] 681e140000 push 0000141e
> >>>>>>> [00001476][0010245a][0000141e] 681e140000 push 0000141e
> >>>>>>> [0000147b][00102456][00001480] e8aefcffff call 0000112e
> >>>>>>>
> >>>>>>> H: Begin Simulation Execution Trace Stored at:11250e
> >>>>>>> Address_of_H:112e
> >>>>>>> [0000141e][001124fa][001124fe] 55 push ebp
> >>>>>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
> >>>>>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
> >>>>>>> [00001424][001124f2][90909090] a100000000 mov eax,[00000000]
> >>>>>>> [00001429][001124f2][90909090] 8945fc mov [ebp-04],eax
> >>>>>>> [0000142c][001124f2][90909090] 8b0d00000000 mov ecx,[00000000]
> >>>>>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
> >>>>>>> [00001435][001124f2][90909090] 890d00000000 mov [00000000],ecx
> >>>>>>> [0000143b][001124f2][90909090] 837dfc02 cmp dword
> >>>>>>> [ebp-04],+02 [0000143f][001124f2][90909090] 7c02 jl
> >>>>>>> 00001443 [00001441][001124f2][90909090] eb1b jmp
> >>>>>>> 0000145e [0000145e][001124fa][001124fe] 8be5 mov
> >>>>>>> esp,ebp [00001460][001124fe][00001217] 5d pop ebp
> >>>>>>> [00001461][00112502][0000141e] c3 ret
> >>>>>>> H: End Simulation Input Terminated Normally
> >>>>>>>
> >>>>>>> [00001480][00102462][00000000] 83c408 add esp,+08
> >>>>>>> [00001483][0010245e][00000001] 50 push eax
> >>>>>>> [00001484][0010245a][0000055f] 685f050000 push 0000055f
> >>>>>>> [00001489][0010245a][0000055f] e820f1ffff call 000005ae
> >>>>>>> Input_Halts = 1
> >>>>>>> [0000148e][00102462][00000000] 83c408 add esp,+08
> >>>>>>> [00001491][00102462][00000000] 33c0 xor eax,eax
> >>>>>>> [00001493][00102466][00000018] 5d pop ebp
> >>>>>>> [00001494][0010246a][00000000] c3 ret
> >>>>>>> Number of Instructions Executed(1317) == 20 Pages
> >>>>>>
> >>>>>> For this particular stack trace I notice that the function
> >>>>>> symbol at the top of it is Pm not P which suggests to me one of
> >>>>>> two things:
> >>>>>
> >>>>> I already had a P so I renamed it to Pm so it would not disturb
> >>>>> my existing code. When I changed all the Pm references to your
> >>>>> name I forgot one.
> >>>>
> >>>> Then I suggest you check the output of compilation/linking is
> >>>> actually initializing static variables correctly. Are you even
> >>>> using a linker or are you just executing an object file? Static
> >>>> data normally goes into a separate data segment during the
> >>>> linking process.
> >>>>
> >>>> /Flibble
> >>>>
> >>>
> >>> I haven't used static data in such a long time that I forgot the
> >>> compiler does not allocate any space for static variables unless
> >>> they have been initialized to a non-zero value.
> >>>
> >>> void Pm(u32 x)
> >>> {
> >>> static int count = 0x777;
> >>> if (count++ > 0x777) goto exit;
> >>> int Halt_Status = H(x, x);
> >>> if (Halt_Status)
> >>> HERE: goto HERE;
> >>> exit:
> >>> return;
> >>> }
> >>>
> >>> int main()
> >>> {
> >>> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
> >>> }
> >>>
> >>>
> >>> _Pm()
> >>> [00000a1a](01) 55 push ebp
> >>> [00000a1b](02) 8bec mov ebp,esp
> >>> [00000a1d](03) 83ec08 sub esp,+08
> >>> [00000a20](05) a107030000 mov eax,[00000307]
> >>> [00000a25](03) 8945fc mov [ebp-04],eax
> >>> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
> >>> [00000a2e](03) 83c101 add ecx,+01
> >>> [00000a31](06) 890d07030000 mov [00000307],ecx
> >>> [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
> >>> [00000a3e](02) 7e02 jng 00000a42
> >>> [00000a40](02) eb1b jmp 00000a5d
> >>> [00000a42](03) 8b5508 mov edx,[ebp+08]
> >>> [00000a45](01) 52 push edx
> >>> [00000a46](03) 8b4508 mov eax,[ebp+08]
> >>> [00000a49](01) 50 push eax
> >>> [00000a4a](05) e8ebfdffff call 0000083a // call H
> >>> [00000a4f](03) 83c408 add esp,+08
> >>> [00000a52](03) 8945f8 mov [ebp-08],eax
> >>> [00000a55](04) 837df800 cmp dword [ebp-08],+00
> >>> [00000a59](02) 7402 jz 00000a5d
> >>> [00000a5b](02) ebfe jmp 00000a5b
> >>> [00000a5d](02) 8be5 mov esp,ebp
> >>> [00000a5f](01) 5d pop ebp
> >>> [00000a60](01) c3 ret
> >>> Size in bytes:(0071) [00000a60]
> >>>
> >>> _main()
> >>> [00000a6a](01) 55 push ebp
> >>> [00000a6b](02) 8bec mov ebp,esp
> >>> [00000a6d](05) 681a0a0000 push 00000a1a // push address of P
> >>> [00000a72](05) 681a0a0000 push 00000a1a // push address of P
> >>> [00000a77](05) e8befdffff call 0000083a // call H
> >>> [00000a7c](03) 83c408 add esp,+08
> >>> [00000a7f](01) 50 push eax
> >>> [00000a80](05) 680b030000 push 0000030b
> >>> [00000a85](05) e8d0f8ffff call 0000035a
> >>> [00000a8a](03) 83c408 add esp,+08
> >>> [00000a8d](02) 33c0 xor eax,eax
> >>> [00000a8f](01) 5d pop ebp
> >>> [00000a90](01) c3 ret
> >>> Size in bytes:(0039) [00000a90]
> >>>
> >>> machine stack stack machine assembly
> >>> address address data code language
> >>> ======== ======== ======== ========= =============
> >>> ...[00000a6a][0010137b][00000000] 55 push ebp
> >>> ...[00000a6b][0010137b][00000000] 8bec mov ebp,esp
> >>> ...[00000a6d][00101377][00000a1a] 681a0a0000 push 00000a1a
> >>> ...[00000a72][00101373][00000a1a] 681a0a0000 push 00000a1a
> >>> ...[00000a77][0010136f][00000a7c] e8befdffff call 0000083a
> >>> New slave_stack at:201427
> >>>
> >>> Begin Local Halt Decider Simulation Execution Trace Stored
> >>> at:21142f ...[00000a1a][0021141b][0021141f] 55 push
> >>> ebp ...[00000a1b][0021141b][0021141f] 8bec mov ebp,esp
> >>> ...[00000a1d][00211413][90909090] 83ec08 sub esp,+08
> >>> ...[00000a20][00211413][90909090] a107030000 mov
> >>> eax,[00000307] ...[00000a25][00211413][90909090] 8945fc
> >>> mov [ebp-04],eax ...[00000a28][00211413][90909090] 8b0d07030000
> >>> mov ecx,[00000307] ...[00000a2e][00211413][90909090] 83c101
> >>> add ecx,+01 ...[00000a31][00211413][90909090] 890d07030000
> >>> mov [00000307],ecx ...[00000a37][00211413][90909090]
> >>> 817dfc77070000 cmp dword [ebp-04],00000777
> >>> ...[00000a3e][00211413][90909090] 7e02 jng 00000a42
> >>> ...[00000a42][00211413][90909090] 8b5508 mov edx,[ebp+08]
> >>> ...[00000a45][0021140f][00000a1a] 52 push edx //
> >>> push address of P
> >>> ...[00000a46][0021140f][00000a1a] 8b4508 mov eax,[ebp+08]
> >>> ...[00000a49][0021140b][00000a1a] 50 push eax //
> >>> push address of P
> >>> ...[00000a4a][00211407][00000a4f] e8ebfdffff call 0000083a //
> >>> call H New slave_stack at:24be4f
> >>> ...[00000a1a][0025be43][0025be47] 55 push ebp
> >>> ...[00000a1b][0025be43][0025be47] 8bec mov ebp,esp
> >>> ...[00000a1d][0025be3b][90909090] 83ec08 sub esp,+08
> >>> ...[00000a20][0025be3b][90909090] a107030000 mov
> >>> eax,[00000307] ...[00000a25][0025be3b][90909090] 8945fc
> >>> mov [ebp-04],eax ...[00000a28][0025be3b][90909090] 8b0d07030000
> >>> mov ecx,[00000307] ...[00000a2e][0025be3b][90909090] 83c101
> >>> add ecx,+01 ...[00000a31][0025be3b][90909090] 890d07030000
> >>> mov [00000307],ecx ...[00000a37][0025be3b][90909090]
> >>> 817dfc77070000 cmp dword [ebp-04],00000777
> >>> ...[00000a3e][0025be3b][90909090] 7e02 jng 00000a42
> >>> ...[00000a40][0025be3b][90909090] eb1b jmp 00000a5d //
> >>> jmp to exit
> >>> ...[00000a5d][0025be43][0025be47] 8be5 mov esp,ebp
> >>> ...[00000a5f][0025be47][00000904] 5d pop ebp
> >>> ...[00000a60][0025be4b][00000a1a] c3 ret
> >>> ...[00000a7c][0010137b][00000000] 83c408 add esp,+08
> >>> ...[00000a7f][00101377][00000001] 50 push eax
> >>> ...[00000a80][00101373][0000030b] 680b030000 push 0000030b
> >>> ---[00000a85][00101373][0000030b] e8d0f8ffff call 0000035a
> >>> Input_Halts = 1
> >>> ...[00000a8a][0010137b][00000000] 83c408 add esp,+08
> >>> ...[00000a8d][0010137b][00000000] 33c0 xor eax,eax
> >>> ...[00000a8f][0010137f][00100000] 5d pop ebp
> >>> ...[00000a90][00101383][00000004] c3 ret
> >>> Number of Instructions Executed(27278)
> >>>
> >>>
> >>
> >> Still seems wrong: post increment of the static variable should
> >> ensure that it does NOT goto exit but instead should call H which
> >> should presumably cause your "infinite recursion detected"
> >> bollocks to manifest.
> >
> > OK, I've looked at your assembly trace and it is recursing into Pm
> > from H and then halting but I am not sure what you are trying to
> > prove? Again [Strachey 1965] and associated proofs are not
> > recursive in nature.
> >
> > /Flibble
> >
>
> (1) H cannot correctly determine the halt status of the HP
> counter-examples unless H is a simulating halt decider.
>
> (2) The claim of the halting problem proofs is that no H in the
> universe can possibly correctly determine the halt status of its
> corresponding pathological input.
>
> (3) H(P,P) does correctly determine that its correponding
> pathological input would never halt.
>
> (4) It is ridiculously stupid of you to say that [Strachey 1965] does
> not specify infinitely recursive simulation when it is an easily
> verified fact that when Strachey T <is> a simulating halt decider
> that Strachey P <does> specify infinitely recursive simulation.
>
> It does not say this directly in [Strachey 1965] only because no one
> ever previously bothered to fully examine the effect of a simulating
> halt decider on the HP's pathological inputs.
I see I have to repeat myself yet again: a simulating halt decider
needn't be recursive in nature and I have sketched a design of such a
halt decider:
https://github.com/i42output/halting-problem/blob/main/README.txt
You are incorrect to claim an equivalence between pathological input
and non-halting.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2022-07-15 12:57 -0500 |
| Message-ID | <KbSdncHSDus_N0z_nZ2dnUU7_83NnZ2d@giganews.com> |
| In reply to | #85258 |
On 7/15/2022 12:46 PM, Mr Flibble wrote:
> On Fri, 15 Jul 2022 12:39:31 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/15/2022 12:28 PM, Mr Flibble wrote:
>>> On Fri, 15 Jul 2022 18:08:22 +0100
>>> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
>>>
>>>> On Fri, 15 Jul 2022 12:00:59 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
>>>>>> On Fri, 15 Jul 2022 10:58:14 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>
>>>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
>>>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>
>>>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>
>>>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
>>>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
>>>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This is an explanation of a key new insight into
>>>>>>>>>>>>>>>>>>>>> the halting problem provided in the language of
>>>>>>>>>>>>>>>>>>>>> software engineering. Technical computer science
>>>>>>>>>>>>>>>>>>>>> terms are explained using software engineering
>>>>>>>>>>>>>>>>>>>>> terms. No knowledge of the halting problem is
>>>>>>>>>>>>>>>>>>>>> required.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It is based on fully operational software executed
>>>>>>>>>>>>>>>>>>>>> in the x86utm operating system. The x86utm
>>>>>>>>>>>>>>>>>>>>> operating system (based on an excellent open
>>>>>>>>>>>>>>>>>>>>> source x86 emulator) was created to study the
>>>>>>>>>>>>>>>>>>>>> details of the halting problem proof
>>>>>>>>>>>>>>>>>>>>> counter-examples at the much higher level of
>>>>>>>>>>>>>>>>>>>>> abstraction of C/x86.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt decider
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P) simulates its
>>>>>>>>>>>>>>>>>>>>> input we can see that: (1) Function H() is called
>>>>>>>>>>>>>>>>>>>>> from P(). (2) With the same arguments to H().
>>>>>>>>>>>>>>>>>>>>> (3) With no instructions in P preceding its
>>>>>>>>>>>>>>>>>>>>> invocation of H(P,P).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The above shows that the simulated P cannot
>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. Because H can see the
>>>>>>>>>>>>>>>>>>>>> same (1)(2)(3) that we see H aborts its simulation
>>>>>>>>>>>>>>>>>>>>> of P and rejects P as non-halting.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> In computability theory, the
>>>>>>>>>>>>>>>>>>>>> halting problem is the problem of determining,
>>>>>>>>>>>>>>>>>>>>> from a description of an arbitrary computer
>>>>>>>>>>>>>>>>>>>>> program and an input, whether the program will
>>>>>>>>>>>>>>>>>>>>> finish running, or continue to run forever. Alan
>>>>>>>>>>>>>>>>>>>>> Turing proved in 1936 that a general algorithm to
>>>>>>>>>>>>>>>>>>>>> solve the halting problem for all possible
>>>>>>>>>>>>>>>>>>>>> program- input pairs cannot exist.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> For any program H that might
>>>>>>>>>>>>>>>>>>>>> determine if programs halt, a "pathological"
>>>>>>>>>>>>>>>>>>>>> program P, called with some input, can pass its
>>>>>>>>>>>>>>>>>>>>> own source and its input to H and then
>>>>>>>>>>>>>>>>>>>>> specifically do the opposite of what H predicts P
>>>>>>>>>>>>>>>>>>>>> will do. No H can exist that handles this case.
>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
>>>>>>>>>>>>>>>>>>>>> relationship to each other as described above.
>>>>>>>>>>>>>>>>>>>>> Because H(P,P) does handle this case the above
>>>>>>>>>>>>>>>>>>>>> halting problem undecidable input template has
>>>>>>>>>>>>>>>>>>>>> been refuted.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *When this halt deciding principle understood to
>>>>>>>>>>>>>>>>>>>>> be correct* A halt decider must compute the
>>>>>>>>>>>>>>>>>>>>> mapping from its inputs to an accept or reject
>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior that is
>>>>>>>>>>>>>>>>>>>>> actually specified by these inputs.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this implements that
>>>>>>>>>>>>>>>>>>>>> principle* Every simulating halt decider that
>>>>>>>>>>>>>>>>>>>>> correctly simulates its input until it correctly
>>>>>>>>>>>>>>>>>>>>> predicts that this simulated input would never
>>>>>>>>>>>>>>>>>>>>> terminate normally, correctly rejects this input
>>>>>>>>>>>>>>>>>>>>> as non-halting.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *H is a Pure function*
>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the basis of
>>>>>>>>>>>>>>>>>>>>> software engineering*
>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion which I
>>>>>>>>>>>>>>>>>>>> suppose is progress.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I have shown that H/P does implement the HP's
>>>>>>>>>>>>>>>>>>> "impossible input" template.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting problem
>>>>>>>>>>>>>>>>>>> proofs that rely on this template.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Equating pathological input with non-halting is
>>>>>>>>>>>>>>>>>> erroneous: you are only doing that because your
>>>>>>>>>>>>>>>>>> broken solution treats it as "infinite recursion".
>>>>>>>>>>>>>>>>>> There is no recursion in [Strachey 1965] and the HP
>>>>>>>>>>>>>>>>>> proofs based on it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> There is no recursion in any of the conventional
>>>>>>>>>>>>>>>>> proofs only because no one ever previously bothered
>>>>>>>>>>>>>>>>> to fully examine how a simulating halt decider would
>>>>>>>>>>>>>>>>> address these otherwise "impossible" inputs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I have shown that a simulating halt decider needn't be
>>>>>>>>>>>>>>>> recursive in nature:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You sure do make it easy to review your work.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> "When the simulator detects the call to H in P
>>>>>>>>>>>>>>> it forks the simulation into a non-halting branch"
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> There is an infinite set of cases where this overly
>>>>>>>>>>>>>>> simplistic criteria gets the wrong answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is neither an honest review or any kind of rebuttal:
>>>>>>>>>>>>>> I have told you before: assertions made without evidence
>>>>>>>>>>>>>> can be dismissed without evidence.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If you claim there are an infinite number of cases where
>>>>>>>>>>>>>> it gets the wrong answer then it shouldn't be too hard
>>>>>>>>>>>>>> for to provide ONE case backing up your claim.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>> Sure:
>>>>>>>>>>>>>
>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>> {
>>>>>>>>>>>>> static int count = 3;
>>>>>>>>>>>>> count--;
>>>>>>>>>>>>> if (!count) goto exit;
>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>> exit:
>>>>>>>>>>>>> return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> Nope; you seem to have forgotten that my decider is not
>>>>>>>>>>>> recursive in nature: my decider will correctly determine
>>>>>>>>>>>> that that input is pathological so will signal an
>>>>>>>>>>>> exception.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The above terminates normally so your decider gets the wrong
>>>>>>>>>>> answer.
>>>>>>>>>>
>>>>>>>>>> It is a pathological input so neither halts nor doesn't halt:
>>>>>>>>>> pathological input is INVALID so the correct "answer" is to
>>>>>>>>>> signal an exception.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So you don't know how static variables work?
>>>>>>>>> I am not surprised.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> void P(ptr x)
>>>>>>>>> {
>>>>>>>>> static int count = 0;
>>>>>>>>> if (count++ >= 2) goto exit;
>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>> if (Halt_Status)
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> exit:
>>>>>>>>> return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> Output("Input_Halts = ", H(P,P));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> _Pm()
>>>>>>>>> [0000141e](01) 55 push ebp
>>>>>>>>> [0000141f](02) 8bec mov ebp,esp
>>>>>>>>> [00001421](03) 83ec08 sub esp,+08
>>>>>>>>> [00001424](05) a100000000 mov eax,[00000000]
>>>>>>>>> [00001429](03) 8945fc mov [ebp-04],eax
>>>>>>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
>>>>>>>>> [00001432](03) 83c101 add ecx,+01
>>>>>>>>> [00001435](06) 890d00000000 mov [00000000],ecx
>>>>>>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
>>>>>>>>> [0000143f](02) 7c02 jl 00001443
>>>>>>>>> [00001441](02) eb1b jmp 0000145e
>>>>>>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
>>>>>>>>> [00001446](01) 52 push edx
>>>>>>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>> [0000144a](01) 50 push eax
>>>>>>>>> [0000144b](05) e8defcffff call 0000112e
>>>>>>>>> [00001450](03) 83c408 add esp,+08
>>>>>>>>> [00001453](03) 8945f8 mov [ebp-08],eax
>>>>>>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
>>>>>>>>> [0000145a](02) 7402 jz 0000145e
>>>>>>>>> [0000145c](02) ebfe jmp 0000145c
>>>>>>>>> [0000145e](02) 8be5 mov esp,ebp
>>>>>>>>> [00001460](01) 5d pop ebp
>>>>>>>>> [00001461](01) c3 ret
>>>>>>>>> Size in bytes:(0068) [00001461]
>>>>>>>>>
>>>>>>>>> _main()
>>>>>>>>> [0000146e](01) 55 push ebp
>>>>>>>>> [0000146f](02) 8bec mov ebp,esp
>>>>>>>>> [00001471](05) 681e140000 push 0000141e
>>>>>>>>> [00001476](05) 681e140000 push 0000141e
>>>>>>>>> [0000147b](05) e8aefcffff call 0000112e
>>>>>>>>> [00001480](03) 83c408 add esp,+08
>>>>>>>>> [00001483](01) 50 push eax
>>>>>>>>> [00001484](05) 685f050000 push 0000055f
>>>>>>>>> [00001489](05) e820f1ffff call 000005ae
>>>>>>>>> [0000148e](03) 83c408 add esp,+08
>>>>>>>>> [00001491](02) 33c0 xor eax,eax
>>>>>>>>> [00001493](01) 5d pop ebp
>>>>>>>>> [00001494](01) c3 ret
>>>>>>>>> Size in bytes:(0039) [00001494]
>>>>>>>>>
>>>>>>>>> machine stack stack machine assembly
>>>>>>>>> address address data code language
>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>> [0000146e][00102462][00000000] 55 push ebp
>>>>>>>>> [0000146f][00102462][00000000] 8bec mov ebp,esp
>>>>>>>>> [00001471][0010245e][0000141e] 681e140000 push 0000141e
>>>>>>>>> [00001476][0010245a][0000141e] 681e140000 push 0000141e
>>>>>>>>> [0000147b][00102456][00001480] e8aefcffff call 0000112e
>>>>>>>>>
>>>>>>>>> H: Begin Simulation Execution Trace Stored at:11250e
>>>>>>>>> Address_of_H:112e
>>>>>>>>> [0000141e][001124fa][001124fe] 55 push ebp
>>>>>>>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
>>>>>>>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
>>>>>>>>> [00001424][001124f2][90909090] a100000000 mov eax,[00000000]
>>>>>>>>> [00001429][001124f2][90909090] 8945fc mov [ebp-04],eax
>>>>>>>>> [0000142c][001124f2][90909090] 8b0d00000000 mov ecx,[00000000]
>>>>>>>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
>>>>>>>>> [00001435][001124f2][90909090] 890d00000000 mov [00000000],ecx
>>>>>>>>> [0000143b][001124f2][90909090] 837dfc02 cmp dword
>>>>>>>>> [ebp-04],+02 [0000143f][001124f2][90909090] 7c02 jl
>>>>>>>>> 00001443 [00001441][001124f2][90909090] eb1b jmp
>>>>>>>>> 0000145e [0000145e][001124fa][001124fe] 8be5 mov
>>>>>>>>> esp,ebp [00001460][001124fe][00001217] 5d pop ebp
>>>>>>>>> [00001461][00112502][0000141e] c3 ret
>>>>>>>>> H: End Simulation Input Terminated Normally
>>>>>>>>>
>>>>>>>>> [00001480][00102462][00000000] 83c408 add esp,+08
>>>>>>>>> [00001483][0010245e][00000001] 50 push eax
>>>>>>>>> [00001484][0010245a][0000055f] 685f050000 push 0000055f
>>>>>>>>> [00001489][0010245a][0000055f] e820f1ffff call 000005ae
>>>>>>>>> Input_Halts = 1
>>>>>>>>> [0000148e][00102462][00000000] 83c408 add esp,+08
>>>>>>>>> [00001491][00102462][00000000] 33c0 xor eax,eax
>>>>>>>>> [00001493][00102466][00000018] 5d pop ebp
>>>>>>>>> [00001494][0010246a][00000000] c3 ret
>>>>>>>>> Number of Instructions Executed(1317) == 20 Pages
>>>>>>>>
>>>>>>>> For this particular stack trace I notice that the function
>>>>>>>> symbol at the top of it is Pm not P which suggests to me one of
>>>>>>>> two things:
>>>>>>>
>>>>>>> I already had a P so I renamed it to Pm so it would not disturb
>>>>>>> my existing code. When I changed all the Pm references to your
>>>>>>> name I forgot one.
>>>>>>
>>>>>> Then I suggest you check the output of compilation/linking is
>>>>>> actually initializing static variables correctly. Are you even
>>>>>> using a linker or are you just executing an object file? Static
>>>>>> data normally goes into a separate data segment during the
>>>>>> linking process.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> I haven't used static data in such a long time that I forgot the
>>>>> compiler does not allocate any space for static variables unless
>>>>> they have been initialized to a non-zero value.
>>>>>
>>>>> void Pm(u32 x)
>>>>> {
>>>>> static int count = 0x777;
>>>>> if (count++ > 0x777) goto exit;
>>>>> int Halt_Status = H(x, x);
>>>>> if (Halt_Status)
>>>>> HERE: goto HERE;
>>>>> exit:
>>>>> return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
>>>>> }
>>>>>
>>>>>
>>>>> _Pm()
>>>>> [00000a1a](01) 55 push ebp
>>>>> [00000a1b](02) 8bec mov ebp,esp
>>>>> [00000a1d](03) 83ec08 sub esp,+08
>>>>> [00000a20](05) a107030000 mov eax,[00000307]
>>>>> [00000a25](03) 8945fc mov [ebp-04],eax
>>>>> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
>>>>> [00000a2e](03) 83c101 add ecx,+01
>>>>> [00000a31](06) 890d07030000 mov [00000307],ecx
>>>>> [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
>>>>> [00000a3e](02) 7e02 jng 00000a42
>>>>> [00000a40](02) eb1b jmp 00000a5d
>>>>> [00000a42](03) 8b5508 mov edx,[ebp+08]
>>>>> [00000a45](01) 52 push edx
>>>>> [00000a46](03) 8b4508 mov eax,[ebp+08]
>>>>> [00000a49](01) 50 push eax
>>>>> [00000a4a](05) e8ebfdffff call 0000083a // call H
>>>>> [00000a4f](03) 83c408 add esp,+08
>>>>> [00000a52](03) 8945f8 mov [ebp-08],eax
>>>>> [00000a55](04) 837df800 cmp dword [ebp-08],+00
>>>>> [00000a59](02) 7402 jz 00000a5d
>>>>> [00000a5b](02) ebfe jmp 00000a5b
>>>>> [00000a5d](02) 8be5 mov esp,ebp
>>>>> [00000a5f](01) 5d pop ebp
>>>>> [00000a60](01) c3 ret
>>>>> Size in bytes:(0071) [00000a60]
>>>>>
>>>>> _main()
>>>>> [00000a6a](01) 55 push ebp
>>>>> [00000a6b](02) 8bec mov ebp,esp
>>>>> [00000a6d](05) 681a0a0000 push 00000a1a // push address of P
>>>>> [00000a72](05) 681a0a0000 push 00000a1a // push address of P
>>>>> [00000a77](05) e8befdffff call 0000083a // call H
>>>>> [00000a7c](03) 83c408 add esp,+08
>>>>> [00000a7f](01) 50 push eax
>>>>> [00000a80](05) 680b030000 push 0000030b
>>>>> [00000a85](05) e8d0f8ffff call 0000035a
>>>>> [00000a8a](03) 83c408 add esp,+08
>>>>> [00000a8d](02) 33c0 xor eax,eax
>>>>> [00000a8f](01) 5d pop ebp
>>>>> [00000a90](01) c3 ret
>>>>> Size in bytes:(0039) [00000a90]
>>>>>
>>>>> machine stack stack machine assembly
>>>>> address address data code language
>>>>> ======== ======== ======== ========= =============
>>>>> ...[00000a6a][0010137b][00000000] 55 push ebp
>>>>> ...[00000a6b][0010137b][00000000] 8bec mov ebp,esp
>>>>> ...[00000a6d][00101377][00000a1a] 681a0a0000 push 00000a1a
>>>>> ...[00000a72][00101373][00000a1a] 681a0a0000 push 00000a1a
>>>>> ...[00000a77][0010136f][00000a7c] e8befdffff call 0000083a
>>>>> New slave_stack at:201427
>>>>>
>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>>>> at:21142f ...[00000a1a][0021141b][0021141f] 55 push
>>>>> ebp ...[00000a1b][0021141b][0021141f] 8bec mov ebp,esp
>>>>> ...[00000a1d][00211413][90909090] 83ec08 sub esp,+08
>>>>> ...[00000a20][00211413][90909090] a107030000 mov
>>>>> eax,[00000307] ...[00000a25][00211413][90909090] 8945fc
>>>>> mov [ebp-04],eax ...[00000a28][00211413][90909090] 8b0d07030000
>>>>> mov ecx,[00000307] ...[00000a2e][00211413][90909090] 83c101
>>>>> add ecx,+01 ...[00000a31][00211413][90909090] 890d07030000
>>>>> mov [00000307],ecx ...[00000a37][00211413][90909090]
>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
>>>>> ...[00000a3e][00211413][90909090] 7e02 jng 00000a42
>>>>> ...[00000a42][00211413][90909090] 8b5508 mov edx,[ebp+08]
>>>>> ...[00000a45][0021140f][00000a1a] 52 push edx //
>>>>> push address of P
>>>>> ...[00000a46][0021140f][00000a1a] 8b4508 mov eax,[ebp+08]
>>>>> ...[00000a49][0021140b][00000a1a] 50 push eax //
>>>>> push address of P
>>>>> ...[00000a4a][00211407][00000a4f] e8ebfdffff call 0000083a //
>>>>> call H New slave_stack at:24be4f
>>>>> ...[00000a1a][0025be43][0025be47] 55 push ebp
>>>>> ...[00000a1b][0025be43][0025be47] 8bec mov ebp,esp
>>>>> ...[00000a1d][0025be3b][90909090] 83ec08 sub esp,+08
>>>>> ...[00000a20][0025be3b][90909090] a107030000 mov
>>>>> eax,[00000307] ...[00000a25][0025be3b][90909090] 8945fc
>>>>> mov [ebp-04],eax ...[00000a28][0025be3b][90909090] 8b0d07030000
>>>>> mov ecx,[00000307] ...[00000a2e][0025be3b][90909090] 83c101
>>>>> add ecx,+01 ...[00000a31][0025be3b][90909090] 890d07030000
>>>>> mov [00000307],ecx ...[00000a37][0025be3b][90909090]
>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
>>>>> ...[00000a3e][0025be3b][90909090] 7e02 jng 00000a42
>>>>> ...[00000a40][0025be3b][90909090] eb1b jmp 00000a5d //
>>>>> jmp to exit
>>>>> ...[00000a5d][0025be43][0025be47] 8be5 mov esp,ebp
>>>>> ...[00000a5f][0025be47][00000904] 5d pop ebp
>>>>> ...[00000a60][0025be4b][00000a1a] c3 ret
>>>>> ...[00000a7c][0010137b][00000000] 83c408 add esp,+08
>>>>> ...[00000a7f][00101377][00000001] 50 push eax
>>>>> ...[00000a80][00101373][0000030b] 680b030000 push 0000030b
>>>>> ---[00000a85][00101373][0000030b] e8d0f8ffff call 0000035a
>>>>> Input_Halts = 1
>>>>> ...[00000a8a][0010137b][00000000] 83c408 add esp,+08
>>>>> ...[00000a8d][0010137b][00000000] 33c0 xor eax,eax
>>>>> ...[00000a8f][0010137f][00100000] 5d pop ebp
>>>>> ...[00000a90][00101383][00000004] c3 ret
>>>>> Number of Instructions Executed(27278)
>>>>>
>>>>>
>>>>
>>>> Still seems wrong: post increment of the static variable should
>>>> ensure that it does NOT goto exit but instead should call H which
>>>> should presumably cause your "infinite recursion detected"
>>>> bollocks to manifest.
>>>
>>> OK, I've looked at your assembly trace and it is recursing into Pm
>>> from H and then halting but I am not sure what you are trying to
>>> prove? Again [Strachey 1965] and associated proofs are not
>>> recursive in nature.
>>>
>>> /Flibble
>>>
>>
>> (1) H cannot correctly determine the halt status of the HP
>> counter-examples unless H is a simulating halt decider.
>>
>> (2) The claim of the halting problem proofs is that no H in the
>> universe can possibly correctly determine the halt status of its
>> corresponding pathological input.
>>
>> (3) H(P,P) does correctly determine that its correponding
>> pathological input would never halt.
>>
>> (4) It is ridiculously stupid of you to say that [Strachey 1965] does
>> not specify infinitely recursive simulation when it is an easily
>> verified fact that when Strachey T <is> a simulating halt decider
>> that Strachey P <does> specify infinitely recursive simulation.
>>
>> It does not say this directly in [Strachey 1965] only because no one
>> ever previously bothered to fully examine the effect of a simulating
>> halt decider on the HP's pathological inputs.
>
> I see I have to repeat myself yet again: a simulating halt decider
> needn't be recursive in nature and I have sketched a design of such a
> halt decider:
>
> https://github.com/i42output/halting-problem/blob/main/README.txt
>
> You are incorrect to claim an equivalence between pathological input
> and non-halting.
>
> /Flibble
>
>
19 When the simulator detects the call to H in P it forks the simulation
20 into a non-halting branch (returning 0 to P) and a halting branch
21 (returning 1 to P)
Software engineers at the low end of technical competence may not fully
comprehend the common knowledge that:
Whenever a function is called in what is essentially infinite recursion
this function cannot possibly correctly return any value to its caller.
You don't seem to understand that.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-07-15 19:04 +0100 |
| Message-ID | <20220715190440.00001376@reddwarf.jmc.corp> |
| In reply to | #85259 |
On Fri, 15 Jul 2022 12:57:53 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/15/2022 12:46 PM, Mr Flibble wrote:
> > On Fri, 15 Jul 2022 12:39:31 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 7/15/2022 12:28 PM, Mr Flibble wrote:
> >>> On Fri, 15 Jul 2022 18:08:22 +0100
> >>> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
> >>>
> >>>> On Fri, 15 Jul 2022 12:00:59 -0500
> >>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>
> >>>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
> >>>>>> On Fri, 15 Jul 2022 10:58:14 -0500
> >>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>
> >>>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
> >>>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
> >>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>
> >>>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
> >>>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
> >>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>
> >>>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
> >>>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
> >>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>
> >>>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
> >>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
> >>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
> >>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
> >>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> This is an explanation of a key new insight into
> >>>>>>>>>>>>>>>>>>>>> the halting problem provided in the language of
> >>>>>>>>>>>>>>>>>>>>> software engineering. Technical computer science
> >>>>>>>>>>>>>>>>>>>>> terms are explained using software engineering
> >>>>>>>>>>>>>>>>>>>>> terms. No knowledge of the halting problem is
> >>>>>>>>>>>>>>>>>>>>> required.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> It is based on fully operational software
> >>>>>>>>>>>>>>>>>>>>> executed in the x86utm operating system. The
> >>>>>>>>>>>>>>>>>>>>> x86utm operating system (based on an excellent
> >>>>>>>>>>>>>>>>>>>>> open source x86 emulator) was created to study
> >>>>>>>>>>>>>>>>>>>>> the details of the halting problem proof
> >>>>>>>>>>>>>>>>>>>>> counter-examples at the much higher level of
> >>>>>>>>>>>>>>>>>>>>> abstraction of C/x86.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt decider
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P) simulates
> >>>>>>>>>>>>>>>>>>>>> its input we can see that: (1) Function H() is
> >>>>>>>>>>>>>>>>>>>>> called from P(). (2) With the same arguments to
> >>>>>>>>>>>>>>>>>>>>> H(). (3) With no instructions in P preceding its
> >>>>>>>>>>>>>>>>>>>>> invocation of H(P,P).
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> The above shows that the simulated P cannot
> >>>>>>>>>>>>>>>>>>>>> possibly terminate normally. Because H can see
> >>>>>>>>>>>>>>>>>>>>> the same (1)(2)(3) that we see H aborts its
> >>>>>>>>>>>>>>>>>>>>> simulation of P and rejects P as non-halting.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> In computability theory, the
> >>>>>>>>>>>>>>>>>>>>> halting problem is the problem of determining,
> >>>>>>>>>>>>>>>>>>>>> from a description of an arbitrary computer
> >>>>>>>>>>>>>>>>>>>>> program and an input, whether the program will
> >>>>>>>>>>>>>>>>>>>>> finish running, or continue to run forever. Alan
> >>>>>>>>>>>>>>>>>>>>> Turing proved in 1936 that a general algorithm
> >>>>>>>>>>>>>>>>>>>>> to solve the halting problem for all possible
> >>>>>>>>>>>>>>>>>>>>> program- input pairs cannot exist.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> For any program H that might
> >>>>>>>>>>>>>>>>>>>>> determine if programs halt, a "pathological"
> >>>>>>>>>>>>>>>>>>>>> program P, called with some input, can pass its
> >>>>>>>>>>>>>>>>>>>>> own source and its input to H and then
> >>>>>>>>>>>>>>>>>>>>> specifically do the opposite of what H predicts
> >>>>>>>>>>>>>>>>>>>>> P will do. No H can exist that handles this
> >>>>>>>>>>>>>>>>>>>>> case.
> >>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
> >>>>>>>>>>>>>>>>>>>>> relationship to each other as described above.
> >>>>>>>>>>>>>>>>>>>>> Because H(P,P) does handle this case the above
> >>>>>>>>>>>>>>>>>>>>> halting problem undecidable input template has
> >>>>>>>>>>>>>>>>>>>>> been refuted.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> *When this halt deciding principle understood to
> >>>>>>>>>>>>>>>>>>>>> be correct* A halt decider must compute the
> >>>>>>>>>>>>>>>>>>>>> mapping from its inputs to an accept or reject
> >>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior that
> >>>>>>>>>>>>>>>>>>>>> is actually specified by these inputs.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this implements
> >>>>>>>>>>>>>>>>>>>>> that principle* Every simulating halt decider
> >>>>>>>>>>>>>>>>>>>>> that correctly simulates its input until it
> >>>>>>>>>>>>>>>>>>>>> correctly predicts that this simulated input
> >>>>>>>>>>>>>>>>>>>>> would never terminate normally, correctly
> >>>>>>>>>>>>>>>>>>>>> rejects this input as non-halting.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> *H is a Pure function*
> >>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
> >>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the basis of
> >>>>>>>>>>>>>>>>>>>>> software engineering*
> >>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion which I
> >>>>>>>>>>>>>>>>>>>> suppose is progress.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> I have shown that H/P does implement the HP's
> >>>>>>>>>>>>>>>>>>> "impossible input" template.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting
> >>>>>>>>>>>>>>>>>>> problem proofs that rely on this template.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Equating pathological input with non-halting is
> >>>>>>>>>>>>>>>>>> erroneous: you are only doing that because your
> >>>>>>>>>>>>>>>>>> broken solution treats it as "infinite recursion".
> >>>>>>>>>>>>>>>>>> There is no recursion in [Strachey 1965] and the HP
> >>>>>>>>>>>>>>>>>> proofs based on it.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> There is no recursion in any of the conventional
> >>>>>>>>>>>>>>>>> proofs only because no one ever previously bothered
> >>>>>>>>>>>>>>>>> to fully examine how a simulating halt decider would
> >>>>>>>>>>>>>>>>> address these otherwise "impossible" inputs.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> I have shown that a simulating halt decider needn't
> >>>>>>>>>>>>>>>> be recursive in nature:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> You sure do make it easy to review your work.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> "When the simulator detects the call to H
> >>>>>>>>>>>>>>> in P it forks the simulation into a non-halting
> >>>>>>>>>>>>>>> branch"
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> There is an infinite set of cases where this overly
> >>>>>>>>>>>>>>> simplistic criteria gets the wrong answer.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> That is neither an honest review or any kind of
> >>>>>>>>>>>>>> rebuttal: I have told you before: assertions made
> >>>>>>>>>>>>>> without evidence can be dismissed without evidence.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> If you claim there are an infinite number of cases
> >>>>>>>>>>>>>> where it gets the wrong answer then it shouldn't be
> >>>>>>>>>>>>>> too hard for to provide ONE case backing up your claim.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> Sure:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>> {
> >>>>>>>>>>>>> static int count = 3;
> >>>>>>>>>>>>> count--;
> >>>>>>>>>>>>> if (!count) goto exit;
> >>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>> exit:
> >>>>>>>>>>>>> return;
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> int main()
> >>>>>>>>>>>>> {
> >>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> Nope; you seem to have forgotten that my decider is not
> >>>>>>>>>>>> recursive in nature: my decider will correctly determine
> >>>>>>>>>>>> that that input is pathological so will signal an
> >>>>>>>>>>>> exception.
> >>>>>>>>>>>>
> >>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> The above terminates normally so your decider gets the
> >>>>>>>>>>> wrong answer.
> >>>>>>>>>>
> >>>>>>>>>> It is a pathological input so neither halts nor doesn't
> >>>>>>>>>> halt: pathological input is INVALID so the correct
> >>>>>>>>>> "answer" is to signal an exception.
> >>>>>>>>>>
> >>>>>>>>>> /Flibble
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> So you don't know how static variables work?
> >>>>>>>>> I am not surprised.
> >>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> void P(ptr x)
> >>>>>>>>> {
> >>>>>>>>> static int count = 0;
> >>>>>>>>> if (count++ >= 2) goto exit;
> >>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>> if (Halt_Status)
> >>>>>>>>> HERE: goto HERE;
> >>>>>>>>> exit:
> >>>>>>>>> return;
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> int main()
> >>>>>>>>> {
> >>>>>>>>> Output("Input_Halts = ", H(P,P));
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> _Pm()
> >>>>>>>>> [0000141e](01) 55 push ebp
> >>>>>>>>> [0000141f](02) 8bec mov ebp,esp
> >>>>>>>>> [00001421](03) 83ec08 sub esp,+08
> >>>>>>>>> [00001424](05) a100000000 mov eax,[00000000]
> >>>>>>>>> [00001429](03) 8945fc mov [ebp-04],eax
> >>>>>>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
> >>>>>>>>> [00001432](03) 83c101 add ecx,+01
> >>>>>>>>> [00001435](06) 890d00000000 mov [00000000],ecx
> >>>>>>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
> >>>>>>>>> [0000143f](02) 7c02 jl 00001443
> >>>>>>>>> [00001441](02) eb1b jmp 0000145e
> >>>>>>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
> >>>>>>>>> [00001446](01) 52 push edx
> >>>>>>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>> [0000144a](01) 50 push eax
> >>>>>>>>> [0000144b](05) e8defcffff call 0000112e
> >>>>>>>>> [00001450](03) 83c408 add esp,+08
> >>>>>>>>> [00001453](03) 8945f8 mov [ebp-08],eax
> >>>>>>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
> >>>>>>>>> [0000145a](02) 7402 jz 0000145e
> >>>>>>>>> [0000145c](02) ebfe jmp 0000145c
> >>>>>>>>> [0000145e](02) 8be5 mov esp,ebp
> >>>>>>>>> [00001460](01) 5d pop ebp
> >>>>>>>>> [00001461](01) c3 ret
> >>>>>>>>> Size in bytes:(0068) [00001461]
> >>>>>>>>>
> >>>>>>>>> _main()
> >>>>>>>>> [0000146e](01) 55 push ebp
> >>>>>>>>> [0000146f](02) 8bec mov ebp,esp
> >>>>>>>>> [00001471](05) 681e140000 push 0000141e
> >>>>>>>>> [00001476](05) 681e140000 push 0000141e
> >>>>>>>>> [0000147b](05) e8aefcffff call 0000112e
> >>>>>>>>> [00001480](03) 83c408 add esp,+08
> >>>>>>>>> [00001483](01) 50 push eax
> >>>>>>>>> [00001484](05) 685f050000 push 0000055f
> >>>>>>>>> [00001489](05) e820f1ffff call 000005ae
> >>>>>>>>> [0000148e](03) 83c408 add esp,+08
> >>>>>>>>> [00001491](02) 33c0 xor eax,eax
> >>>>>>>>> [00001493](01) 5d pop ebp
> >>>>>>>>> [00001494](01) c3 ret
> >>>>>>>>> Size in bytes:(0039) [00001494]
> >>>>>>>>>
> >>>>>>>>> machine stack stack machine assembly
> >>>>>>>>> address address data code language
> >>>>>>>>> ======== ======== ======== ========= =============
> >>>>>>>>> [0000146e][00102462][00000000] 55 push ebp
> >>>>>>>>> [0000146f][00102462][00000000] 8bec mov ebp,esp
> >>>>>>>>> [00001471][0010245e][0000141e] 681e140000 push 0000141e
> >>>>>>>>> [00001476][0010245a][0000141e] 681e140000 push 0000141e
> >>>>>>>>> [0000147b][00102456][00001480] e8aefcffff call 0000112e
> >>>>>>>>>
> >>>>>>>>> H: Begin Simulation Execution Trace Stored at:11250e
> >>>>>>>>> Address_of_H:112e
> >>>>>>>>> [0000141e][001124fa][001124fe] 55 push ebp
> >>>>>>>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
> >>>>>>>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
> >>>>>>>>> [00001424][001124f2][90909090] a100000000 mov
> >>>>>>>>> eax,[00000000] [00001429][001124f2][90909090] 8945fc
> >>>>>>>>> mov [ebp-04],eax [0000142c][001124f2][90909090]
> >>>>>>>>> 8b0d00000000 mov ecx,[00000000]
> >>>>>>>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
> >>>>>>>>> [00001435][001124f2][90909090] 890d00000000 mov
> >>>>>>>>> [00000000],ecx [0000143b][001124f2][90909090] 837dfc02
> >>>>>>>>> cmp dword [ebp-04],+02 [0000143f][001124f2][90909090] 7c02
> >>>>>>>>> jl 00001443 [00001441][001124f2][90909090] eb1b
> >>>>>>>>> jmp 0000145e [0000145e][001124fa][001124fe] 8be5
> >>>>>>>>> mov esp,ebp [00001460][001124fe][00001217] 5d pop
> >>>>>>>>> ebp [00001461][00112502][0000141e] c3 ret H: End
> >>>>>>>>> Simulation Input Terminated Normally
> >>>>>>>>>
> >>>>>>>>> [00001480][00102462][00000000] 83c408 add esp,+08
> >>>>>>>>> [00001483][0010245e][00000001] 50 push eax
> >>>>>>>>> [00001484][0010245a][0000055f] 685f050000 push 0000055f
> >>>>>>>>> [00001489][0010245a][0000055f] e820f1ffff call 000005ae
> >>>>>>>>> Input_Halts = 1
> >>>>>>>>> [0000148e][00102462][00000000] 83c408 add esp,+08
> >>>>>>>>> [00001491][00102462][00000000] 33c0 xor eax,eax
> >>>>>>>>> [00001493][00102466][00000018] 5d pop ebp
> >>>>>>>>> [00001494][0010246a][00000000] c3 ret
> >>>>>>>>> Number of Instructions Executed(1317) == 20 Pages
> >>>>>>>>
> >>>>>>>> For this particular stack trace I notice that the function
> >>>>>>>> symbol at the top of it is Pm not P which suggests to me one
> >>>>>>>> of two things:
> >>>>>>>
> >>>>>>> I already had a P so I renamed it to Pm so it would not
> >>>>>>> disturb my existing code. When I changed all the Pm
> >>>>>>> references to your name I forgot one.
> >>>>>>
> >>>>>> Then I suggest you check the output of compilation/linking is
> >>>>>> actually initializing static variables correctly. Are you even
> >>>>>> using a linker or are you just executing an object file?
> >>>>>> Static data normally goes into a separate data segment during
> >>>>>> the linking process.
> >>>>>>
> >>>>>> /Flibble
> >>>>>>
> >>>>>
> >>>>> I haven't used static data in such a long time that I forgot the
> >>>>> compiler does not allocate any space for static variables unless
> >>>>> they have been initialized to a non-zero value.
> >>>>>
> >>>>> void Pm(u32 x)
> >>>>> {
> >>>>> static int count = 0x777;
> >>>>> if (count++ > 0x777) goto exit;
> >>>>> int Halt_Status = H(x, x);
> >>>>> if (Halt_Status)
> >>>>> HERE: goto HERE;
> >>>>> exit:
> >>>>> return;
> >>>>> }
> >>>>>
> >>>>> int main()
> >>>>> {
> >>>>> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
> >>>>> }
> >>>>>
> >>>>>
> >>>>> _Pm()
> >>>>> [00000a1a](01) 55 push ebp
> >>>>> [00000a1b](02) 8bec mov ebp,esp
> >>>>> [00000a1d](03) 83ec08 sub esp,+08
> >>>>> [00000a20](05) a107030000 mov eax,[00000307]
> >>>>> [00000a25](03) 8945fc mov [ebp-04],eax
> >>>>> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
> >>>>> [00000a2e](03) 83c101 add ecx,+01
> >>>>> [00000a31](06) 890d07030000 mov [00000307],ecx
> >>>>> [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>> [00000a3e](02) 7e02 jng 00000a42
> >>>>> [00000a40](02) eb1b jmp 00000a5d
> >>>>> [00000a42](03) 8b5508 mov edx,[ebp+08]
> >>>>> [00000a45](01) 52 push edx
> >>>>> [00000a46](03) 8b4508 mov eax,[ebp+08]
> >>>>> [00000a49](01) 50 push eax
> >>>>> [00000a4a](05) e8ebfdffff call 0000083a // call H
> >>>>> [00000a4f](03) 83c408 add esp,+08
> >>>>> [00000a52](03) 8945f8 mov [ebp-08],eax
> >>>>> [00000a55](04) 837df800 cmp dword [ebp-08],+00
> >>>>> [00000a59](02) 7402 jz 00000a5d
> >>>>> [00000a5b](02) ebfe jmp 00000a5b
> >>>>> [00000a5d](02) 8be5 mov esp,ebp
> >>>>> [00000a5f](01) 5d pop ebp
> >>>>> [00000a60](01) c3 ret
> >>>>> Size in bytes:(0071) [00000a60]
> >>>>>
> >>>>> _main()
> >>>>> [00000a6a](01) 55 push ebp
> >>>>> [00000a6b](02) 8bec mov ebp,esp
> >>>>> [00000a6d](05) 681a0a0000 push 00000a1a // push address
> >>>>> of P [00000a72](05) 681a0a0000 push 00000a1a // push
> >>>>> address of P [00000a77](05) e8befdffff call 0000083a //
> >>>>> call H [00000a7c](03) 83c408 add esp,+08
> >>>>> [00000a7f](01) 50 push eax
> >>>>> [00000a80](05) 680b030000 push 0000030b
> >>>>> [00000a85](05) e8d0f8ffff call 0000035a
> >>>>> [00000a8a](03) 83c408 add esp,+08
> >>>>> [00000a8d](02) 33c0 xor eax,eax
> >>>>> [00000a8f](01) 5d pop ebp
> >>>>> [00000a90](01) c3 ret
> >>>>> Size in bytes:(0039) [00000a90]
> >>>>>
> >>>>> machine stack stack machine assembly
> >>>>> address address data code language
> >>>>> ======== ======== ======== ========= =============
> >>>>> ...[00000a6a][0010137b][00000000] 55 push ebp
> >>>>> ...[00000a6b][0010137b][00000000] 8bec mov ebp,esp
> >>>>> ...[00000a6d][00101377][00000a1a] 681a0a0000 push 00000a1a
> >>>>> ...[00000a72][00101373][00000a1a] 681a0a0000 push 00000a1a
> >>>>> ...[00000a77][0010136f][00000a7c] e8befdffff call 0000083a
> >>>>> New slave_stack at:201427
> >>>>>
> >>>>> Begin Local Halt Decider Simulation Execution Trace Stored
> >>>>> at:21142f ...[00000a1a][0021141b][0021141f] 55 push
> >>>>> ebp ...[00000a1b][0021141b][0021141f] 8bec mov
> >>>>> ebp,esp ...[00000a1d][00211413][90909090] 83ec08 sub
> >>>>> esp,+08 ...[00000a20][00211413][90909090] a107030000 mov
> >>>>> eax,[00000307] ...[00000a25][00211413][90909090] 8945fc
> >>>>> mov [ebp-04],eax ...[00000a28][00211413][90909090] 8b0d07030000
> >>>>> mov ecx,[00000307] ...[00000a2e][00211413][90909090] 83c101
> >>>>> add ecx,+01 ...[00000a31][00211413][90909090] 890d07030000
> >>>>> mov [00000307],ecx ...[00000a37][00211413][90909090]
> >>>>> 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>> ...[00000a3e][00211413][90909090] 7e02 jng 00000a42
> >>>>> ...[00000a42][00211413][90909090] 8b5508 mov
> >>>>> edx,[ebp+08] ...[00000a45][0021140f][00000a1a] 52
> >>>>> push edx // push address of P
> >>>>> ...[00000a46][0021140f][00000a1a] 8b4508 mov
> >>>>> eax,[ebp+08] ...[00000a49][0021140b][00000a1a] 50
> >>>>> push eax // push address of P
> >>>>> ...[00000a4a][00211407][00000a4f] e8ebfdffff call 0000083a
> >>>>> // call H New slave_stack at:24be4f
> >>>>> ...[00000a1a][0025be43][0025be47] 55 push ebp
> >>>>> ...[00000a1b][0025be43][0025be47] 8bec mov ebp,esp
> >>>>> ...[00000a1d][0025be3b][90909090] 83ec08 sub esp,+08
> >>>>> ...[00000a20][0025be3b][90909090] a107030000 mov
> >>>>> eax,[00000307] ...[00000a25][0025be3b][90909090] 8945fc
> >>>>> mov [ebp-04],eax ...[00000a28][0025be3b][90909090] 8b0d07030000
> >>>>> mov ecx,[00000307] ...[00000a2e][0025be3b][90909090] 83c101
> >>>>> add ecx,+01 ...[00000a31][0025be3b][90909090] 890d07030000
> >>>>> mov [00000307],ecx ...[00000a37][0025be3b][90909090]
> >>>>> 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>> ...[00000a3e][0025be3b][90909090] 7e02 jng 00000a42
> >>>>> ...[00000a40][0025be3b][90909090] eb1b jmp 00000a5d
> >>>>> // jmp to exit
> >>>>> ...[00000a5d][0025be43][0025be47] 8be5 mov esp,ebp
> >>>>> ...[00000a5f][0025be47][00000904] 5d pop ebp
> >>>>> ...[00000a60][0025be4b][00000a1a] c3 ret
> >>>>> ...[00000a7c][0010137b][00000000] 83c408 add esp,+08
> >>>>> ...[00000a7f][00101377][00000001] 50 push eax
> >>>>> ...[00000a80][00101373][0000030b] 680b030000 push 0000030b
> >>>>> ---[00000a85][00101373][0000030b] e8d0f8ffff call 0000035a
> >>>>> Input_Halts = 1
> >>>>> ...[00000a8a][0010137b][00000000] 83c408 add esp,+08
> >>>>> ...[00000a8d][0010137b][00000000] 33c0 xor eax,eax
> >>>>> ...[00000a8f][0010137f][00100000] 5d pop ebp
> >>>>> ...[00000a90][00101383][00000004] c3 ret
> >>>>> Number of Instructions Executed(27278)
> >>>>>
> >>>>>
> >>>>
> >>>> Still seems wrong: post increment of the static variable should
> >>>> ensure that it does NOT goto exit but instead should call H which
> >>>> should presumably cause your "infinite recursion detected"
> >>>> bollocks to manifest.
> >>>
> >>> OK, I've looked at your assembly trace and it is recursing into Pm
> >>> from H and then halting but I am not sure what you are trying to
> >>> prove? Again [Strachey 1965] and associated proofs are not
> >>> recursive in nature.
> >>>
> >>> /Flibble
> >>>
> >>
> >> (1) H cannot correctly determine the halt status of the HP
> >> counter-examples unless H is a simulating halt decider.
> >>
> >> (2) The claim of the halting problem proofs is that no H in the
> >> universe can possibly correctly determine the halt status of its
> >> corresponding pathological input.
> >>
> >> (3) H(P,P) does correctly determine that its correponding
> >> pathological input would never halt.
> >>
> >> (4) It is ridiculously stupid of you to say that [Strachey 1965]
> >> does not specify infinitely recursive simulation when it is an
> >> easily verified fact that when Strachey T <is> a simulating halt
> >> decider that Strachey P <does> specify infinitely recursive
> >> simulation.
> >>
> >> It does not say this directly in [Strachey 1965] only because no
> >> one ever previously bothered to fully examine the effect of a
> >> simulating halt decider on the HP's pathological inputs.
> >
> > I see I have to repeat myself yet again: a simulating halt decider
> > needn't be recursive in nature and I have sketched a design of such
> > a halt decider:
> >
> > https://github.com/i42output/halting-problem/blob/main/README.txt
> >
> > You are incorrect to claim an equivalence between pathological input
> > and non-halting.
> >
> > /Flibble
> >
> >
>
> 19 When the simulator detects the call to H in P it forks the
> simulation 20 into a non-halting branch (returning 0 to P) and a
> halting branch 21 (returning 1 to P)
>
> Software engineers at the low end of technical competence may not
> fully comprehend the common knowledge that:
>
> Whenever a function is called in what is essentially infinite
> recursion this function cannot possibly correctly return any value to
> its caller. You don't seem to understand that.
Why are you so fucking obtuse? My forking simulating decider IS NOT
RECURSIVE. My decider when detecting a call to H will NOT call it
but will instead fork the simulation into two COPIES and continue with
the next instruction after the call *as if* the call was made and
returned halting to one copy and not-halting to the other. This is no
less valid than your method of detecting a call to H and
instead of calling it, aborting your simulation.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2022-07-15 13:17 -0500 |
| Message-ID | <qLGdnfQQtoHfMkz_nZ2dnUU7_83NnZ2d@giganews.com> |
| In reply to | #85260 |
On 7/15/2022 1:04 PM, Mr Flibble wrote:
> On Fri, 15 Jul 2022 12:57:53 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/15/2022 12:46 PM, Mr Flibble wrote:
>>> On Fri, 15 Jul 2022 12:39:31 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 7/15/2022 12:28 PM, Mr Flibble wrote:
>>>>> On Fri, 15 Jul 2022 18:08:22 +0100
>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
>>>>>
>>>>>> On Fri, 15 Jul 2022 12:00:59 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>
>>>>>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
>>>>>>>> On Fri, 15 Jul 2022 10:58:14 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>
>>>>>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>
>>>>>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
>>>>>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
>>>>>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This is an explanation of a key new insight into
>>>>>>>>>>>>>>>>>>>>>>> the halting problem provided in the language of
>>>>>>>>>>>>>>>>>>>>>>> software engineering. Technical computer science
>>>>>>>>>>>>>>>>>>>>>>> terms are explained using software engineering
>>>>>>>>>>>>>>>>>>>>>>> terms. No knowledge of the halting problem is
>>>>>>>>>>>>>>>>>>>>>>> required.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is based on fully operational software
>>>>>>>>>>>>>>>>>>>>>>> executed in the x86utm operating system. The
>>>>>>>>>>>>>>>>>>>>>>> x86utm operating system (based on an excellent
>>>>>>>>>>>>>>>>>>>>>>> open source x86 emulator) was created to study
>>>>>>>>>>>>>>>>>>>>>>> the details of the halting problem proof
>>>>>>>>>>>>>>>>>>>>>>> counter-examples at the much higher level of
>>>>>>>>>>>>>>>>>>>>>>> abstraction of C/x86.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P) simulates
>>>>>>>>>>>>>>>>>>>>>>> its input we can see that: (1) Function H() is
>>>>>>>>>>>>>>>>>>>>>>> called from P(). (2) With the same arguments to
>>>>>>>>>>>>>>>>>>>>>>> H(). (3) With no instructions in P preceding its
>>>>>>>>>>>>>>>>>>>>>>> invocation of H(P,P).
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The above shows that the simulated P cannot
>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. Because H can see
>>>>>>>>>>>>>>>>>>>>>>> the same (1)(2)(3) that we see H aborts its
>>>>>>>>>>>>>>>>>>>>>>> simulation of P and rejects P as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> In computability theory, the
>>>>>>>>>>>>>>>>>>>>>>> halting problem is the problem of determining,
>>>>>>>>>>>>>>>>>>>>>>> from a description of an arbitrary computer
>>>>>>>>>>>>>>>>>>>>>>> program and an input, whether the program will
>>>>>>>>>>>>>>>>>>>>>>> finish running, or continue to run forever. Alan
>>>>>>>>>>>>>>>>>>>>>>> Turing proved in 1936 that a general algorithm
>>>>>>>>>>>>>>>>>>>>>>> to solve the halting problem for all possible
>>>>>>>>>>>>>>>>>>>>>>> program- input pairs cannot exist.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> For any program H that might
>>>>>>>>>>>>>>>>>>>>>>> determine if programs halt, a "pathological"
>>>>>>>>>>>>>>>>>>>>>>> program P, called with some input, can pass its
>>>>>>>>>>>>>>>>>>>>>>> own source and its input to H and then
>>>>>>>>>>>>>>>>>>>>>>> specifically do the opposite of what H predicts
>>>>>>>>>>>>>>>>>>>>>>> P will do. No H can exist that handles this
>>>>>>>>>>>>>>>>>>>>>>> case.
>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
>>>>>>>>>>>>>>>>>>>>>>> relationship to each other as described above.
>>>>>>>>>>>>>>>>>>>>>>> Because H(P,P) does handle this case the above
>>>>>>>>>>>>>>>>>>>>>>> halting problem undecidable input template has
>>>>>>>>>>>>>>>>>>>>>>> been refuted.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *When this halt deciding principle understood to
>>>>>>>>>>>>>>>>>>>>>>> be correct* A halt decider must compute the
>>>>>>>>>>>>>>>>>>>>>>> mapping from its inputs to an accept or reject
>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior that
>>>>>>>>>>>>>>>>>>>>>>> is actually specified by these inputs.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this implements
>>>>>>>>>>>>>>>>>>>>>>> that principle* Every simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>> that correctly simulates its input until it
>>>>>>>>>>>>>>>>>>>>>>> correctly predicts that this simulated input
>>>>>>>>>>>>>>>>>>>>>>> would never terminate normally, correctly
>>>>>>>>>>>>>>>>>>>>>>> rejects this input as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *H is a Pure function*
>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the basis of
>>>>>>>>>>>>>>>>>>>>>>> software engineering*
>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion which I
>>>>>>>>>>>>>>>>>>>>>> suppose is progress.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I have shown that H/P does implement the HP's
>>>>>>>>>>>>>>>>>>>>> "impossible input" template.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting
>>>>>>>>>>>>>>>>>>>>> problem proofs that rely on this template.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Equating pathological input with non-halting is
>>>>>>>>>>>>>>>>>>>> erroneous: you are only doing that because your
>>>>>>>>>>>>>>>>>>>> broken solution treats it as "infinite recursion".
>>>>>>>>>>>>>>>>>>>> There is no recursion in [Strachey 1965] and the HP
>>>>>>>>>>>>>>>>>>>> proofs based on it.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> There is no recursion in any of the conventional
>>>>>>>>>>>>>>>>>>> proofs only because no one ever previously bothered
>>>>>>>>>>>>>>>>>>> to fully examine how a simulating halt decider would
>>>>>>>>>>>>>>>>>>> address these otherwise "impossible" inputs.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I have shown that a simulating halt decider needn't
>>>>>>>>>>>>>>>>>> be recursive in nature:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You sure do make it easy to review your work.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> "When the simulator detects the call to H
>>>>>>>>>>>>>>>>> in P it forks the simulation into a non-halting
>>>>>>>>>>>>>>>>> branch"
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> There is an infinite set of cases where this overly
>>>>>>>>>>>>>>>>> simplistic criteria gets the wrong answer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That is neither an honest review or any kind of
>>>>>>>>>>>>>>>> rebuttal: I have told you before: assertions made
>>>>>>>>>>>>>>>> without evidence can be dismissed without evidence.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If you claim there are an infinite number of cases
>>>>>>>>>>>>>>>> where it gets the wrong answer then it shouldn't be
>>>>>>>>>>>>>>>> too hard for to provide ONE case backing up your claim.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Sure:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> static int count = 3;
>>>>>>>>>>>>>>> count--;
>>>>>>>>>>>>>>> if (!count) goto exit;
>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>> exit:
>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope; you seem to have forgotten that my decider is not
>>>>>>>>>>>>>> recursive in nature: my decider will correctly determine
>>>>>>>>>>>>>> that that input is pathological so will signal an
>>>>>>>>>>>>>> exception.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The above terminates normally so your decider gets the
>>>>>>>>>>>>> wrong answer.
>>>>>>>>>>>>
>>>>>>>>>>>> It is a pathological input so neither halts nor doesn't
>>>>>>>>>>>> halt: pathological input is INVALID so the correct
>>>>>>>>>>>> "answer" is to signal an exception.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So you don't know how static variables work?
>>>>>>>>>>> I am not surprised.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>> {
>>>>>>>>>>> static int count = 0;
>>>>>>>>>>> if (count++ >= 2) goto exit;
>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>> exit:
>>>>>>>>>>> return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>> Output("Input_Halts = ", H(P,P));
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> _Pm()
>>>>>>>>>>> [0000141e](01) 55 push ebp
>>>>>>>>>>> [0000141f](02) 8bec mov ebp,esp
>>>>>>>>>>> [00001421](03) 83ec08 sub esp,+08
>>>>>>>>>>> [00001424](05) a100000000 mov eax,[00000000]
>>>>>>>>>>> [00001429](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
>>>>>>>>>>> [00001432](03) 83c101 add ecx,+01
>>>>>>>>>>> [00001435](06) 890d00000000 mov [00000000],ecx
>>>>>>>>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
>>>>>>>>>>> [0000143f](02) 7c02 jl 00001443
>>>>>>>>>>> [00001441](02) eb1b jmp 0000145e
>>>>>>>>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
>>>>>>>>>>> [00001446](01) 52 push edx
>>>>>>>>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> [0000144a](01) 50 push eax
>>>>>>>>>>> [0000144b](05) e8defcffff call 0000112e
>>>>>>>>>>> [00001450](03) 83c408 add esp,+08
>>>>>>>>>>> [00001453](03) 8945f8 mov [ebp-08],eax
>>>>>>>>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
>>>>>>>>>>> [0000145a](02) 7402 jz 0000145e
>>>>>>>>>>> [0000145c](02) ebfe jmp 0000145c
>>>>>>>>>>> [0000145e](02) 8be5 mov esp,ebp
>>>>>>>>>>> [00001460](01) 5d pop ebp
>>>>>>>>>>> [00001461](01) c3 ret
>>>>>>>>>>> Size in bytes:(0068) [00001461]
>>>>>>>>>>>
>>>>>>>>>>> _main()
>>>>>>>>>>> [0000146e](01) 55 push ebp
>>>>>>>>>>> [0000146f](02) 8bec mov ebp,esp
>>>>>>>>>>> [00001471](05) 681e140000 push 0000141e
>>>>>>>>>>> [00001476](05) 681e140000 push 0000141e
>>>>>>>>>>> [0000147b](05) e8aefcffff call 0000112e
>>>>>>>>>>> [00001480](03) 83c408 add esp,+08
>>>>>>>>>>> [00001483](01) 50 push eax
>>>>>>>>>>> [00001484](05) 685f050000 push 0000055f
>>>>>>>>>>> [00001489](05) e820f1ffff call 000005ae
>>>>>>>>>>> [0000148e](03) 83c408 add esp,+08
>>>>>>>>>>> [00001491](02) 33c0 xor eax,eax
>>>>>>>>>>> [00001493](01) 5d pop ebp
>>>>>>>>>>> [00001494](01) c3 ret
>>>>>>>>>>> Size in bytes:(0039) [00001494]
>>>>>>>>>>>
>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>> address address data code language
>>>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>>>> [0000146e][00102462][00000000] 55 push ebp
>>>>>>>>>>> [0000146f][00102462][00000000] 8bec mov ebp,esp
>>>>>>>>>>> [00001471][0010245e][0000141e] 681e140000 push 0000141e
>>>>>>>>>>> [00001476][0010245a][0000141e] 681e140000 push 0000141e
>>>>>>>>>>> [0000147b][00102456][00001480] e8aefcffff call 0000112e
>>>>>>>>>>>
>>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:11250e
>>>>>>>>>>> Address_of_H:112e
>>>>>>>>>>> [0000141e][001124fa][001124fe] 55 push ebp
>>>>>>>>>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
>>>>>>>>>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
>>>>>>>>>>> [00001424][001124f2][90909090] a100000000 mov
>>>>>>>>>>> eax,[00000000] [00001429][001124f2][90909090] 8945fc
>>>>>>>>>>> mov [ebp-04],eax [0000142c][001124f2][90909090]
>>>>>>>>>>> 8b0d00000000 mov ecx,[00000000]
>>>>>>>>>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
>>>>>>>>>>> [00001435][001124f2][90909090] 890d00000000 mov
>>>>>>>>>>> [00000000],ecx [0000143b][001124f2][90909090] 837dfc02
>>>>>>>>>>> cmp dword [ebp-04],+02 [0000143f][001124f2][90909090] 7c02
>>>>>>>>>>> jl 00001443 [00001441][001124f2][90909090] eb1b
>>>>>>>>>>> jmp 0000145e [0000145e][001124fa][001124fe] 8be5
>>>>>>>>>>> mov esp,ebp [00001460][001124fe][00001217] 5d pop
>>>>>>>>>>> ebp [00001461][00112502][0000141e] c3 ret H: End
>>>>>>>>>>> Simulation Input Terminated Normally
>>>>>>>>>>>
>>>>>>>>>>> [00001480][00102462][00000000] 83c408 add esp,+08
>>>>>>>>>>> [00001483][0010245e][00000001] 50 push eax
>>>>>>>>>>> [00001484][0010245a][0000055f] 685f050000 push 0000055f
>>>>>>>>>>> [00001489][0010245a][0000055f] e820f1ffff call 000005ae
>>>>>>>>>>> Input_Halts = 1
>>>>>>>>>>> [0000148e][00102462][00000000] 83c408 add esp,+08
>>>>>>>>>>> [00001491][00102462][00000000] 33c0 xor eax,eax
>>>>>>>>>>> [00001493][00102466][00000018] 5d pop ebp
>>>>>>>>>>> [00001494][0010246a][00000000] c3 ret
>>>>>>>>>>> Number of Instructions Executed(1317) == 20 Pages
>>>>>>>>>>
>>>>>>>>>> For this particular stack trace I notice that the function
>>>>>>>>>> symbol at the top of it is Pm not P which suggests to me one
>>>>>>>>>> of two things:
>>>>>>>>>
>>>>>>>>> I already had a P so I renamed it to Pm so it would not
>>>>>>>>> disturb my existing code. When I changed all the Pm
>>>>>>>>> references to your name I forgot one.
>>>>>>>>
>>>>>>>> Then I suggest you check the output of compilation/linking is
>>>>>>>> actually initializing static variables correctly. Are you even
>>>>>>>> using a linker or are you just executing an object file?
>>>>>>>> Static data normally goes into a separate data segment during
>>>>>>>> the linking process.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> I haven't used static data in such a long time that I forgot the
>>>>>>> compiler does not allocate any space for static variables unless
>>>>>>> they have been initialized to a non-zero value.
>>>>>>>
>>>>>>> void Pm(u32 x)
>>>>>>> {
>>>>>>> static int count = 0x777;
>>>>>>> if (count++ > 0x777) goto exit;
>>>>>>> int Halt_Status = H(x, x);
>>>>>>> if (Halt_Status)
>>>>>>> HERE: goto HERE;
>>>>>>> exit:
>>>>>>> return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
>>>>>>> }
>>>>>>>
>>>>>>>
>>>>>>> _Pm()
>>>>>>> [00000a1a](01) 55 push ebp
>>>>>>> [00000a1b](02) 8bec mov ebp,esp
>>>>>>> [00000a1d](03) 83ec08 sub esp,+08
>>>>>>> [00000a20](05) a107030000 mov eax,[00000307]
>>>>>>> [00000a25](03) 8945fc mov [ebp-04],eax
>>>>>>> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
>>>>>>> [00000a2e](03) 83c101 add ecx,+01
>>>>>>> [00000a31](06) 890d07030000 mov [00000307],ecx
>>>>>>> [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>> [00000a3e](02) 7e02 jng 00000a42
>>>>>>> [00000a40](02) eb1b jmp 00000a5d
>>>>>>> [00000a42](03) 8b5508 mov edx,[ebp+08]
>>>>>>> [00000a45](01) 52 push edx
>>>>>>> [00000a46](03) 8b4508 mov eax,[ebp+08]
>>>>>>> [00000a49](01) 50 push eax
>>>>>>> [00000a4a](05) e8ebfdffff call 0000083a // call H
>>>>>>> [00000a4f](03) 83c408 add esp,+08
>>>>>>> [00000a52](03) 8945f8 mov [ebp-08],eax
>>>>>>> [00000a55](04) 837df800 cmp dword [ebp-08],+00
>>>>>>> [00000a59](02) 7402 jz 00000a5d
>>>>>>> [00000a5b](02) ebfe jmp 00000a5b
>>>>>>> [00000a5d](02) 8be5 mov esp,ebp
>>>>>>> [00000a5f](01) 5d pop ebp
>>>>>>> [00000a60](01) c3 ret
>>>>>>> Size in bytes:(0071) [00000a60]
>>>>>>>
>>>>>>> _main()
>>>>>>> [00000a6a](01) 55 push ebp
>>>>>>> [00000a6b](02) 8bec mov ebp,esp
>>>>>>> [00000a6d](05) 681a0a0000 push 00000a1a // push address
>>>>>>> of P [00000a72](05) 681a0a0000 push 00000a1a // push
>>>>>>> address of P [00000a77](05) e8befdffff call 0000083a //
>>>>>>> call H [00000a7c](03) 83c408 add esp,+08
>>>>>>> [00000a7f](01) 50 push eax
>>>>>>> [00000a80](05) 680b030000 push 0000030b
>>>>>>> [00000a85](05) e8d0f8ffff call 0000035a
>>>>>>> [00000a8a](03) 83c408 add esp,+08
>>>>>>> [00000a8d](02) 33c0 xor eax,eax
>>>>>>> [00000a8f](01) 5d pop ebp
>>>>>>> [00000a90](01) c3 ret
>>>>>>> Size in bytes:(0039) [00000a90]
>>>>>>>
>>>>>>> machine stack stack machine assembly
>>>>>>> address address data code language
>>>>>>> ======== ======== ======== ========= =============
>>>>>>> ...[00000a6a][0010137b][00000000] 55 push ebp
>>>>>>> ...[00000a6b][0010137b][00000000] 8bec mov ebp,esp
>>>>>>> ...[00000a6d][00101377][00000a1a] 681a0a0000 push 00000a1a
>>>>>>> ...[00000a72][00101373][00000a1a] 681a0a0000 push 00000a1a
>>>>>>> ...[00000a77][0010136f][00000a7c] e8befdffff call 0000083a
>>>>>>> New slave_stack at:201427
>>>>>>>
>>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>>>>>> at:21142f ...[00000a1a][0021141b][0021141f] 55 push
>>>>>>> ebp ...[00000a1b][0021141b][0021141f] 8bec mov
>>>>>>> ebp,esp ...[00000a1d][00211413][90909090] 83ec08 sub
>>>>>>> esp,+08 ...[00000a20][00211413][90909090] a107030000 mov
>>>>>>> eax,[00000307] ...[00000a25][00211413][90909090] 8945fc
>>>>>>> mov [ebp-04],eax ...[00000a28][00211413][90909090] 8b0d07030000
>>>>>>> mov ecx,[00000307] ...[00000a2e][00211413][90909090] 83c101
>>>>>>> add ecx,+01 ...[00000a31][00211413][90909090] 890d07030000
>>>>>>> mov [00000307],ecx ...[00000a37][00211413][90909090]
>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>> ...[00000a3e][00211413][90909090] 7e02 jng 00000a42
>>>>>>> ...[00000a42][00211413][90909090] 8b5508 mov
>>>>>>> edx,[ebp+08] ...[00000a45][0021140f][00000a1a] 52
>>>>>>> push edx // push address of P
>>>>>>> ...[00000a46][0021140f][00000a1a] 8b4508 mov
>>>>>>> eax,[ebp+08] ...[00000a49][0021140b][00000a1a] 50
>>>>>>> push eax // push address of P
>>>>>>> ...[00000a4a][00211407][00000a4f] e8ebfdffff call 0000083a
>>>>>>> // call H New slave_stack at:24be4f
>>>>>>> ...[00000a1a][0025be43][0025be47] 55 push ebp
>>>>>>> ...[00000a1b][0025be43][0025be47] 8bec mov ebp,esp
>>>>>>> ...[00000a1d][0025be3b][90909090] 83ec08 sub esp,+08
>>>>>>> ...[00000a20][0025be3b][90909090] a107030000 mov
>>>>>>> eax,[00000307] ...[00000a25][0025be3b][90909090] 8945fc
>>>>>>> mov [ebp-04],eax ...[00000a28][0025be3b][90909090] 8b0d07030000
>>>>>>> mov ecx,[00000307] ...[00000a2e][0025be3b][90909090] 83c101
>>>>>>> add ecx,+01 ...[00000a31][0025be3b][90909090] 890d07030000
>>>>>>> mov [00000307],ecx ...[00000a37][0025be3b][90909090]
>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>> ...[00000a3e][0025be3b][90909090] 7e02 jng 00000a42
>>>>>>> ...[00000a40][0025be3b][90909090] eb1b jmp 00000a5d
>>>>>>> // jmp to exit
>>>>>>> ...[00000a5d][0025be43][0025be47] 8be5 mov esp,ebp
>>>>>>> ...[00000a5f][0025be47][00000904] 5d pop ebp
>>>>>>> ...[00000a60][0025be4b][00000a1a] c3 ret
>>>>>>> ...[00000a7c][0010137b][00000000] 83c408 add esp,+08
>>>>>>> ...[00000a7f][00101377][00000001] 50 push eax
>>>>>>> ...[00000a80][00101373][0000030b] 680b030000 push 0000030b
>>>>>>> ---[00000a85][00101373][0000030b] e8d0f8ffff call 0000035a
>>>>>>> Input_Halts = 1
>>>>>>> ...[00000a8a][0010137b][00000000] 83c408 add esp,+08
>>>>>>> ...[00000a8d][0010137b][00000000] 33c0 xor eax,eax
>>>>>>> ...[00000a8f][0010137f][00100000] 5d pop ebp
>>>>>>> ...[00000a90][00101383][00000004] c3 ret
>>>>>>> Number of Instructions Executed(27278)
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Still seems wrong: post increment of the static variable should
>>>>>> ensure that it does NOT goto exit but instead should call H which
>>>>>> should presumably cause your "infinite recursion detected"
>>>>>> bollocks to manifest.
>>>>>
>>>>> OK, I've looked at your assembly trace and it is recursing into Pm
>>>>> from H and then halting but I am not sure what you are trying to
>>>>> prove? Again [Strachey 1965] and associated proofs are not
>>>>> recursive in nature.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> (1) H cannot correctly determine the halt status of the HP
>>>> counter-examples unless H is a simulating halt decider.
>>>>
>>>> (2) The claim of the halting problem proofs is that no H in the
>>>> universe can possibly correctly determine the halt status of its
>>>> corresponding pathological input.
>>>>
>>>> (3) H(P,P) does correctly determine that its correponding
>>>> pathological input would never halt.
>>>>
>>>> (4) It is ridiculously stupid of you to say that [Strachey 1965]
>>>> does not specify infinitely recursive simulation when it is an
>>>> easily verified fact that when Strachey T <is> a simulating halt
>>>> decider that Strachey P <does> specify infinitely recursive
>>>> simulation.
>>>>
>>>> It does not say this directly in [Strachey 1965] only because no
>>>> one ever previously bothered to fully examine the effect of a
>>>> simulating halt decider on the HP's pathological inputs.
>>>
>>> I see I have to repeat myself yet again: a simulating halt decider
>>> needn't be recursive in nature and I have sketched a design of such
>>> a halt decider:
>>>
>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>
>>> You are incorrect to claim an equivalence between pathological input
>>> and non-halting.
>>>
>>> /Flibble
>>>
>>>
>>
>> 19 When the simulator detects the call to H in P it forks the
>> simulation 20 into a non-halting branch (returning 0 to P) and a
>> halting branch 21 (returning 1 to P)
>>
>> Software engineers at the low end of technical competence may not
>> fully comprehend the common knowledge that:
>>
>> Whenever a function is called in what is essentially infinite
>> recursion this function cannot possibly correctly return any value to
>> its caller. You don't seem to understand that.
>
> Why are you so fucking obtuse? My forking simulating decider IS NOT
> RECURSIVE.
It is directly disobeying the actual behavior specified by the actual
input by returning a value to a function that called it in infinite
recursion.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-07-15 19:23 +0100 |
| Message-ID | <20220715192306.00003910@reddwarf.jmc.corp> |
| In reply to | #85261 |
On Fri, 15 Jul 2022 13:17:37 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/15/2022 1:04 PM, Mr Flibble wrote:
> > On Fri, 15 Jul 2022 12:57:53 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 7/15/2022 12:46 PM, Mr Flibble wrote:
> >>> On Fri, 15 Jul 2022 12:39:31 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 7/15/2022 12:28 PM, Mr Flibble wrote:
> >>>>> On Fri, 15 Jul 2022 18:08:22 +0100
> >>>>> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
> >>>>>
> >>>>>> On Fri, 15 Jul 2022 12:00:59 -0500
> >>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>
> >>>>>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
> >>>>>>>> On Fri, 15 Jul 2022 10:58:14 -0500
> >>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>
> >>>>>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
> >>>>>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
> >>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>
> >>>>>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
> >>>>>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
> >>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>
> >>>>>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
> >>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
> >>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
> >>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
> >>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
> >>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> This is an explanation of a key new insight
> >>>>>>>>>>>>>>>>>>>>>>> into the halting problem provided in the
> >>>>>>>>>>>>>>>>>>>>>>> language of software engineering. Technical
> >>>>>>>>>>>>>>>>>>>>>>> computer science terms are explained using
> >>>>>>>>>>>>>>>>>>>>>>> software engineering terms. No knowledge of
> >>>>>>>>>>>>>>>>>>>>>>> the halting problem is required.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> It is based on fully operational software
> >>>>>>>>>>>>>>>>>>>>>>> executed in the x86utm operating system. The
> >>>>>>>>>>>>>>>>>>>>>>> x86utm operating system (based on an excellent
> >>>>>>>>>>>>>>>>>>>>>>> open source x86 emulator) was created to study
> >>>>>>>>>>>>>>>>>>>>>>> the details of the halting problem proof
> >>>>>>>>>>>>>>>>>>>>>>> counter-examples at the much higher level of
> >>>>>>>>>>>>>>>>>>>>>>> abstraction of C/x86.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt
> >>>>>>>>>>>>>>>>>>>>>>> decider
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P,
> >>>>>>>>>>>>>>>>>>>>>>> P)); }
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P) simulates
> >>>>>>>>>>>>>>>>>>>>>>> its input we can see that: (1) Function H() is
> >>>>>>>>>>>>>>>>>>>>>>> called from P(). (2) With the same arguments
> >>>>>>>>>>>>>>>>>>>>>>> to H(). (3) With no instructions in P
> >>>>>>>>>>>>>>>>>>>>>>> preceding its invocation of H(P,P).
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> The above shows that the simulated P cannot
> >>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. Because H can see
> >>>>>>>>>>>>>>>>>>>>>>> the same (1)(2)(3) that we see H aborts its
> >>>>>>>>>>>>>>>>>>>>>>> simulation of P and rejects P as non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> In computability theory, the
> >>>>>>>>>>>>>>>>>>>>>>> halting problem is the problem of determining,
> >>>>>>>>>>>>>>>>>>>>>>> from a description of an arbitrary computer
> >>>>>>>>>>>>>>>>>>>>>>> program and an input, whether the program will
> >>>>>>>>>>>>>>>>>>>>>>> finish running, or continue to run forever.
> >>>>>>>>>>>>>>>>>>>>>>> Alan Turing proved in 1936 that a general
> >>>>>>>>>>>>>>>>>>>>>>> algorithm to solve the halting problem for
> >>>>>>>>>>>>>>>>>>>>>>> all possible program- input pairs cannot
> >>>>>>>>>>>>>>>>>>>>>>> exist.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> For any program H that might
> >>>>>>>>>>>>>>>>>>>>>>> determine if programs halt, a "pathological"
> >>>>>>>>>>>>>>>>>>>>>>> program P, called with some input, can pass
> >>>>>>>>>>>>>>>>>>>>>>> its own source and its input to H and then
> >>>>>>>>>>>>>>>>>>>>>>> specifically do the opposite of what H
> >>>>>>>>>>>>>>>>>>>>>>> predicts P will do. No H can exist that
> >>>>>>>>>>>>>>>>>>>>>>> handles this case.
> >>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
> >>>>>>>>>>>>>>>>>>>>>>> relationship to each other as described above.
> >>>>>>>>>>>>>>>>>>>>>>> Because H(P,P) does handle this case the above
> >>>>>>>>>>>>>>>>>>>>>>> halting problem undecidable input template has
> >>>>>>>>>>>>>>>>>>>>>>> been refuted.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> *When this halt deciding principle understood
> >>>>>>>>>>>>>>>>>>>>>>> to be correct* A halt decider must compute the
> >>>>>>>>>>>>>>>>>>>>>>> mapping from its inputs to an accept or reject
> >>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior that
> >>>>>>>>>>>>>>>>>>>>>>> is actually specified by these inputs.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this implements
> >>>>>>>>>>>>>>>>>>>>>>> that principle* Every simulating halt decider
> >>>>>>>>>>>>>>>>>>>>>>> that correctly simulates its input until it
> >>>>>>>>>>>>>>>>>>>>>>> correctly predicts that this simulated input
> >>>>>>>>>>>>>>>>>>>>>>> would never terminate normally, correctly
> >>>>>>>>>>>>>>>>>>>>>>> rejects this input as non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> *H is a Pure function*
> >>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
> >>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the basis
> >>>>>>>>>>>>>>>>>>>>>>> of software engineering*
> >>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion which
> >>>>>>>>>>>>>>>>>>>>>> I suppose is progress.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> I have shown that H/P does implement the HP's
> >>>>>>>>>>>>>>>>>>>>> "impossible input" template.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting
> >>>>>>>>>>>>>>>>>>>>> problem proofs that rely on this template.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Equating pathological input with non-halting is
> >>>>>>>>>>>>>>>>>>>> erroneous: you are only doing that because your
> >>>>>>>>>>>>>>>>>>>> broken solution treats it as "infinite
> >>>>>>>>>>>>>>>>>>>> recursion". There is no recursion in [Strachey
> >>>>>>>>>>>>>>>>>>>> 1965] and the HP proofs based on it.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> There is no recursion in any of the conventional
> >>>>>>>>>>>>>>>>>>> proofs only because no one ever previously
> >>>>>>>>>>>>>>>>>>> bothered to fully examine how a simulating halt
> >>>>>>>>>>>>>>>>>>> decider would address these otherwise
> >>>>>>>>>>>>>>>>>>> "impossible" inputs.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> I have shown that a simulating halt decider needn't
> >>>>>>>>>>>>>>>>>> be recursive in nature:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> You sure do make it easy to review your work.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> "When the simulator detects the call to H
> >>>>>>>>>>>>>>>>> in P it forks the simulation into a non-halting
> >>>>>>>>>>>>>>>>> branch"
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> There is an infinite set of cases where this overly
> >>>>>>>>>>>>>>>>> simplistic criteria gets the wrong answer.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> That is neither an honest review or any kind of
> >>>>>>>>>>>>>>>> rebuttal: I have told you before: assertions made
> >>>>>>>>>>>>>>>> without evidence can be dismissed without evidence.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> If you claim there are an infinite number of cases
> >>>>>>>>>>>>>>>> where it gets the wrong answer then it shouldn't be
> >>>>>>>>>>>>>>>> too hard for to provide ONE case backing up your
> >>>>>>>>>>>>>>>> claim.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Sure:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>> static int count = 3;
> >>>>>>>>>>>>>>> count--;
> >>>>>>>>>>>>>>> if (!count) goto exit;
> >>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>> exit:
> >>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Nope; you seem to have forgotten that my decider is not
> >>>>>>>>>>>>>> recursive in nature: my decider will correctly
> >>>>>>>>>>>>>> determine that that input is pathological so will
> >>>>>>>>>>>>>> signal an exception.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> The above terminates normally so your decider gets the
> >>>>>>>>>>>>> wrong answer.
> >>>>>>>>>>>>
> >>>>>>>>>>>> It is a pathological input so neither halts nor doesn't
> >>>>>>>>>>>> halt: pathological input is INVALID so the correct
> >>>>>>>>>>>> "answer" is to signal an exception.
> >>>>>>>>>>>>
> >>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> So you don't know how static variables work?
> >>>>>>>>>>> I am not surprised.
> >>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>> {
> >>>>>>>>>>> static int count = 0;
> >>>>>>>>>>> if (count++ >= 2) goto exit;
> >>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>> exit:
> >>>>>>>>>>> return;
> >>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>> int main()
> >>>>>>>>>>> {
> >>>>>>>>>>> Output("Input_Halts = ", H(P,P));
> >>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>> _Pm()
> >>>>>>>>>>> [0000141e](01) 55 push ebp
> >>>>>>>>>>> [0000141f](02) 8bec mov ebp,esp
> >>>>>>>>>>> [00001421](03) 83ec08 sub esp,+08
> >>>>>>>>>>> [00001424](05) a100000000 mov eax,[00000000]
> >>>>>>>>>>> [00001429](03) 8945fc mov [ebp-04],eax
> >>>>>>>>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
> >>>>>>>>>>> [00001432](03) 83c101 add ecx,+01
> >>>>>>>>>>> [00001435](06) 890d00000000 mov [00000000],ecx
> >>>>>>>>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
> >>>>>>>>>>> [0000143f](02) 7c02 jl 00001443
> >>>>>>>>>>> [00001441](02) eb1b jmp 0000145e
> >>>>>>>>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
> >>>>>>>>>>> [00001446](01) 52 push edx
> >>>>>>>>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>> [0000144a](01) 50 push eax
> >>>>>>>>>>> [0000144b](05) e8defcffff call 0000112e
> >>>>>>>>>>> [00001450](03) 83c408 add esp,+08
> >>>>>>>>>>> [00001453](03) 8945f8 mov [ebp-08],eax
> >>>>>>>>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
> >>>>>>>>>>> [0000145a](02) 7402 jz 0000145e
> >>>>>>>>>>> [0000145c](02) ebfe jmp 0000145c
> >>>>>>>>>>> [0000145e](02) 8be5 mov esp,ebp
> >>>>>>>>>>> [00001460](01) 5d pop ebp
> >>>>>>>>>>> [00001461](01) c3 ret
> >>>>>>>>>>> Size in bytes:(0068) [00001461]
> >>>>>>>>>>>
> >>>>>>>>>>> _main()
> >>>>>>>>>>> [0000146e](01) 55 push ebp
> >>>>>>>>>>> [0000146f](02) 8bec mov ebp,esp
> >>>>>>>>>>> [00001471](05) 681e140000 push 0000141e
> >>>>>>>>>>> [00001476](05) 681e140000 push 0000141e
> >>>>>>>>>>> [0000147b](05) e8aefcffff call 0000112e
> >>>>>>>>>>> [00001480](03) 83c408 add esp,+08
> >>>>>>>>>>> [00001483](01) 50 push eax
> >>>>>>>>>>> [00001484](05) 685f050000 push 0000055f
> >>>>>>>>>>> [00001489](05) e820f1ffff call 000005ae
> >>>>>>>>>>> [0000148e](03) 83c408 add esp,+08
> >>>>>>>>>>> [00001491](02) 33c0 xor eax,eax
> >>>>>>>>>>> [00001493](01) 5d pop ebp
> >>>>>>>>>>> [00001494](01) c3 ret
> >>>>>>>>>>> Size in bytes:(0039) [00001494]
> >>>>>>>>>>>
> >>>>>>>>>>> machine stack stack machine assembly
> >>>>>>>>>>> address address data code language
> >>>>>>>>>>> ======== ======== ======== =========
> >>>>>>>>>>> ============= [0000146e][00102462][00000000] 55
> >>>>>>>>>>> push ebp [0000146f][00102462][00000000] 8bec mov
> >>>>>>>>>>> ebp,esp [00001471][0010245e][0000141e] 681e140000 push
> >>>>>>>>>>> 0000141e [00001476][0010245a][0000141e] 681e140000 push
> >>>>>>>>>>> 0000141e [0000147b][00102456][00001480] e8aefcffff call
> >>>>>>>>>>> 0000112e
> >>>>>>>>>>>
> >>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:11250e
> >>>>>>>>>>> Address_of_H:112e
> >>>>>>>>>>> [0000141e][001124fa][001124fe] 55 push ebp
> >>>>>>>>>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
> >>>>>>>>>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
> >>>>>>>>>>> [00001424][001124f2][90909090] a100000000 mov
> >>>>>>>>>>> eax,[00000000] [00001429][001124f2][90909090] 8945fc
> >>>>>>>>>>> mov [ebp-04],eax [0000142c][001124f2][90909090]
> >>>>>>>>>>> 8b0d00000000 mov ecx,[00000000]
> >>>>>>>>>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
> >>>>>>>>>>> [00001435][001124f2][90909090] 890d00000000 mov
> >>>>>>>>>>> [00000000],ecx [0000143b][001124f2][90909090] 837dfc02
> >>>>>>>>>>> cmp dword [ebp-04],+02 [0000143f][001124f2][90909090] 7c02
> >>>>>>>>>>> jl 00001443 [00001441][001124f2][90909090] eb1b
> >>>>>>>>>>> jmp 0000145e [0000145e][001124fa][001124fe] 8be5
> >>>>>>>>>>> mov esp,ebp [00001460][001124fe][00001217] 5d
> >>>>>>>>>>> pop ebp [00001461][00112502][0000141e] c3 ret
> >>>>>>>>>>> H: End Simulation Input Terminated Normally
> >>>>>>>>>>>
> >>>>>>>>>>> [00001480][00102462][00000000] 83c408 add esp,+08
> >>>>>>>>>>> [00001483][0010245e][00000001] 50 push eax
> >>>>>>>>>>> [00001484][0010245a][0000055f] 685f050000 push 0000055f
> >>>>>>>>>>> [00001489][0010245a][0000055f] e820f1ffff call 000005ae
> >>>>>>>>>>> Input_Halts = 1
> >>>>>>>>>>> [0000148e][00102462][00000000] 83c408 add esp,+08
> >>>>>>>>>>> [00001491][00102462][00000000] 33c0 xor eax,eax
> >>>>>>>>>>> [00001493][00102466][00000018] 5d pop ebp
> >>>>>>>>>>> [00001494][0010246a][00000000] c3 ret
> >>>>>>>>>>> Number of Instructions Executed(1317) == 20 Pages
> >>>>>>>>>>
> >>>>>>>>>> For this particular stack trace I notice that the function
> >>>>>>>>>> symbol at the top of it is Pm not P which suggests to me
> >>>>>>>>>> one of two things:
> >>>>>>>>>
> >>>>>>>>> I already had a P so I renamed it to Pm so it would not
> >>>>>>>>> disturb my existing code. When I changed all the Pm
> >>>>>>>>> references to your name I forgot one.
> >>>>>>>>
> >>>>>>>> Then I suggest you check the output of compilation/linking is
> >>>>>>>> actually initializing static variables correctly. Are you
> >>>>>>>> even using a linker or are you just executing an object file?
> >>>>>>>> Static data normally goes into a separate data segment during
> >>>>>>>> the linking process.
> >>>>>>>>
> >>>>>>>> /Flibble
> >>>>>>>>
> >>>>>>>
> >>>>>>> I haven't used static data in such a long time that I forgot
> >>>>>>> the compiler does not allocate any space for static variables
> >>>>>>> unless they have been initialized to a non-zero value.
> >>>>>>>
> >>>>>>> void Pm(u32 x)
> >>>>>>> {
> >>>>>>> static int count = 0x777;
> >>>>>>> if (count++ > 0x777) goto exit;
> >>>>>>> int Halt_Status = H(x, x);
> >>>>>>> if (Halt_Status)
> >>>>>>> HERE: goto HERE;
> >>>>>>> exit:
> >>>>>>> return;
> >>>>>>> }
> >>>>>>>
> >>>>>>> int main()
> >>>>>>> {
> >>>>>>> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
> >>>>>>> }
> >>>>>>>
> >>>>>>>
> >>>>>>> _Pm()
> >>>>>>> [00000a1a](01) 55 push ebp
> >>>>>>> [00000a1b](02) 8bec mov ebp,esp
> >>>>>>> [00000a1d](03) 83ec08 sub esp,+08
> >>>>>>> [00000a20](05) a107030000 mov eax,[00000307]
> >>>>>>> [00000a25](03) 8945fc mov [ebp-04],eax
> >>>>>>> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
> >>>>>>> [00000a2e](03) 83c101 add ecx,+01
> >>>>>>> [00000a31](06) 890d07030000 mov [00000307],ecx
> >>>>>>> [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>>>> [00000a3e](02) 7e02 jng 00000a42
> >>>>>>> [00000a40](02) eb1b jmp 00000a5d
> >>>>>>> [00000a42](03) 8b5508 mov edx,[ebp+08]
> >>>>>>> [00000a45](01) 52 push edx
> >>>>>>> [00000a46](03) 8b4508 mov eax,[ebp+08]
> >>>>>>> [00000a49](01) 50 push eax
> >>>>>>> [00000a4a](05) e8ebfdffff call 0000083a // call H
> >>>>>>> [00000a4f](03) 83c408 add esp,+08
> >>>>>>> [00000a52](03) 8945f8 mov [ebp-08],eax
> >>>>>>> [00000a55](04) 837df800 cmp dword [ebp-08],+00
> >>>>>>> [00000a59](02) 7402 jz 00000a5d
> >>>>>>> [00000a5b](02) ebfe jmp 00000a5b
> >>>>>>> [00000a5d](02) 8be5 mov esp,ebp
> >>>>>>> [00000a5f](01) 5d pop ebp
> >>>>>>> [00000a60](01) c3 ret
> >>>>>>> Size in bytes:(0071) [00000a60]
> >>>>>>>
> >>>>>>> _main()
> >>>>>>> [00000a6a](01) 55 push ebp
> >>>>>>> [00000a6b](02) 8bec mov ebp,esp
> >>>>>>> [00000a6d](05) 681a0a0000 push 00000a1a // push address
> >>>>>>> of P [00000a72](05) 681a0a0000 push 00000a1a // push
> >>>>>>> address of P [00000a77](05) e8befdffff call 0000083a //
> >>>>>>> call H [00000a7c](03) 83c408 add esp,+08
> >>>>>>> [00000a7f](01) 50 push eax
> >>>>>>> [00000a80](05) 680b030000 push 0000030b
> >>>>>>> [00000a85](05) e8d0f8ffff call 0000035a
> >>>>>>> [00000a8a](03) 83c408 add esp,+08
> >>>>>>> [00000a8d](02) 33c0 xor eax,eax
> >>>>>>> [00000a8f](01) 5d pop ebp
> >>>>>>> [00000a90](01) c3 ret
> >>>>>>> Size in bytes:(0039) [00000a90]
> >>>>>>>
> >>>>>>> machine stack stack machine assembly
> >>>>>>> address address data code language
> >>>>>>> ======== ======== ======== ========= =============
> >>>>>>> ...[00000a6a][0010137b][00000000] 55 push ebp
> >>>>>>> ...[00000a6b][0010137b][00000000] 8bec mov ebp,esp
> >>>>>>> ...[00000a6d][00101377][00000a1a] 681a0a0000 push
> >>>>>>> 00000a1a ...[00000a72][00101373][00000a1a] 681a0a0000
> >>>>>>> push 00000a1a ...[00000a77][0010136f][00000a7c] e8befdffff
> >>>>>>> call 0000083a New slave_stack at:201427
> >>>>>>>
> >>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
> >>>>>>> at:21142f ...[00000a1a][0021141b][0021141f] 55
> >>>>>>> push ebp ...[00000a1b][0021141b][0021141f] 8bec mov
> >>>>>>> ebp,esp ...[00000a1d][00211413][90909090] 83ec08 sub
> >>>>>>> esp,+08 ...[00000a20][00211413][90909090] a107030000 mov
> >>>>>>> eax,[00000307] ...[00000a25][00211413][90909090] 8945fc
> >>>>>>> mov [ebp-04],eax ...[00000a28][00211413][90909090]
> >>>>>>> 8b0d07030000 mov ecx,[00000307]
> >>>>>>> ...[00000a2e][00211413][90909090] 83c101 add ecx,+01
> >>>>>>> ...[00000a31][00211413][90909090] 890d07030000 mov
> >>>>>>> [00000307],ecx ...[00000a37][00211413][90909090]
> >>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>>>> ...[00000a3e][00211413][90909090] 7e02 jng
> >>>>>>> 00000a42 ...[00000a42][00211413][90909090] 8b5508
> >>>>>>> mov edx,[ebp+08] ...[00000a45][0021140f][00000a1a] 52 push
> >>>>>>> edx // push address of P
> >>>>>>> ...[00000a46][0021140f][00000a1a] 8b4508 mov
> >>>>>>> eax,[ebp+08] ...[00000a49][0021140b][00000a1a] 50 push eax
> >>>>>>> // push address of P ...[00000a4a][00211407][00000a4f]
> >>>>>>> e8ebfdffff call 0000083a // call H New slave_stack
> >>>>>>> at:24be4f ...[00000a1a][0025be43][0025be47] 55
> >>>>>>> push ebp ...[00000a1b][0025be43][0025be47] 8bec
> >>>>>>> mov ebp,esp ...[00000a1d][0025be3b][90909090] 83ec08
> >>>>>>> sub esp,+08 ...[00000a20][0025be3b][90909090] a107030000
> >>>>>>> mov eax,[00000307] ...[00000a25][0025be3b][90909090] 8945fc
> >>>>>>> mov [ebp-04],eax ...[00000a28][0025be3b][90909090]
> >>>>>>> 8b0d07030000 mov ecx,[00000307]
> >>>>>>> ...[00000a2e][0025be3b][90909090] 83c101 add ecx,+01
> >>>>>>> ...[00000a31][0025be3b][90909090] 890d07030000 mov
> >>>>>>> [00000307],ecx ...[00000a37][0025be3b][90909090]
> >>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>>>> ...[00000a3e][0025be3b][90909090] 7e02 jng
> >>>>>>> 00000a42 ...[00000a40][0025be3b][90909090] eb1b
> >>>>>>> jmp 00000a5d // jmp to exit ...[00000a5d][0025be43][0025be47]
> >>>>>>> 8be5 mov esp,ebp ...[00000a5f][0025be47][00000904]
> >>>>>>> 5d pop ebp ...[00000a60][0025be4b][00000a1a] c3
> >>>>>>> ret ...[00000a7c][0010137b][00000000] 83c408
> >>>>>>> add esp,+08 ...[00000a7f][00101377][00000001] 50
> >>>>>>> push eax ...[00000a80][00101373][0000030b] 680b030000
> >>>>>>> push 0000030b ---[00000a85][00101373][0000030b] e8d0f8ffff
> >>>>>>> call 0000035a Input_Halts = 1
> >>>>>>> ...[00000a8a][0010137b][00000000] 83c408 add esp,+08
> >>>>>>> ...[00000a8d][0010137b][00000000] 33c0 xor eax,eax
> >>>>>>> ...[00000a8f][0010137f][00100000] 5d pop ebp
> >>>>>>> ...[00000a90][00101383][00000004] c3 ret
> >>>>>>> Number of Instructions Executed(27278)
> >>>>>>>
> >>>>>>>
> >>>>>>
> >>>>>> Still seems wrong: post increment of the static variable should
> >>>>>> ensure that it does NOT goto exit but instead should call H
> >>>>>> which should presumably cause your "infinite recursion
> >>>>>> detected" bollocks to manifest.
> >>>>>
> >>>>> OK, I've looked at your assembly trace and it is recursing into
> >>>>> Pm from H and then halting but I am not sure what you are
> >>>>> trying to prove? Again [Strachey 1965] and associated proofs
> >>>>> are not recursive in nature.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> (1) H cannot correctly determine the halt status of the HP
> >>>> counter-examples unless H is a simulating halt decider.
> >>>>
> >>>> (2) The claim of the halting problem proofs is that no H in the
> >>>> universe can possibly correctly determine the halt status of its
> >>>> corresponding pathological input.
> >>>>
> >>>> (3) H(P,P) does correctly determine that its correponding
> >>>> pathological input would never halt.
> >>>>
> >>>> (4) It is ridiculously stupid of you to say that [Strachey 1965]
> >>>> does not specify infinitely recursive simulation when it is an
> >>>> easily verified fact that when Strachey T <is> a simulating halt
> >>>> decider that Strachey P <does> specify infinitely recursive
> >>>> simulation.
> >>>>
> >>>> It does not say this directly in [Strachey 1965] only because no
> >>>> one ever previously bothered to fully examine the effect of a
> >>>> simulating halt decider on the HP's pathological inputs.
> >>>
> >>> I see I have to repeat myself yet again: a simulating halt decider
> >>> needn't be recursive in nature and I have sketched a design of
> >>> such a halt decider:
> >>>
> >>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>
> >>> You are incorrect to claim an equivalence between pathological
> >>> input and non-halting.
> >>>
> >>> /Flibble
> >>>
> >>>
> >>
> >> 19 When the simulator detects the call to H in P it forks the
> >> simulation 20 into a non-halting branch (returning 0 to P) and a
> >> halting branch 21 (returning 1 to P)
> >>
> >> Software engineers at the low end of technical competence may not
> >> fully comprehend the common knowledge that:
> >>
> >> Whenever a function is called in what is essentially infinite
> >> recursion this function cannot possibly correctly return any value
> >> to its caller. You don't seem to understand that.
> >
> > Why are you so fucking obtuse? My forking simulating decider IS NOT
> > RECURSIVE.
>
> It is directly disobeying the actual behavior specified by the actual
> input by returning a value to a function that called it in infinite
> recursion.
There is no infinite recursion in [Strachey 1965]. There is no infinite
recursion in the proofs based on [Strachey 1965]. There is no infinite
recursion in my forking simulating decider. The only infinite recursion
is that infinite recursion associated with your broken decider.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2022-07-15 13:34 -0500 |
| Message-ID | <XqqdnZSta5rZLkz_nZ2dnUU7_8xg4p2d@giganews.com> |
| In reply to | #85262 |
On 7/15/2022 1:23 PM, Mr Flibble wrote:
> On Fri, 15 Jul 2022 13:17:37 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/15/2022 1:04 PM, Mr Flibble wrote:
>>> On Fri, 15 Jul 2022 12:57:53 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 7/15/2022 12:46 PM, Mr Flibble wrote:
>>>>> On Fri, 15 Jul 2022 12:39:31 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 7/15/2022 12:28 PM, Mr Flibble wrote:
>>>>>>> On Fri, 15 Jul 2022 18:08:22 +0100
>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
>>>>>>>
>>>>>>>> On Fri, 15 Jul 2022 12:00:59 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>
>>>>>>>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 15 Jul 2022 10:58:14 -0500
>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>
>>>>>>>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
>>>>>>>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
>>>>>>>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This is an explanation of a key new insight
>>>>>>>>>>>>>>>>>>>>>>>>> into the halting problem provided in the
>>>>>>>>>>>>>>>>>>>>>>>>> language of software engineering. Technical
>>>>>>>>>>>>>>>>>>>>>>>>> computer science terms are explained using
>>>>>>>>>>>>>>>>>>>>>>>>> software engineering terms. No knowledge of
>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem is required.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> It is based on fully operational software
>>>>>>>>>>>>>>>>>>>>>>>>> executed in the x86utm operating system. The
>>>>>>>>>>>>>>>>>>>>>>>>> x86utm operating system (based on an excellent
>>>>>>>>>>>>>>>>>>>>>>>>> open source x86 emulator) was created to study
>>>>>>>>>>>>>>>>>>>>>>>>> the details of the halting problem proof
>>>>>>>>>>>>>>>>>>>>>>>>> counter-examples at the much higher level of
>>>>>>>>>>>>>>>>>>>>>>>>> abstraction of C/x86.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P,
>>>>>>>>>>>>>>>>>>>>>>>>> P)); }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P) simulates
>>>>>>>>>>>>>>>>>>>>>>>>> its input we can see that: (1) Function H() is
>>>>>>>>>>>>>>>>>>>>>>>>> called from P(). (2) With the same arguments
>>>>>>>>>>>>>>>>>>>>>>>>> to H(). (3) With no instructions in P
>>>>>>>>>>>>>>>>>>>>>>>>> preceding its invocation of H(P,P).
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The above shows that the simulated P cannot
>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. Because H can see
>>>>>>>>>>>>>>>>>>>>>>>>> the same (1)(2)(3) that we see H aborts its
>>>>>>>>>>>>>>>>>>>>>>>>> simulation of P and rejects P as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> In computability theory, the
>>>>>>>>>>>>>>>>>>>>>>>>> halting problem is the problem of determining,
>>>>>>>>>>>>>>>>>>>>>>>>> from a description of an arbitrary computer
>>>>>>>>>>>>>>>>>>>>>>>>> program and an input, whether the program will
>>>>>>>>>>>>>>>>>>>>>>>>> finish running, or continue to run forever.
>>>>>>>>>>>>>>>>>>>>>>>>> Alan Turing proved in 1936 that a general
>>>>>>>>>>>>>>>>>>>>>>>>> algorithm to solve the halting problem for
>>>>>>>>>>>>>>>>>>>>>>>>> all possible program- input pairs cannot
>>>>>>>>>>>>>>>>>>>>>>>>> exist.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> For any program H that might
>>>>>>>>>>>>>>>>>>>>>>>>> determine if programs halt, a "pathological"
>>>>>>>>>>>>>>>>>>>>>>>>> program P, called with some input, can pass
>>>>>>>>>>>>>>>>>>>>>>>>> its own source and its input to H and then
>>>>>>>>>>>>>>>>>>>>>>>>> specifically do the opposite of what H
>>>>>>>>>>>>>>>>>>>>>>>>> predicts P will do. No H can exist that
>>>>>>>>>>>>>>>>>>>>>>>>> handles this case.
>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
>>>>>>>>>>>>>>>>>>>>>>>>> relationship to each other as described above.
>>>>>>>>>>>>>>>>>>>>>>>>> Because H(P,P) does handle this case the above
>>>>>>>>>>>>>>>>>>>>>>>>> halting problem undecidable input template has
>>>>>>>>>>>>>>>>>>>>>>>>> been refuted.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *When this halt deciding principle understood
>>>>>>>>>>>>>>>>>>>>>>>>> to be correct* A halt decider must compute the
>>>>>>>>>>>>>>>>>>>>>>>>> mapping from its inputs to an accept or reject
>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior that
>>>>>>>>>>>>>>>>>>>>>>>>> is actually specified by these inputs.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this implements
>>>>>>>>>>>>>>>>>>>>>>>>> that principle* Every simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>> that correctly simulates its input until it
>>>>>>>>>>>>>>>>>>>>>>>>> correctly predicts that this simulated input
>>>>>>>>>>>>>>>>>>>>>>>>> would never terminate normally, correctly
>>>>>>>>>>>>>>>>>>>>>>>>> rejects this input as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *H is a Pure function*
>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the basis
>>>>>>>>>>>>>>>>>>>>>>>>> of software engineering*
>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion which
>>>>>>>>>>>>>>>>>>>>>>>> I suppose is progress.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I have shown that H/P does implement the HP's
>>>>>>>>>>>>>>>>>>>>>>> "impossible input" template.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting
>>>>>>>>>>>>>>>>>>>>>>> problem proofs that rely on this template.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Equating pathological input with non-halting is
>>>>>>>>>>>>>>>>>>>>>> erroneous: you are only doing that because your
>>>>>>>>>>>>>>>>>>>>>> broken solution treats it as "infinite
>>>>>>>>>>>>>>>>>>>>>> recursion". There is no recursion in [Strachey
>>>>>>>>>>>>>>>>>>>>>> 1965] and the HP proofs based on it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> There is no recursion in any of the conventional
>>>>>>>>>>>>>>>>>>>>> proofs only because no one ever previously
>>>>>>>>>>>>>>>>>>>>> bothered to fully examine how a simulating halt
>>>>>>>>>>>>>>>>>>>>> decider would address these otherwise
>>>>>>>>>>>>>>>>>>>>> "impossible" inputs.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I have shown that a simulating halt decider needn't
>>>>>>>>>>>>>>>>>>>> be recursive in nature:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You sure do make it easy to review your work.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> "When the simulator detects the call to H
>>>>>>>>>>>>>>>>>>> in P it forks the simulation into a non-halting
>>>>>>>>>>>>>>>>>>> branch"
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> There is an infinite set of cases where this overly
>>>>>>>>>>>>>>>>>>> simplistic criteria gets the wrong answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That is neither an honest review or any kind of
>>>>>>>>>>>>>>>>>> rebuttal: I have told you before: assertions made
>>>>>>>>>>>>>>>>>> without evidence can be dismissed without evidence.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If you claim there are an infinite number of cases
>>>>>>>>>>>>>>>>>> where it gets the wrong answer then it shouldn't be
>>>>>>>>>>>>>>>>>> too hard for to provide ONE case backing up your
>>>>>>>>>>>>>>>>>> claim.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Sure:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> static int count = 3;
>>>>>>>>>>>>>>>>> count--;
>>>>>>>>>>>>>>>>> if (!count) goto exit;
>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>> exit:
>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope; you seem to have forgotten that my decider is not
>>>>>>>>>>>>>>>> recursive in nature: my decider will correctly
>>>>>>>>>>>>>>>> determine that that input is pathological so will
>>>>>>>>>>>>>>>> signal an exception.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The above terminates normally so your decider gets the
>>>>>>>>>>>>>>> wrong answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is a pathological input so neither halts nor doesn't
>>>>>>>>>>>>>> halt: pathological input is INVALID so the correct
>>>>>>>>>>>>>> "answer" is to signal an exception.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> So you don't know how static variables work?
>>>>>>>>>>>>> I am not surprised.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>> {
>>>>>>>>>>>>> static int count = 0;
>>>>>>>>>>>>> if (count++ >= 2) goto exit;
>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>> exit:
>>>>>>>>>>>>> return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> Output("Input_Halts = ", H(P,P));
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> _Pm()
>>>>>>>>>>>>> [0000141e](01) 55 push ebp
>>>>>>>>>>>>> [0000141f](02) 8bec mov ebp,esp
>>>>>>>>>>>>> [00001421](03) 83ec08 sub esp,+08
>>>>>>>>>>>>> [00001424](05) a100000000 mov eax,[00000000]
>>>>>>>>>>>>> [00001429](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
>>>>>>>>>>>>> [00001432](03) 83c101 add ecx,+01
>>>>>>>>>>>>> [00001435](06) 890d00000000 mov [00000000],ecx
>>>>>>>>>>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
>>>>>>>>>>>>> [0000143f](02) 7c02 jl 00001443
>>>>>>>>>>>>> [00001441](02) eb1b jmp 0000145e
>>>>>>>>>>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
>>>>>>>>>>>>> [00001446](01) 52 push edx
>>>>>>>>>>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>> [0000144a](01) 50 push eax
>>>>>>>>>>>>> [0000144b](05) e8defcffff call 0000112e
>>>>>>>>>>>>> [00001450](03) 83c408 add esp,+08
>>>>>>>>>>>>> [00001453](03) 8945f8 mov [ebp-08],eax
>>>>>>>>>>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
>>>>>>>>>>>>> [0000145a](02) 7402 jz 0000145e
>>>>>>>>>>>>> [0000145c](02) ebfe jmp 0000145c
>>>>>>>>>>>>> [0000145e](02) 8be5 mov esp,ebp
>>>>>>>>>>>>> [00001460](01) 5d pop ebp
>>>>>>>>>>>>> [00001461](01) c3 ret
>>>>>>>>>>>>> Size in bytes:(0068) [00001461]
>>>>>>>>>>>>>
>>>>>>>>>>>>> _main()
>>>>>>>>>>>>> [0000146e](01) 55 push ebp
>>>>>>>>>>>>> [0000146f](02) 8bec mov ebp,esp
>>>>>>>>>>>>> [00001471](05) 681e140000 push 0000141e
>>>>>>>>>>>>> [00001476](05) 681e140000 push 0000141e
>>>>>>>>>>>>> [0000147b](05) e8aefcffff call 0000112e
>>>>>>>>>>>>> [00001480](03) 83c408 add esp,+08
>>>>>>>>>>>>> [00001483](01) 50 push eax
>>>>>>>>>>>>> [00001484](05) 685f050000 push 0000055f
>>>>>>>>>>>>> [00001489](05) e820f1ffff call 000005ae
>>>>>>>>>>>>> [0000148e](03) 83c408 add esp,+08
>>>>>>>>>>>>> [00001491](02) 33c0 xor eax,eax
>>>>>>>>>>>>> [00001493](01) 5d pop ebp
>>>>>>>>>>>>> [00001494](01) c3 ret
>>>>>>>>>>>>> Size in bytes:(0039) [00001494]
>>>>>>>>>>>>>
>>>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>>>> address address data code language
>>>>>>>>>>>>> ======== ======== ======== =========
>>>>>>>>>>>>> ============= [0000146e][00102462][00000000] 55
>>>>>>>>>>>>> push ebp [0000146f][00102462][00000000] 8bec mov
>>>>>>>>>>>>> ebp,esp [00001471][0010245e][0000141e] 681e140000 push
>>>>>>>>>>>>> 0000141e [00001476][0010245a][0000141e] 681e140000 push
>>>>>>>>>>>>> 0000141e [0000147b][00102456][00001480] e8aefcffff call
>>>>>>>>>>>>> 0000112e
>>>>>>>>>>>>>
>>>>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:11250e
>>>>>>>>>>>>> Address_of_H:112e
>>>>>>>>>>>>> [0000141e][001124fa][001124fe] 55 push ebp
>>>>>>>>>>>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
>>>>>>>>>>>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
>>>>>>>>>>>>> [00001424][001124f2][90909090] a100000000 mov
>>>>>>>>>>>>> eax,[00000000] [00001429][001124f2][90909090] 8945fc
>>>>>>>>>>>>> mov [ebp-04],eax [0000142c][001124f2][90909090]
>>>>>>>>>>>>> 8b0d00000000 mov ecx,[00000000]
>>>>>>>>>>>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
>>>>>>>>>>>>> [00001435][001124f2][90909090] 890d00000000 mov
>>>>>>>>>>>>> [00000000],ecx [0000143b][001124f2][90909090] 837dfc02
>>>>>>>>>>>>> cmp dword [ebp-04],+02 [0000143f][001124f2][90909090] 7c02
>>>>>>>>>>>>> jl 00001443 [00001441][001124f2][90909090] eb1b
>>>>>>>>>>>>> jmp 0000145e [0000145e][001124fa][001124fe] 8be5
>>>>>>>>>>>>> mov esp,ebp [00001460][001124fe][00001217] 5d
>>>>>>>>>>>>> pop ebp [00001461][00112502][0000141e] c3 ret
>>>>>>>>>>>>> H: End Simulation Input Terminated Normally
>>>>>>>>>>>>>
>>>>>>>>>>>>> [00001480][00102462][00000000] 83c408 add esp,+08
>>>>>>>>>>>>> [00001483][0010245e][00000001] 50 push eax
>>>>>>>>>>>>> [00001484][0010245a][0000055f] 685f050000 push 0000055f
>>>>>>>>>>>>> [00001489][0010245a][0000055f] e820f1ffff call 000005ae
>>>>>>>>>>>>> Input_Halts = 1
>>>>>>>>>>>>> [0000148e][00102462][00000000] 83c408 add esp,+08
>>>>>>>>>>>>> [00001491][00102462][00000000] 33c0 xor eax,eax
>>>>>>>>>>>>> [00001493][00102466][00000018] 5d pop ebp
>>>>>>>>>>>>> [00001494][0010246a][00000000] c3 ret
>>>>>>>>>>>>> Number of Instructions Executed(1317) == 20 Pages
>>>>>>>>>>>>
>>>>>>>>>>>> For this particular stack trace I notice that the function
>>>>>>>>>>>> symbol at the top of it is Pm not P which suggests to me
>>>>>>>>>>>> one of two things:
>>>>>>>>>>>
>>>>>>>>>>> I already had a P so I renamed it to Pm so it would not
>>>>>>>>>>> disturb my existing code. When I changed all the Pm
>>>>>>>>>>> references to your name I forgot one.
>>>>>>>>>>
>>>>>>>>>> Then I suggest you check the output of compilation/linking is
>>>>>>>>>> actually initializing static variables correctly. Are you
>>>>>>>>>> even using a linker or are you just executing an object file?
>>>>>>>>>> Static data normally goes into a separate data segment during
>>>>>>>>>> the linking process.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I haven't used static data in such a long time that I forgot
>>>>>>>>> the compiler does not allocate any space for static variables
>>>>>>>>> unless they have been initialized to a non-zero value.
>>>>>>>>>
>>>>>>>>> void Pm(u32 x)
>>>>>>>>> {
>>>>>>>>> static int count = 0x777;
>>>>>>>>> if (count++ > 0x777) goto exit;
>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>> if (Halt_Status)
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> exit:
>>>>>>>>> return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> _Pm()
>>>>>>>>> [00000a1a](01) 55 push ebp
>>>>>>>>> [00000a1b](02) 8bec mov ebp,esp
>>>>>>>>> [00000a1d](03) 83ec08 sub esp,+08
>>>>>>>>> [00000a20](05) a107030000 mov eax,[00000307]
>>>>>>>>> [00000a25](03) 8945fc mov [ebp-04],eax
>>>>>>>>> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
>>>>>>>>> [00000a2e](03) 83c101 add ecx,+01
>>>>>>>>> [00000a31](06) 890d07030000 mov [00000307],ecx
>>>>>>>>> [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>>>> [00000a3e](02) 7e02 jng 00000a42
>>>>>>>>> [00000a40](02) eb1b jmp 00000a5d
>>>>>>>>> [00000a42](03) 8b5508 mov edx,[ebp+08]
>>>>>>>>> [00000a45](01) 52 push edx
>>>>>>>>> [00000a46](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>> [00000a49](01) 50 push eax
>>>>>>>>> [00000a4a](05) e8ebfdffff call 0000083a // call H
>>>>>>>>> [00000a4f](03) 83c408 add esp,+08
>>>>>>>>> [00000a52](03) 8945f8 mov [ebp-08],eax
>>>>>>>>> [00000a55](04) 837df800 cmp dword [ebp-08],+00
>>>>>>>>> [00000a59](02) 7402 jz 00000a5d
>>>>>>>>> [00000a5b](02) ebfe jmp 00000a5b
>>>>>>>>> [00000a5d](02) 8be5 mov esp,ebp
>>>>>>>>> [00000a5f](01) 5d pop ebp
>>>>>>>>> [00000a60](01) c3 ret
>>>>>>>>> Size in bytes:(0071) [00000a60]
>>>>>>>>>
>>>>>>>>> _main()
>>>>>>>>> [00000a6a](01) 55 push ebp
>>>>>>>>> [00000a6b](02) 8bec mov ebp,esp
>>>>>>>>> [00000a6d](05) 681a0a0000 push 00000a1a // push address
>>>>>>>>> of P [00000a72](05) 681a0a0000 push 00000a1a // push
>>>>>>>>> address of P [00000a77](05) e8befdffff call 0000083a //
>>>>>>>>> call H [00000a7c](03) 83c408 add esp,+08
>>>>>>>>> [00000a7f](01) 50 push eax
>>>>>>>>> [00000a80](05) 680b030000 push 0000030b
>>>>>>>>> [00000a85](05) e8d0f8ffff call 0000035a
>>>>>>>>> [00000a8a](03) 83c408 add esp,+08
>>>>>>>>> [00000a8d](02) 33c0 xor eax,eax
>>>>>>>>> [00000a8f](01) 5d pop ebp
>>>>>>>>> [00000a90](01) c3 ret
>>>>>>>>> Size in bytes:(0039) [00000a90]
>>>>>>>>>
>>>>>>>>> machine stack stack machine assembly
>>>>>>>>> address address data code language
>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>> ...[00000a6a][0010137b][00000000] 55 push ebp
>>>>>>>>> ...[00000a6b][0010137b][00000000] 8bec mov ebp,esp
>>>>>>>>> ...[00000a6d][00101377][00000a1a] 681a0a0000 push
>>>>>>>>> 00000a1a ...[00000a72][00101373][00000a1a] 681a0a0000
>>>>>>>>> push 00000a1a ...[00000a77][0010136f][00000a7c] e8befdffff
>>>>>>>>> call 0000083a New slave_stack at:201427
>>>>>>>>>
>>>>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>>>>>>>> at:21142f ...[00000a1a][0021141b][0021141f] 55
>>>>>>>>> push ebp ...[00000a1b][0021141b][0021141f] 8bec mov
>>>>>>>>> ebp,esp ...[00000a1d][00211413][90909090] 83ec08 sub
>>>>>>>>> esp,+08 ...[00000a20][00211413][90909090] a107030000 mov
>>>>>>>>> eax,[00000307] ...[00000a25][00211413][90909090] 8945fc
>>>>>>>>> mov [ebp-04],eax ...[00000a28][00211413][90909090]
>>>>>>>>> 8b0d07030000 mov ecx,[00000307]
>>>>>>>>> ...[00000a2e][00211413][90909090] 83c101 add ecx,+01
>>>>>>>>> ...[00000a31][00211413][90909090] 890d07030000 mov
>>>>>>>>> [00000307],ecx ...[00000a37][00211413][90909090]
>>>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>>>> ...[00000a3e][00211413][90909090] 7e02 jng
>>>>>>>>> 00000a42 ...[00000a42][00211413][90909090] 8b5508
>>>>>>>>> mov edx,[ebp+08] ...[00000a45][0021140f][00000a1a] 52 push
>>>>>>>>> edx // push address of P
>>>>>>>>> ...[00000a46][0021140f][00000a1a] 8b4508 mov
>>>>>>>>> eax,[ebp+08] ...[00000a49][0021140b][00000a1a] 50 push eax
>>>>>>>>> // push address of P ...[00000a4a][00211407][00000a4f]
>>>>>>>>> e8ebfdffff call 0000083a // call H New slave_stack
>>>>>>>>> at:24be4f ...[00000a1a][0025be43][0025be47] 55
>>>>>>>>> push ebp ...[00000a1b][0025be43][0025be47] 8bec
>>>>>>>>> mov ebp,esp ...[00000a1d][0025be3b][90909090] 83ec08
>>>>>>>>> sub esp,+08 ...[00000a20][0025be3b][90909090] a107030000
>>>>>>>>> mov eax,[00000307] ...[00000a25][0025be3b][90909090] 8945fc
>>>>>>>>> mov [ebp-04],eax ...[00000a28][0025be3b][90909090]
>>>>>>>>> 8b0d07030000 mov ecx,[00000307]
>>>>>>>>> ...[00000a2e][0025be3b][90909090] 83c101 add ecx,+01
>>>>>>>>> ...[00000a31][0025be3b][90909090] 890d07030000 mov
>>>>>>>>> [00000307],ecx ...[00000a37][0025be3b][90909090]
>>>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>>>> ...[00000a3e][0025be3b][90909090] 7e02 jng
>>>>>>>>> 00000a42 ...[00000a40][0025be3b][90909090] eb1b
>>>>>>>>> jmp 00000a5d // jmp to exit ...[00000a5d][0025be43][0025be47]
>>>>>>>>> 8be5 mov esp,ebp ...[00000a5f][0025be47][00000904]
>>>>>>>>> 5d pop ebp ...[00000a60][0025be4b][00000a1a] c3
>>>>>>>>> ret ...[00000a7c][0010137b][00000000] 83c408
>>>>>>>>> add esp,+08 ...[00000a7f][00101377][00000001] 50
>>>>>>>>> push eax ...[00000a80][00101373][0000030b] 680b030000
>>>>>>>>> push 0000030b ---[00000a85][00101373][0000030b] e8d0f8ffff
>>>>>>>>> call 0000035a Input_Halts = 1
>>>>>>>>> ...[00000a8a][0010137b][00000000] 83c408 add esp,+08
>>>>>>>>> ...[00000a8d][0010137b][00000000] 33c0 xor eax,eax
>>>>>>>>> ...[00000a8f][0010137f][00100000] 5d pop ebp
>>>>>>>>> ...[00000a90][00101383][00000004] c3 ret
>>>>>>>>> Number of Instructions Executed(27278)
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Still seems wrong: post increment of the static variable should
>>>>>>>> ensure that it does NOT goto exit but instead should call H
>>>>>>>> which should presumably cause your "infinite recursion
>>>>>>>> detected" bollocks to manifest.
>>>>>>>
>>>>>>> OK, I've looked at your assembly trace and it is recursing into
>>>>>>> Pm from H and then halting but I am not sure what you are
>>>>>>> trying to prove? Again [Strachey 1965] and associated proofs
>>>>>>> are not recursive in nature.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> (1) H cannot correctly determine the halt status of the HP
>>>>>> counter-examples unless H is a simulating halt decider.
>>>>>>
>>>>>> (2) The claim of the halting problem proofs is that no H in the
>>>>>> universe can possibly correctly determine the halt status of its
>>>>>> corresponding pathological input.
>>>>>>
>>>>>> (3) H(P,P) does correctly determine that its correponding
>>>>>> pathological input would never halt.
>>>>>>
>>>>>> (4) It is ridiculously stupid of you to say that [Strachey 1965]
>>>>>> does not specify infinitely recursive simulation when it is an
>>>>>> easily verified fact that when Strachey T <is> a simulating halt
>>>>>> decider that Strachey P <does> specify infinitely recursive
>>>>>> simulation.
>>>>>>
>>>>>> It does not say this directly in [Strachey 1965] only because no
>>>>>> one ever previously bothered to fully examine the effect of a
>>>>>> simulating halt decider on the HP's pathological inputs.
>>>>>
>>>>> I see I have to repeat myself yet again: a simulating halt decider
>>>>> needn't be recursive in nature and I have sketched a design of
>>>>> such a halt decider:
>>>>>
>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>>
>>>>> You are incorrect to claim an equivalence between pathological
>>>>> input and non-halting.
>>>>>
>>>>> /Flibble
>>>>>
>>>>>
>>>>
>>>> 19 When the simulator detects the call to H in P it forks the
>>>> simulation 20 into a non-halting branch (returning 0 to P) and a
>>>> halting branch 21 (returning 1 to P)
>>>>
>>>> Software engineers at the low end of technical competence may not
>>>> fully comprehend the common knowledge that:
>>>>
>>>> Whenever a function is called in what is essentially infinite
>>>> recursion this function cannot possibly correctly return any value
>>>> to its caller. You don't seem to understand that.
>>>
>>> Why are you so fucking obtuse? My forking simulating decider IS NOT
>>> RECURSIVE.
>>
>> It is directly disobeying the actual behavior specified by the actual
>> input by returning a value to a function that called it in infinite
>> recursion.
>
> There is no infinite recursion in [Strachey 1965]. There is no infinite
> recursion in the proofs based on [Strachey 1965]. There is no infinite
> recursion in my forking simulating decider. The only infinite recursion
> is that infinite recursion associated with your broken decider.
>
> /Flibble
>
>
The pathological input ([Strachey 1965] and others) to every simulating
halt decider specifies infinitely nested simulution to every simulating
halt decider.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-07-15 19:46 +0100 |
| Message-ID | <20220715194649.00007759@reddwarf.jmc.corp> |
| In reply to | #85264 |
On Fri, 15 Jul 2022 13:34:43 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/15/2022 1:23 PM, Mr Flibble wrote:
> > On Fri, 15 Jul 2022 13:17:37 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 7/15/2022 1:04 PM, Mr Flibble wrote:
> >>> On Fri, 15 Jul 2022 12:57:53 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 7/15/2022 12:46 PM, Mr Flibble wrote:
> >>>>> On Fri, 15 Jul 2022 12:39:31 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 7/15/2022 12:28 PM, Mr Flibble wrote:
> >>>>>>> On Fri, 15 Jul 2022 18:08:22 +0100
> >>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
> >>>>>>>
> >>>>>>>> On Fri, 15 Jul 2022 12:00:59 -0500
> >>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>
> >>>>>>>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
> >>>>>>>>>> On Fri, 15 Jul 2022 10:58:14 -0500
> >>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>
> >>>>>>>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
> >>>>>>>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
> >>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>
> >>>>>>>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
> >>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
> >>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
> >>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
> >>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
> >>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
> >>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> This is an explanation of a key new insight
> >>>>>>>>>>>>>>>>>>>>>>>>> into the halting problem provided in the
> >>>>>>>>>>>>>>>>>>>>>>>>> language of software engineering. Technical
> >>>>>>>>>>>>>>>>>>>>>>>>> computer science terms are explained using
> >>>>>>>>>>>>>>>>>>>>>>>>> software engineering terms. No knowledge of
> >>>>>>>>>>>>>>>>>>>>>>>>> the halting problem is required.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> It is based on fully operational software
> >>>>>>>>>>>>>>>>>>>>>>>>> executed in the x86utm operating system. The
> >>>>>>>>>>>>>>>>>>>>>>>>> x86utm operating system (based on an
> >>>>>>>>>>>>>>>>>>>>>>>>> excellent open source x86 emulator) was
> >>>>>>>>>>>>>>>>>>>>>>>>> created to study the details of the halting
> >>>>>>>>>>>>>>>>>>>>>>>>> problem proof counter-examples at the much
> >>>>>>>>>>>>>>>>>>>>>>>>> higher level of abstraction of C/x86.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt
> >>>>>>>>>>>>>>>>>>>>>>>>> decider
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P,
> >>>>>>>>>>>>>>>>>>>>>>>>> P)); }
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>> simulates its input we can see that: (1)
> >>>>>>>>>>>>>>>>>>>>>>>>> Function H() is called from P(). (2) With
> >>>>>>>>>>>>>>>>>>>>>>>>> the same arguments to H(). (3) With no
> >>>>>>>>>>>>>>>>>>>>>>>>> instructions in P preceding its invocation
> >>>>>>>>>>>>>>>>>>>>>>>>> of H(P,P).
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> The above shows that the simulated P cannot
> >>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. Because H can
> >>>>>>>>>>>>>>>>>>>>>>>>> see the same (1)(2)(3) that we see H aborts
> >>>>>>>>>>>>>>>>>>>>>>>>> its simulation of P and rejects P as
> >>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> In computability theory,
> >>>>>>>>>>>>>>>>>>>>>>>>> the halting problem is the problem of
> >>>>>>>>>>>>>>>>>>>>>>>>> determining, from a description of an
> >>>>>>>>>>>>>>>>>>>>>>>>> arbitrary computer program and an input,
> >>>>>>>>>>>>>>>>>>>>>>>>> whether the program will finish running, or
> >>>>>>>>>>>>>>>>>>>>>>>>> continue to run forever. Alan Turing proved
> >>>>>>>>>>>>>>>>>>>>>>>>> in 1936 that a general algorithm to solve
> >>>>>>>>>>>>>>>>>>>>>>>>> the halting problem for all possible
> >>>>>>>>>>>>>>>>>>>>>>>>> program- input pairs cannot exist.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> For any program H that
> >>>>>>>>>>>>>>>>>>>>>>>>> might determine if programs halt, a
> >>>>>>>>>>>>>>>>>>>>>>>>> "pathological" program P, called with some
> >>>>>>>>>>>>>>>>>>>>>>>>> input, can pass its own source and its
> >>>>>>>>>>>>>>>>>>>>>>>>> input to H and then specifically do the
> >>>>>>>>>>>>>>>>>>>>>>>>> opposite of what H predicts P will do. No H
> >>>>>>>>>>>>>>>>>>>>>>>>> can exist that handles this case.
> >>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
> >>>>>>>>>>>>>>>>>>>>>>>>> relationship to each other as described
> >>>>>>>>>>>>>>>>>>>>>>>>> above. Because H(P,P) does handle this case
> >>>>>>>>>>>>>>>>>>>>>>>>> the above halting problem undecidable input
> >>>>>>>>>>>>>>>>>>>>>>>>> template has been refuted.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> *When this halt deciding principle
> >>>>>>>>>>>>>>>>>>>>>>>>> understood to be correct* A halt decider
> >>>>>>>>>>>>>>>>>>>>>>>>> must compute the mapping from its inputs to
> >>>>>>>>>>>>>>>>>>>>>>>>> an accept or reject state on the basis of
> >>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior that is actually
> >>>>>>>>>>>>>>>>>>>>>>>>> specified by these inputs.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this implements
> >>>>>>>>>>>>>>>>>>>>>>>>> that principle* Every simulating halt
> >>>>>>>>>>>>>>>>>>>>>>>>> decider that correctly simulates its input
> >>>>>>>>>>>>>>>>>>>>>>>>> until it correctly predicts that this
> >>>>>>>>>>>>>>>>>>>>>>>>> simulated input would never terminate
> >>>>>>>>>>>>>>>>>>>>>>>>> normally, correctly rejects this input as
> >>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> *H is a Pure function*
> >>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
> >>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the basis
> >>>>>>>>>>>>>>>>>>>>>>>>> of software engineering*
> >>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion
> >>>>>>>>>>>>>>>>>>>>>>>> which I suppose is progress.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> I have shown that H/P does implement the HP's
> >>>>>>>>>>>>>>>>>>>>>>> "impossible input" template.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting
> >>>>>>>>>>>>>>>>>>>>>>> problem proofs that rely on this template.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Equating pathological input with non-halting is
> >>>>>>>>>>>>>>>>>>>>>> erroneous: you are only doing that because your
> >>>>>>>>>>>>>>>>>>>>>> broken solution treats it as "infinite
> >>>>>>>>>>>>>>>>>>>>>> recursion". There is no recursion in [Strachey
> >>>>>>>>>>>>>>>>>>>>>> 1965] and the HP proofs based on it.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> There is no recursion in any of the conventional
> >>>>>>>>>>>>>>>>>>>>> proofs only because no one ever previously
> >>>>>>>>>>>>>>>>>>>>> bothered to fully examine how a simulating halt
> >>>>>>>>>>>>>>>>>>>>> decider would address these otherwise
> >>>>>>>>>>>>>>>>>>>>> "impossible" inputs.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> I have shown that a simulating halt decider
> >>>>>>>>>>>>>>>>>>>> needn't be recursive in nature:
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> You sure do make it easy to review your work.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> "When the simulator detects the call
> >>>>>>>>>>>>>>>>>>> to H in P it forks the simulation into a
> >>>>>>>>>>>>>>>>>>> non-halting branch"
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> There is an infinite set of cases where this
> >>>>>>>>>>>>>>>>>>> overly simplistic criteria gets the wrong answer.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> That is neither an honest review or any kind of
> >>>>>>>>>>>>>>>>>> rebuttal: I have told you before: assertions made
> >>>>>>>>>>>>>>>>>> without evidence can be dismissed without evidence.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> If you claim there are an infinite number of cases
> >>>>>>>>>>>>>>>>>> where it gets the wrong answer then it shouldn't be
> >>>>>>>>>>>>>>>>>> too hard for to provide ONE case backing up your
> >>>>>>>>>>>>>>>>>> claim.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Sure:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>> static int count = 3;
> >>>>>>>>>>>>>>>>> count--;
> >>>>>>>>>>>>>>>>> if (!count) goto exit;
> >>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>> exit:
> >>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Nope; you seem to have forgotten that my decider is
> >>>>>>>>>>>>>>>> not recursive in nature: my decider will correctly
> >>>>>>>>>>>>>>>> determine that that input is pathological so will
> >>>>>>>>>>>>>>>> signal an exception.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> The above terminates normally so your decider gets the
> >>>>>>>>>>>>>>> wrong answer.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> It is a pathological input so neither halts nor doesn't
> >>>>>>>>>>>>>> halt: pathological input is INVALID so the correct
> >>>>>>>>>>>>>> "answer" is to signal an exception.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> So you don't know how static variables work?
> >>>>>>>>>>>>> I am not surprised.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>> {
> >>>>>>>>>>>>> static int count = 0;
> >>>>>>>>>>>>> if (count++ >= 2) goto exit;
> >>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>> exit:
> >>>>>>>>>>>>> return;
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> int main()
> >>>>>>>>>>>>> {
> >>>>>>>>>>>>> Output("Input_Halts = ", H(P,P));
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> _Pm()
> >>>>>>>>>>>>> [0000141e](01) 55 push ebp
> >>>>>>>>>>>>> [0000141f](02) 8bec mov ebp,esp
> >>>>>>>>>>>>> [00001421](03) 83ec08 sub esp,+08
> >>>>>>>>>>>>> [00001424](05) a100000000 mov eax,[00000000]
> >>>>>>>>>>>>> [00001429](03) 8945fc mov [ebp-04],eax
> >>>>>>>>>>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
> >>>>>>>>>>>>> [00001432](03) 83c101 add ecx,+01
> >>>>>>>>>>>>> [00001435](06) 890d00000000 mov [00000000],ecx
> >>>>>>>>>>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
> >>>>>>>>>>>>> [0000143f](02) 7c02 jl 00001443
> >>>>>>>>>>>>> [00001441](02) eb1b jmp 0000145e
> >>>>>>>>>>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
> >>>>>>>>>>>>> [00001446](01) 52 push edx
> >>>>>>>>>>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>> [0000144a](01) 50 push eax
> >>>>>>>>>>>>> [0000144b](05) e8defcffff call 0000112e
> >>>>>>>>>>>>> [00001450](03) 83c408 add esp,+08
> >>>>>>>>>>>>> [00001453](03) 8945f8 mov [ebp-08],eax
> >>>>>>>>>>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
> >>>>>>>>>>>>> [0000145a](02) 7402 jz 0000145e
> >>>>>>>>>>>>> [0000145c](02) ebfe jmp 0000145c
> >>>>>>>>>>>>> [0000145e](02) 8be5 mov esp,ebp
> >>>>>>>>>>>>> [00001460](01) 5d pop ebp
> >>>>>>>>>>>>> [00001461](01) c3 ret
> >>>>>>>>>>>>> Size in bytes:(0068) [00001461]
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> _main()
> >>>>>>>>>>>>> [0000146e](01) 55 push ebp
> >>>>>>>>>>>>> [0000146f](02) 8bec mov ebp,esp
> >>>>>>>>>>>>> [00001471](05) 681e140000 push 0000141e
> >>>>>>>>>>>>> [00001476](05) 681e140000 push 0000141e
> >>>>>>>>>>>>> [0000147b](05) e8aefcffff call 0000112e
> >>>>>>>>>>>>> [00001480](03) 83c408 add esp,+08
> >>>>>>>>>>>>> [00001483](01) 50 push eax
> >>>>>>>>>>>>> [00001484](05) 685f050000 push 0000055f
> >>>>>>>>>>>>> [00001489](05) e820f1ffff call 000005ae
> >>>>>>>>>>>>> [0000148e](03) 83c408 add esp,+08
> >>>>>>>>>>>>> [00001491](02) 33c0 xor eax,eax
> >>>>>>>>>>>>> [00001493](01) 5d pop ebp
> >>>>>>>>>>>>> [00001494](01) c3 ret
> >>>>>>>>>>>>> Size in bytes:(0039) [00001494]
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> machine stack stack machine
> >>>>>>>>>>>>> assembly address address data code
> >>>>>>>>>>>>> language ======== ======== ======== =========
> >>>>>>>>>>>>> ============= [0000146e][00102462][00000000] 55
> >>>>>>>>>>>>> push ebp [0000146f][00102462][00000000] 8bec mov
> >>>>>>>>>>>>> ebp,esp [00001471][0010245e][0000141e] 681e140000 push
> >>>>>>>>>>>>> 0000141e [00001476][0010245a][0000141e] 681e140000
> >>>>>>>>>>>>> push 0000141e [0000147b][00102456][00001480] e8aefcffff
> >>>>>>>>>>>>> call 0000112e
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:11250e
> >>>>>>>>>>>>> Address_of_H:112e
> >>>>>>>>>>>>> [0000141e][001124fa][001124fe] 55 push ebp
> >>>>>>>>>>>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
> >>>>>>>>>>>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
> >>>>>>>>>>>>> [00001424][001124f2][90909090] a100000000 mov
> >>>>>>>>>>>>> eax,[00000000] [00001429][001124f2][90909090] 8945fc
> >>>>>>>>>>>>> mov [ebp-04],eax [0000142c][001124f2][90909090]
> >>>>>>>>>>>>> 8b0d00000000 mov ecx,[00000000]
> >>>>>>>>>>>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
> >>>>>>>>>>>>> [00001435][001124f2][90909090] 890d00000000 mov
> >>>>>>>>>>>>> [00000000],ecx [0000143b][001124f2][90909090] 837dfc02
> >>>>>>>>>>>>> cmp dword [ebp-04],+02 [0000143f][001124f2][90909090]
> >>>>>>>>>>>>> 7c02 jl 00001443 [00001441][001124f2][90909090] eb1b
> >>>>>>>>>>>>> jmp 0000145e [0000145e][001124fa][001124fe] 8be5
> >>>>>>>>>>>>> mov esp,ebp [00001460][001124fe][00001217] 5d
> >>>>>>>>>>>>> pop ebp [00001461][00112502][0000141e] c3 ret
> >>>>>>>>>>>>> H: End Simulation Input Terminated Normally
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> [00001480][00102462][00000000] 83c408 add esp,+08
> >>>>>>>>>>>>> [00001483][0010245e][00000001] 50 push eax
> >>>>>>>>>>>>> [00001484][0010245a][0000055f] 685f050000 push
> >>>>>>>>>>>>> 0000055f [00001489][0010245a][0000055f] e820f1ffff
> >>>>>>>>>>>>> call 000005ae Input_Halts = 1
> >>>>>>>>>>>>> [0000148e][00102462][00000000] 83c408 add esp,+08
> >>>>>>>>>>>>> [00001491][00102462][00000000] 33c0 xor eax,eax
> >>>>>>>>>>>>> [00001493][00102466][00000018] 5d pop ebp
> >>>>>>>>>>>>> [00001494][0010246a][00000000] c3 ret
> >>>>>>>>>>>>> Number of Instructions Executed(1317) == 20 Pages
> >>>>>>>>>>>>
> >>>>>>>>>>>> For this particular stack trace I notice that the
> >>>>>>>>>>>> function symbol at the top of it is Pm not P which
> >>>>>>>>>>>> suggests to me one of two things:
> >>>>>>>>>>>
> >>>>>>>>>>> I already had a P so I renamed it to Pm so it would not
> >>>>>>>>>>> disturb my existing code. When I changed all the Pm
> >>>>>>>>>>> references to your name I forgot one.
> >>>>>>>>>>
> >>>>>>>>>> Then I suggest you check the output of compilation/linking
> >>>>>>>>>> is actually initializing static variables correctly. Are
> >>>>>>>>>> you even using a linker or are you just executing an
> >>>>>>>>>> object file? Static data normally goes into a separate
> >>>>>>>>>> data segment during the linking process.
> >>>>>>>>>>
> >>>>>>>>>> /Flibble
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> I haven't used static data in such a long time that I forgot
> >>>>>>>>> the compiler does not allocate any space for static
> >>>>>>>>> variables unless they have been initialized to a non-zero
> >>>>>>>>> value.
> >>>>>>>>>
> >>>>>>>>> void Pm(u32 x)
> >>>>>>>>> {
> >>>>>>>>> static int count = 0x777;
> >>>>>>>>> if (count++ > 0x777) goto exit;
> >>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>> if (Halt_Status)
> >>>>>>>>> HERE: goto HERE;
> >>>>>>>>> exit:
> >>>>>>>>> return;
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> int main()
> >>>>>>>>> {
> >>>>>>>>> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> _Pm()
> >>>>>>>>> [00000a1a](01) 55 push ebp
> >>>>>>>>> [00000a1b](02) 8bec mov ebp,esp
> >>>>>>>>> [00000a1d](03) 83ec08 sub esp,+08
> >>>>>>>>> [00000a20](05) a107030000 mov eax,[00000307]
> >>>>>>>>> [00000a25](03) 8945fc mov [ebp-04],eax
> >>>>>>>>> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
> >>>>>>>>> [00000a2e](03) 83c101 add ecx,+01
> >>>>>>>>> [00000a31](06) 890d07030000 mov [00000307],ecx
> >>>>>>>>> [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>>>>>> [00000a3e](02) 7e02 jng 00000a42
> >>>>>>>>> [00000a40](02) eb1b jmp 00000a5d
> >>>>>>>>> [00000a42](03) 8b5508 mov edx,[ebp+08]
> >>>>>>>>> [00000a45](01) 52 push edx
> >>>>>>>>> [00000a46](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>> [00000a49](01) 50 push eax
> >>>>>>>>> [00000a4a](05) e8ebfdffff call 0000083a // call H
> >>>>>>>>> [00000a4f](03) 83c408 add esp,+08
> >>>>>>>>> [00000a52](03) 8945f8 mov [ebp-08],eax
> >>>>>>>>> [00000a55](04) 837df800 cmp dword [ebp-08],+00
> >>>>>>>>> [00000a59](02) 7402 jz 00000a5d
> >>>>>>>>> [00000a5b](02) ebfe jmp 00000a5b
> >>>>>>>>> [00000a5d](02) 8be5 mov esp,ebp
> >>>>>>>>> [00000a5f](01) 5d pop ebp
> >>>>>>>>> [00000a60](01) c3 ret
> >>>>>>>>> Size in bytes:(0071) [00000a60]
> >>>>>>>>>
> >>>>>>>>> _main()
> >>>>>>>>> [00000a6a](01) 55 push ebp
> >>>>>>>>> [00000a6b](02) 8bec mov ebp,esp
> >>>>>>>>> [00000a6d](05) 681a0a0000 push 00000a1a // push
> >>>>>>>>> address of P [00000a72](05) 681a0a0000 push 00000a1a
> >>>>>>>>> // push address of P [00000a77](05) e8befdffff call
> >>>>>>>>> 0000083a // call H [00000a7c](03) 83c408 add
> >>>>>>>>> esp,+08 [00000a7f](01) 50 push eax
> >>>>>>>>> [00000a80](05) 680b030000 push 0000030b
> >>>>>>>>> [00000a85](05) e8d0f8ffff call 0000035a
> >>>>>>>>> [00000a8a](03) 83c408 add esp,+08
> >>>>>>>>> [00000a8d](02) 33c0 xor eax,eax
> >>>>>>>>> [00000a8f](01) 5d pop ebp
> >>>>>>>>> [00000a90](01) c3 ret
> >>>>>>>>> Size in bytes:(0039) [00000a90]
> >>>>>>>>>
> >>>>>>>>> machine stack stack machine assembly
> >>>>>>>>> address address data code language
> >>>>>>>>> ======== ======== ======== ========= =============
> >>>>>>>>> ...[00000a6a][0010137b][00000000] 55 push ebp
> >>>>>>>>> ...[00000a6b][0010137b][00000000] 8bec mov
> >>>>>>>>> ebp,esp ...[00000a6d][00101377][00000a1a] 681a0a0000
> >>>>>>>>> push 00000a1a ...[00000a72][00101373][00000a1a] 681a0a0000
> >>>>>>>>> push 00000a1a ...[00000a77][0010136f][00000a7c] e8befdffff
> >>>>>>>>> call 0000083a New slave_stack at:201427
> >>>>>>>>>
> >>>>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
> >>>>>>>>> at:21142f ...[00000a1a][0021141b][0021141f] 55
> >>>>>>>>> push ebp ...[00000a1b][0021141b][0021141f] 8bec
> >>>>>>>>> mov ebp,esp ...[00000a1d][00211413][90909090] 83ec08
> >>>>>>>>> sub esp,+08 ...[00000a20][00211413][90909090] a107030000
> >>>>>>>>> mov eax,[00000307] ...[00000a25][00211413][90909090]
> >>>>>>>>> 8945fc mov [ebp-04],eax ...[00000a28][00211413][90909090]
> >>>>>>>>> 8b0d07030000 mov ecx,[00000307]
> >>>>>>>>> ...[00000a2e][00211413][90909090] 83c101 add ecx,+01
> >>>>>>>>> ...[00000a31][00211413][90909090] 890d07030000 mov
> >>>>>>>>> [00000307],ecx ...[00000a37][00211413][90909090]
> >>>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>>>>>> ...[00000a3e][00211413][90909090] 7e02 jng
> >>>>>>>>> 00000a42 ...[00000a42][00211413][90909090] 8b5508
> >>>>>>>>> mov edx,[ebp+08] ...[00000a45][0021140f][00000a1a] 52 push
> >>>>>>>>> edx // push address of P
> >>>>>>>>> ...[00000a46][0021140f][00000a1a] 8b4508 mov
> >>>>>>>>> eax,[ebp+08] ...[00000a49][0021140b][00000a1a] 50 push eax
> >>>>>>>>> // push address of P ...[00000a4a][00211407][00000a4f]
> >>>>>>>>> e8ebfdffff call 0000083a // call H New slave_stack
> >>>>>>>>> at:24be4f ...[00000a1a][0025be43][0025be47] 55
> >>>>>>>>> push ebp ...[00000a1b][0025be43][0025be47] 8bec
> >>>>>>>>> mov ebp,esp ...[00000a1d][0025be3b][90909090] 83ec08
> >>>>>>>>> sub esp,+08 ...[00000a20][0025be3b][90909090] a107030000
> >>>>>>>>> mov eax,[00000307] ...[00000a25][0025be3b][90909090] 8945fc
> >>>>>>>>> mov [ebp-04],eax ...[00000a28][0025be3b][90909090]
> >>>>>>>>> 8b0d07030000 mov ecx,[00000307]
> >>>>>>>>> ...[00000a2e][0025be3b][90909090] 83c101 add ecx,+01
> >>>>>>>>> ...[00000a31][0025be3b][90909090] 890d07030000 mov
> >>>>>>>>> [00000307],ecx ...[00000a37][0025be3b][90909090]
> >>>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>>>>>> ...[00000a3e][0025be3b][90909090] 7e02 jng
> >>>>>>>>> 00000a42 ...[00000a40][0025be3b][90909090] eb1b
> >>>>>>>>> jmp 00000a5d // jmp to exit
> >>>>>>>>> ...[00000a5d][0025be43][0025be47] 8be5 mov
> >>>>>>>>> esp,ebp ...[00000a5f][0025be47][00000904] 5d
> >>>>>>>>> pop ebp ...[00000a60][0025be4b][00000a1a] c3 ret
> >>>>>>>>> ...[00000a7c][0010137b][00000000] 83c408 add esp,+08
> >>>>>>>>> ...[00000a7f][00101377][00000001] 50 push eax
> >>>>>>>>> ...[00000a80][00101373][0000030b] 680b030000 push 0000030b
> >>>>>>>>> ---[00000a85][00101373][0000030b] e8d0f8ffff call 0000035a
> >>>>>>>>> Input_Halts = 1 ...[00000a8a][0010137b][00000000] 83c408
> >>>>>>>>> add esp,+08 ...[00000a8d][0010137b][00000000] 33c0
> >>>>>>>>> xor eax,eax ...[00000a8f][0010137f][00100000] 5d
> >>>>>>>>> pop ebp ...[00000a90][00101383][00000004] c3
> >>>>>>>>> ret Number of Instructions Executed(27278)
> >>>>>>>>>
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Still seems wrong: post increment of the static variable
> >>>>>>>> should ensure that it does NOT goto exit but instead should
> >>>>>>>> call H which should presumably cause your "infinite recursion
> >>>>>>>> detected" bollocks to manifest.
> >>>>>>>
> >>>>>>> OK, I've looked at your assembly trace and it is recursing
> >>>>>>> into Pm from H and then halting but I am not sure what you are
> >>>>>>> trying to prove? Again [Strachey 1965] and associated proofs
> >>>>>>> are not recursive in nature.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> (1) H cannot correctly determine the halt status of the HP
> >>>>>> counter-examples unless H is a simulating halt decider.
> >>>>>>
> >>>>>> (2) The claim of the halting problem proofs is that no H in the
> >>>>>> universe can possibly correctly determine the halt status of
> >>>>>> its corresponding pathological input.
> >>>>>>
> >>>>>> (3) H(P,P) does correctly determine that its correponding
> >>>>>> pathological input would never halt.
> >>>>>>
> >>>>>> (4) It is ridiculously stupid of you to say that [Strachey
> >>>>>> 1965] does not specify infinitely recursive simulation when it
> >>>>>> is an easily verified fact that when Strachey T <is> a
> >>>>>> simulating halt decider that Strachey P <does> specify
> >>>>>> infinitely recursive simulation.
> >>>>>>
> >>>>>> It does not say this directly in [Strachey 1965] only because
> >>>>>> no one ever previously bothered to fully examine the effect of
> >>>>>> a simulating halt decider on the HP's pathological inputs.
> >>>>>
> >>>>> I see I have to repeat myself yet again: a simulating halt
> >>>>> decider needn't be recursive in nature and I have sketched a
> >>>>> design of such a halt decider:
> >>>>>
> >>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>>>
> >>>>> You are incorrect to claim an equivalence between pathological
> >>>>> input and non-halting.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>>
> >>>>
> >>>> 19 When the simulator detects the call to H in P it forks the
> >>>> simulation 20 into a non-halting branch (returning 0 to P) and a
> >>>> halting branch 21 (returning 1 to P)
> >>>>
> >>>> Software engineers at the low end of technical competence may not
> >>>> fully comprehend the common knowledge that:
> >>>>
> >>>> Whenever a function is called in what is essentially infinite
> >>>> recursion this function cannot possibly correctly return any
> >>>> value to its caller. You don't seem to understand that.
> >>>
> >>> Why are you so fucking obtuse? My forking simulating decider IS
> >>> NOT RECURSIVE.
> >>
> >> It is directly disobeying the actual behavior specified by the
> >> actual input by returning a value to a function that called it in
> >> infinite recursion.
> >
> > There is no infinite recursion in [Strachey 1965]. There is no
> > infinite recursion in the proofs based on [Strachey 1965]. There is
> > no infinite recursion in my forking simulating decider. The only
> > infinite recursion is that infinite recursion associated with your
> > broken decider.
> >
> > /Flibble
> >
> >
>
> The pathological input ([Strachey 1965] and others) to every
> simulating halt decider specifies infinitely nested simulution to
> every simulating halt decider.
My simulating halt decider does not have any infinite nesting or
infinite recursion.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2022-07-15 13:31 -0500 |
| Message-ID | <XqqdnZWta5oKL0z_nZ2dnUU7_8zNnZ2d@giganews.com> |
| In reply to | #85261 |
On 7/15/2022 1:17 PM, olcott wrote:
> On 7/15/2022 1:04 PM, Mr Flibble wrote:
>> On Fri, 15 Jul 2022 12:57:53 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 7/15/2022 12:46 PM, Mr Flibble wrote:
>>>> On Fri, 15 Jul 2022 12:39:31 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 7/15/2022 12:28 PM, Mr Flibble wrote:
>>>>>> On Fri, 15 Jul 2022 18:08:22 +0100
>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
>>>>>>> On Fri, 15 Jul 2022 12:00:59 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
>>>>>>>>> On Fri, 15 Jul 2022 10:58:14 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>> This is an explanation of a key new insight into
>>>>>>>>>>>>>>>>>>>>>>>> the halting problem provided in the language of
>>>>>>>>>>>>>>>>>>>>>>>> software engineering. Technical computer science
>>>>>>>>>>>>>>>>>>>>>>>> terms are explained using software engineering
>>>>>>>>>>>>>>>>>>>>>>>> terms. No knowledge of the halting problem is
>>>>>>>>>>>>>>>>>>>>>>>> required.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It is based on fully operational software
>>>>>>>>>>>>>>>>>>>>>>>> executed in the x86utm operating system. The
>>>>>>>>>>>>>>>>>>>>>>>> x86utm operating system (based on an excellent
>>>>>>>>>>>>>>>>>>>>>>>> open source x86 emulator) was created to study
>>>>>>>>>>>>>>>>>>>>>>>> the details of the halting problem proof
>>>>>>>>>>>>>>>>>>>>>>>> counter-examples at the much higher level of
>>>>>>>>>>>>>>>>>>>>>>>> abstraction of C/x86.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P) simulates
>>>>>>>>>>>>>>>>>>>>>>>> its input we can see that: (1) Function H() is
>>>>>>>>>>>>>>>>>>>>>>>> called from P(). (2) With the same arguments to
>>>>>>>>>>>>>>>>>>>>>>>> H(). (3) With no instructions in P preceding its
>>>>>>>>>>>>>>>>>>>>>>>> invocation of H(P,P).
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The above shows that the simulated P cannot
>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. Because H can see
>>>>>>>>>>>>>>>>>>>>>>>> the same (1)(2)(3) that we see H aborts its
>>>>>>>>>>>>>>>>>>>>>>>> simulation of P and rejects P as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> In computability theory, the
>>>>>>>>>>>>>>>>>>>>>>>> halting problem is the problem of determining,
>>>>>>>>>>>>>>>>>>>>>>>> from a description of an arbitrary computer
>>>>>>>>>>>>>>>>>>>>>>>> program and an input, whether the program will
>>>>>>>>>>>>>>>>>>>>>>>> finish running, or continue to run forever. Alan
>>>>>>>>>>>>>>>>>>>>>>>> Turing proved in 1936 that a general algorithm
>>>>>>>>>>>>>>>>>>>>>>>> to solve the halting problem for all possible
>>>>>>>>>>>>>>>>>>>>>>>> program- input pairs cannot exist.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> For any program H that might
>>>>>>>>>>>>>>>>>>>>>>>> determine if programs halt, a "pathological"
>>>>>>>>>>>>>>>>>>>>>>>> program P, called with some input, can pass its
>>>>>>>>>>>>>>>>>>>>>>>> own source and its input to H and then
>>>>>>>>>>>>>>>>>>>>>>>> specifically do the opposite of what H predicts
>>>>>>>>>>>>>>>>>>>>>>>> P will do. No H can exist that handles this
>>>>>>>>>>>>>>>>>>>>>>>> case.
>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
>>>>>>>>>>>>>>>>>>>>>>>> relationship to each other as described above.
>>>>>>>>>>>>>>>>>>>>>>>> Because H(P,P) does handle this case the above
>>>>>>>>>>>>>>>>>>>>>>>> halting problem undecidable input template has
>>>>>>>>>>>>>>>>>>>>>>>> been refuted.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *When this halt deciding principle understood to
>>>>>>>>>>>>>>>>>>>>>>>> be correct* A halt decider must compute the
>>>>>>>>>>>>>>>>>>>>>>>> mapping from its inputs to an accept or reject
>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior that
>>>>>>>>>>>>>>>>>>>>>>>> is actually specified by these inputs.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this implements
>>>>>>>>>>>>>>>>>>>>>>>> that principle* Every simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>> that correctly simulates its input until it
>>>>>>>>>>>>>>>>>>>>>>>> correctly predicts that this simulated input
>>>>>>>>>>>>>>>>>>>>>>>> would never terminate normally, correctly
>>>>>>>>>>>>>>>>>>>>>>>> rejects this input as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *H is a Pure function*
>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the basis of
>>>>>>>>>>>>>>>>>>>>>>>> software engineering*
>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion which I
>>>>>>>>>>>>>>>>>>>>>>> suppose is progress.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I have shown that H/P does implement the HP's
>>>>>>>>>>>>>>>>>>>>>> "impossible input" template.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting
>>>>>>>>>>>>>>>>>>>>>> problem proofs that rely on this template.
>>>>>>>>>>>>>>>>>>>>> Equating pathological input with non-halting is
>>>>>>>>>>>>>>>>>>>>> erroneous: you are only doing that because your
>>>>>>>>>>>>>>>>>>>>> broken solution treats it as "infinite recursion".
>>>>>>>>>>>>>>>>>>>>> There is no recursion in [Strachey 1965] and the HP
>>>>>>>>>>>>>>>>>>>>> proofs based on it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> There is no recursion in any of the conventional
>>>>>>>>>>>>>>>>>>>> proofs only because no one ever previously bothered
>>>>>>>>>>>>>>>>>>>> to fully examine how a simulating halt decider would
>>>>>>>>>>>>>>>>>>>> address these otherwise "impossible" inputs.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I have shown that a simulating halt decider needn't
>>>>>>>>>>>>>>>>>>> be recursive in nature:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You sure do make it easy to review your work.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> "When the simulator detects the call to H
>>>>>>>>>>>>>>>>>> in P it forks the simulation into a non-halting
>>>>>>>>>>>>>>>>>> branch"
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> There is an infinite set of cases where this overly
>>>>>>>>>>>>>>>>>> simplistic criteria gets the wrong answer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is neither an honest review or any kind of
>>>>>>>>>>>>>>>>> rebuttal: I have told you before: assertions made
>>>>>>>>>>>>>>>>> without evidence can be dismissed without evidence.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If you claim there are an infinite number of cases
>>>>>>>>>>>>>>>>> where it gets the wrong answer then it shouldn't be
>>>>>>>>>>>>>>>>> too hard for to provide ONE case backing up your claim.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>> Sure:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> static int count = 3;
>>>>>>>>>>>>>>>> count--;
>>>>>>>>>>>>>>>> if (!count) goto exit;
>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>> exit:
>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>> Nope; you seem to have forgotten that my decider is not
>>>>>>>>>>>>>>> recursive in nature: my decider will correctly determine
>>>>>>>>>>>>>>> that that input is pathological so will signal an
>>>>>>>>>>>>>>> exception.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The above terminates normally so your decider gets the
>>>>>>>>>>>>>> wrong answer.
>>>>>>>>>>>>> It is a pathological input so neither halts nor doesn't
>>>>>>>>>>>>> halt: pathological input is INVALID so the correct
>>>>>>>>>>>>> "answer" is to signal an exception.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> So you don't know how static variables work?
>>>>>>>>>>>> I am not surprised.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>> static int count = 0;
>>>>>>>>>>>> if (count++ >= 2) goto exit;
>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>> exit:
>>>>>>>>>>>> return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> Output("Input_Halts = ", H(P,P));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> _Pm()
>>>>>>>>>>>> [0000141e](01) 55 push ebp
>>>>>>>>>>>> [0000141f](02) 8bec mov ebp,esp
>>>>>>>>>>>> [00001421](03) 83ec08 sub esp,+08
>>>>>>>>>>>> [00001424](05) a100000000 mov eax,[00000000]
>>>>>>>>>>>> [00001429](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
>>>>>>>>>>>> [00001432](03) 83c101 add ecx,+01
>>>>>>>>>>>> [00001435](06) 890d00000000 mov [00000000],ecx
>>>>>>>>>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
>>>>>>>>>>>> [0000143f](02) 7c02 jl 00001443
>>>>>>>>>>>> [00001441](02) eb1b jmp 0000145e
>>>>>>>>>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
>>>>>>>>>>>> [00001446](01) 52 push edx
>>>>>>>>>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> [0000144a](01) 50 push eax
>>>>>>>>>>>> [0000144b](05) e8defcffff call 0000112e
>>>>>>>>>>>> [00001450](03) 83c408 add esp,+08
>>>>>>>>>>>> [00001453](03) 8945f8 mov [ebp-08],eax
>>>>>>>>>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
>>>>>>>>>>>> [0000145a](02) 7402 jz 0000145e
>>>>>>>>>>>> [0000145c](02) ebfe jmp 0000145c
>>>>>>>>>>>> [0000145e](02) 8be5 mov esp,ebp
>>>>>>>>>>>> [00001460](01) 5d pop ebp
>>>>>>>>>>>> [00001461](01) c3 ret
>>>>>>>>>>>> Size in bytes:(0068) [00001461]
>>>>>>>>>>>>
>>>>>>>>>>>> _main()
>>>>>>>>>>>> [0000146e](01) 55 push ebp
>>>>>>>>>>>> [0000146f](02) 8bec mov ebp,esp
>>>>>>>>>>>> [00001471](05) 681e140000 push 0000141e
>>>>>>>>>>>> [00001476](05) 681e140000 push 0000141e
>>>>>>>>>>>> [0000147b](05) e8aefcffff call 0000112e
>>>>>>>>>>>> [00001480](03) 83c408 add esp,+08
>>>>>>>>>>>> [00001483](01) 50 push eax
>>>>>>>>>>>> [00001484](05) 685f050000 push 0000055f
>>>>>>>>>>>> [00001489](05) e820f1ffff call 000005ae
>>>>>>>>>>>> [0000148e](03) 83c408 add esp,+08
>>>>>>>>>>>> [00001491](02) 33c0 xor eax,eax
>>>>>>>>>>>> [00001493](01) 5d pop ebp
>>>>>>>>>>>> [00001494](01) c3 ret
>>>>>>>>>>>> Size in bytes:(0039) [00001494]
>>>>>>>>>>>>
>>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>>> address address data code language
>>>>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>>>>> [0000146e][00102462][00000000] 55 push ebp
>>>>>>>>>>>> [0000146f][00102462][00000000] 8bec mov ebp,esp
>>>>>>>>>>>> [00001471][0010245e][0000141e] 681e140000 push 0000141e
>>>>>>>>>>>> [00001476][0010245a][0000141e] 681e140000 push 0000141e
>>>>>>>>>>>> [0000147b][00102456][00001480] e8aefcffff call 0000112e
>>>>>>>>>>>>
>>>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:11250e
>>>>>>>>>>>> Address_of_H:112e
>>>>>>>>>>>> [0000141e][001124fa][001124fe] 55 push ebp
>>>>>>>>>>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
>>>>>>>>>>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
>>>>>>>>>>>> [00001424][001124f2][90909090] a100000000 mov
>>>>>>>>>>>> eax,[00000000] [00001429][001124f2][90909090] 8945fc
>>>>>>>>>>>> mov [ebp-04],eax [0000142c][001124f2][90909090]
>>>>>>>>>>>> 8b0d00000000 mov ecx,[00000000]
>>>>>>>>>>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
>>>>>>>>>>>> [00001435][001124f2][90909090] 890d00000000 mov
>>>>>>>>>>>> [00000000],ecx [0000143b][001124f2][90909090] 837dfc02
>>>>>>>>>>>> cmp dword [ebp-04],+02 [0000143f][001124f2][90909090] 7c02
>>>>>>>>>>>> jl 00001443 [00001441][001124f2][90909090] eb1b
>>>>>>>>>>>> jmp 0000145e [0000145e][001124fa][001124fe] 8be5
>>>>>>>>>>>> mov esp,ebp [00001460][001124fe][00001217] 5d pop
>>>>>>>>>>>> ebp [00001461][00112502][0000141e] c3 ret H: End
>>>>>>>>>>>> Simulation Input Terminated Normally
>>>>>>>>>>>>
>>>>>>>>>>>> [00001480][00102462][00000000] 83c408 add esp,+08
>>>>>>>>>>>> [00001483][0010245e][00000001] 50 push eax
>>>>>>>>>>>> [00001484][0010245a][0000055f] 685f050000 push 0000055f
>>>>>>>>>>>> [00001489][0010245a][0000055f] e820f1ffff call 000005ae
>>>>>>>>>>>> Input_Halts = 1
>>>>>>>>>>>> [0000148e][00102462][00000000] 83c408 add esp,+08
>>>>>>>>>>>> [00001491][00102462][00000000] 33c0 xor eax,eax
>>>>>>>>>>>> [00001493][00102466][00000018] 5d pop ebp
>>>>>>>>>>>> [00001494][0010246a][00000000] c3 ret
>>>>>>>>>>>> Number of Instructions Executed(1317) == 20 Pages
>>>>>>>>>>>
>>>>>>>>>>> For this particular stack trace I notice that the function
>>>>>>>>>>> symbol at the top of it is Pm not P which suggests to me one
>>>>>>>>>>> of two things:
>>>>>>>>>>
>>>>>>>>>> I already had a P so I renamed it to Pm so it would not
>>>>>>>>>> disturb my existing code. When I changed all the Pm
>>>>>>>>>> references to your name I forgot one.
>>>>>>>>>
>>>>>>>>> Then I suggest you check the output of compilation/linking is
>>>>>>>>> actually initializing static variables correctly. Are you even
>>>>>>>>> using a linker or are you just executing an object file?
>>>>>>>>> Static data normally goes into a separate data segment during
>>>>>>>>> the linking process.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> I haven't used static data in such a long time that I forgot the
>>>>>>>> compiler does not allocate any space for static variables unless
>>>>>>>> they have been initialized to a non-zero value.
>>>>>>>>
>>>>>>>> void Pm(u32 x)
>>>>>>>> {
>>>>>>>> static int count = 0x777;
>>>>>>>> if (count++ > 0x777) goto exit;
>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>> if (Halt_Status)
>>>>>>>> HERE: goto HERE;
>>>>>>>> exit:
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>> _Pm()
>>>>>>>> [00000a1a](01) 55 push ebp
>>>>>>>> [00000a1b](02) 8bec mov ebp,esp
>>>>>>>> [00000a1d](03) 83ec08 sub esp,+08
>>>>>>>> [00000a20](05) a107030000 mov eax,[00000307]
>>>>>>>> [00000a25](03) 8945fc mov [ebp-04],eax
>>>>>>>> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
>>>>>>>> [00000a2e](03) 83c101 add ecx,+01
>>>>>>>> [00000a31](06) 890d07030000 mov [00000307],ecx
>>>>>>>> [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>>> [00000a3e](02) 7e02 jng 00000a42
>>>>>>>> [00000a40](02) eb1b jmp 00000a5d
>>>>>>>> [00000a42](03) 8b5508 mov edx,[ebp+08]
>>>>>>>> [00000a45](01) 52 push edx
>>>>>>>> [00000a46](03) 8b4508 mov eax,[ebp+08]
>>>>>>>> [00000a49](01) 50 push eax
>>>>>>>> [00000a4a](05) e8ebfdffff call 0000083a // call H
>>>>>>>> [00000a4f](03) 83c408 add esp,+08
>>>>>>>> [00000a52](03) 8945f8 mov [ebp-08],eax
>>>>>>>> [00000a55](04) 837df800 cmp dword [ebp-08],+00
>>>>>>>> [00000a59](02) 7402 jz 00000a5d
>>>>>>>> [00000a5b](02) ebfe jmp 00000a5b
>>>>>>>> [00000a5d](02) 8be5 mov esp,ebp
>>>>>>>> [00000a5f](01) 5d pop ebp
>>>>>>>> [00000a60](01) c3 ret
>>>>>>>> Size in bytes:(0071) [00000a60]
>>>>>>>>
>>>>>>>> _main()
>>>>>>>> [00000a6a](01) 55 push ebp
>>>>>>>> [00000a6b](02) 8bec mov ebp,esp
>>>>>>>> [00000a6d](05) 681a0a0000 push 00000a1a // push address
>>>>>>>> of P [00000a72](05) 681a0a0000 push 00000a1a // push
>>>>>>>> address of P [00000a77](05) e8befdffff call 0000083a //
>>>>>>>> call H [00000a7c](03) 83c408 add esp,+08
>>>>>>>> [00000a7f](01) 50 push eax
>>>>>>>> [00000a80](05) 680b030000 push 0000030b
>>>>>>>> [00000a85](05) e8d0f8ffff call 0000035a
>>>>>>>> [00000a8a](03) 83c408 add esp,+08
>>>>>>>> [00000a8d](02) 33c0 xor eax,eax
>>>>>>>> [00000a8f](01) 5d pop ebp
>>>>>>>> [00000a90](01) c3 ret
>>>>>>>> Size in bytes:(0039) [00000a90]
>>>>>>>>
>>>>>>>> machine stack stack machine assembly
>>>>>>>> address address data code language
>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>> ...[00000a6a][0010137b][00000000] 55 push ebp
>>>>>>>> ...[00000a6b][0010137b][00000000] 8bec mov ebp,esp
>>>>>>>> ...[00000a6d][00101377][00000a1a] 681a0a0000 push 00000a1a
>>>>>>>> ...[00000a72][00101373][00000a1a] 681a0a0000 push 00000a1a
>>>>>>>> ...[00000a77][0010136f][00000a7c] e8befdffff call 0000083a
>>>>>>>> New slave_stack at:201427
>>>>>>>>
>>>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>>>>>>> at:21142f ...[00000a1a][0021141b][0021141f] 55 push
>>>>>>>> ebp ...[00000a1b][0021141b][0021141f] 8bec mov
>>>>>>>> ebp,esp ...[00000a1d][00211413][90909090] 83ec08 sub
>>>>>>>> esp,+08 ...[00000a20][00211413][90909090] a107030000 mov
>>>>>>>> eax,[00000307] ...[00000a25][00211413][90909090] 8945fc
>>>>>>>> mov [ebp-04],eax ...[00000a28][00211413][90909090] 8b0d07030000
>>>>>>>> mov ecx,[00000307] ...[00000a2e][00211413][90909090] 83c101
>>>>>>>> add ecx,+01 ...[00000a31][00211413][90909090] 890d07030000
>>>>>>>> mov [00000307],ecx ...[00000a37][00211413][90909090]
>>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>>> ...[00000a3e][00211413][90909090] 7e02 jng 00000a42
>>>>>>>> ...[00000a42][00211413][90909090] 8b5508 mov
>>>>>>>> edx,[ebp+08] ...[00000a45][0021140f][00000a1a] 52
>>>>>>>> push edx // push address of P
>>>>>>>> ...[00000a46][0021140f][00000a1a] 8b4508 mov
>>>>>>>> eax,[ebp+08] ...[00000a49][0021140b][00000a1a] 50
>>>>>>>> push eax // push address of P
>>>>>>>> ...[00000a4a][00211407][00000a4f] e8ebfdffff call 0000083a
>>>>>>>> // call H New slave_stack at:24be4f
>>>>>>>> ...[00000a1a][0025be43][0025be47] 55 push ebp
>>>>>>>> ...[00000a1b][0025be43][0025be47] 8bec mov ebp,esp
>>>>>>>> ...[00000a1d][0025be3b][90909090] 83ec08 sub esp,+08
>>>>>>>> ...[00000a20][0025be3b][90909090] a107030000 mov
>>>>>>>> eax,[00000307] ...[00000a25][0025be3b][90909090] 8945fc
>>>>>>>> mov [ebp-04],eax ...[00000a28][0025be3b][90909090] 8b0d07030000
>>>>>>>> mov ecx,[00000307] ...[00000a2e][0025be3b][90909090] 83c101
>>>>>>>> add ecx,+01 ...[00000a31][0025be3b][90909090] 890d07030000
>>>>>>>> mov [00000307],ecx ...[00000a37][0025be3b][90909090]
>>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>>> ...[00000a3e][0025be3b][90909090] 7e02 jng 00000a42
>>>>>>>> ...[00000a40][0025be3b][90909090] eb1b jmp 00000a5d
>>>>>>>> // jmp to exit
>>>>>>>> ...[00000a5d][0025be43][0025be47] 8be5 mov esp,ebp
>>>>>>>> ...[00000a5f][0025be47][00000904] 5d pop ebp
>>>>>>>> ...[00000a60][0025be4b][00000a1a] c3 ret
>>>>>>>> ...[00000a7c][0010137b][00000000] 83c408 add esp,+08
>>>>>>>> ...[00000a7f][00101377][00000001] 50 push eax
>>>>>>>> ...[00000a80][00101373][0000030b] 680b030000 push 0000030b
>>>>>>>> ---[00000a85][00101373][0000030b] e8d0f8ffff call 0000035a
>>>>>>>> Input_Halts = 1
>>>>>>>> ...[00000a8a][0010137b][00000000] 83c408 add esp,+08
>>>>>>>> ...[00000a8d][0010137b][00000000] 33c0 xor eax,eax
>>>>>>>> ...[00000a8f][0010137f][00100000] 5d pop ebp
>>>>>>>> ...[00000a90][00101383][00000004] c3 ret
>>>>>>>> Number of Instructions Executed(27278)
>>>>>>>>
>>>>>>>
>>>>>>> Still seems wrong: post increment of the static variable should
>>>>>>> ensure that it does NOT goto exit but instead should call H which
>>>>>>> should presumably cause your "infinite recursion detected"
>>>>>>> bollocks to manifest.
>>>>>>
>>>>>> OK, I've looked at your assembly trace and it is recursing into Pm
>>>>>> from H and then halting but I am not sure what you are trying to
>>>>>> prove? Again [Strachey 1965] and associated proofs are not
>>>>>> recursive in nature.
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>> (1) H cannot correctly determine the halt status of the HP
>>>>> counter-examples unless H is a simulating halt decider.
>>>>>
>>>>> (2) The claim of the halting problem proofs is that no H in the
>>>>> universe can possibly correctly determine the halt status of its
>>>>> corresponding pathological input.
>>>>>
>>>>> (3) H(P,P) does correctly determine that its correponding
>>>>> pathological input would never halt.
>>>>>
>>>>> (4) It is ridiculously stupid of you to say that [Strachey 1965]
>>>>> does not specify infinitely recursive simulation when it is an
>>>>> easily verified fact that when Strachey T <is> a simulating halt
>>>>> decider that Strachey P <does> specify infinitely recursive
>>>>> simulation.
>>>>>
>>>>> It does not say this directly in [Strachey 1965] only because no
>>>>> one ever previously bothered to fully examine the effect of a
>>>>> simulating halt decider on the HP's pathological inputs.
>>>>
>>>> I see I have to repeat myself yet again: a simulating halt decider
>>>> needn't be recursive in nature and I have sketched a design of such
>>>> a halt decider:
>>>>
>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>
>>>> You are incorrect to claim an equivalence between pathological input
>>>> and non-halting.
>>>>
>>>> /Flibble
>>>>
>>>
>>> 19 When the simulator detects the call to H in P it forks the
>>> simulation 20 into a non-halting branch (returning 0 to P) and a
>>> halting branch 21 (returning 1 to P)
>>>
>>> Software engineers at the low end of technical competence may not
>>> fully comprehend the common knowledge that:
>>>
>>> Whenever a function is called in what is essentially infinite
>>> recursion this function cannot possibly correctly return any value to
>>> its caller. You don't seem to understand that.
>>
>> Why are you so fucking obtuse? My forking simulating decider IS NOT
>> RECURSIVE.
>
> It is directly disobeying the actual behavior specified by the actual
> input by returning a value to a function that called it in infinite
> recursion.
>
>
Even if we did accept that your pathological self-reference detector is
valid it is only a copycat of my idea and it provides a weaker result.
It answers: I don't know and mine answers: non-halting.
Because you did not even copycat my criteria correctly your H gets the
wrong answer on this input.
int add(int N)
{
return N + 3;
}
void Pc(ptr x)
{
H(add, (ptr)7);
return;
}
int main()
{
Output("Input_Halts = ", H(Pc,Pc));
}
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-07-15 19:41 +0100 |
| Message-ID | <20220715194148.00005b14@reddwarf.jmc.corp> |
| In reply to | #85263 |
On Fri, 15 Jul 2022 13:31:50 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/15/2022 1:17 PM, olcott wrote:
> > On 7/15/2022 1:04 PM, Mr Flibble wrote:
> >> On Fri, 15 Jul 2022 12:57:53 -0500
> >> olcott <NoOne@NoWhere.com> wrote:
> >>
> >>> On 7/15/2022 12:46 PM, Mr Flibble wrote:
> >>>> On Fri, 15 Jul 2022 12:39:31 -0500
> >>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>> On 7/15/2022 12:28 PM, Mr Flibble wrote:
> >>>>>> On Fri, 15 Jul 2022 18:08:22 +0100
> >>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
> >>>>>>> On Fri, 15 Jul 2022 12:00:59 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 15 Jul 2022 10:58:14 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
> >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
> >>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
> >>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
> >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
> >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> This is an explanation of a key new insight
> >>>>>>>>>>>>>>>>>>>>>>>> into the halting problem provided in the
> >>>>>>>>>>>>>>>>>>>>>>>> language of software engineering. Technical
> >>>>>>>>>>>>>>>>>>>>>>>> computer science terms are explained using
> >>>>>>>>>>>>>>>>>>>>>>>> software engineering terms. No knowledge of
> >>>>>>>>>>>>>>>>>>>>>>>> the halting problem is required.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> It is based on fully operational software
> >>>>>>>>>>>>>>>>>>>>>>>> executed in the x86utm operating system. The
> >>>>>>>>>>>>>>>>>>>>>>>> x86utm operating system (based on an
> >>>>>>>>>>>>>>>>>>>>>>>> excellent open source x86 emulator) was
> >>>>>>>>>>>>>>>>>>>>>>>> created to study the details of the halting
> >>>>>>>>>>>>>>>>>>>>>>>> problem proof counter-examples at the much
> >>>>>>>>>>>>>>>>>>>>>>>> higher level of abstraction of C/x86.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt
> >>>>>>>>>>>>>>>>>>>>>>>> decider
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P,
> >>>>>>>>>>>>>>>>>>>>>>>> P)); }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P) simulates
> >>>>>>>>>>>>>>>>>>>>>>>> its input we can see that: (1) Function H()
> >>>>>>>>>>>>>>>>>>>>>>>> is called from P(). (2) With the same
> >>>>>>>>>>>>>>>>>>>>>>>> arguments to H(). (3) With no instructions
> >>>>>>>>>>>>>>>>>>>>>>>> in P preceding its invocation of H(P,P).
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> The above shows that the simulated P cannot
> >>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. Because H can
> >>>>>>>>>>>>>>>>>>>>>>>> see the same (1)(2)(3) that we see H aborts
> >>>>>>>>>>>>>>>>>>>>>>>> its simulation of P and rejects P as
> >>>>>>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> In computability theory, the
> >>>>>>>>>>>>>>>>>>>>>>>> halting problem is the problem of
> >>>>>>>>>>>>>>>>>>>>>>>> determining, from a description of an
> >>>>>>>>>>>>>>>>>>>>>>>> arbitrary computer program and an input,
> >>>>>>>>>>>>>>>>>>>>>>>> whether the program will finish running, or
> >>>>>>>>>>>>>>>>>>>>>>>> continue to run forever. Alan Turing proved
> >>>>>>>>>>>>>>>>>>>>>>>> in 1936 that a general algorithm to solve
> >>>>>>>>>>>>>>>>>>>>>>>> the halting problem for all possible
> >>>>>>>>>>>>>>>>>>>>>>>> program- input pairs cannot exist.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> For any program H that might
> >>>>>>>>>>>>>>>>>>>>>>>> determine if programs halt, a "pathological"
> >>>>>>>>>>>>>>>>>>>>>>>> program P, called with some input, can pass
> >>>>>>>>>>>>>>>>>>>>>>>> its own source and its input to H and then
> >>>>>>>>>>>>>>>>>>>>>>>> specifically do the opposite of what H
> >>>>>>>>>>>>>>>>>>>>>>>> predicts P will do. No H can exist that
> >>>>>>>>>>>>>>>>>>>>>>>> handles this case.
> >>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
> >>>>>>>>>>>>>>>>>>>>>>>> relationship to each other as described
> >>>>>>>>>>>>>>>>>>>>>>>> above. Because H(P,P) does handle this case
> >>>>>>>>>>>>>>>>>>>>>>>> the above halting problem undecidable input
> >>>>>>>>>>>>>>>>>>>>>>>> template has been refuted.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> *When this halt deciding principle
> >>>>>>>>>>>>>>>>>>>>>>>> understood to be correct* A halt decider
> >>>>>>>>>>>>>>>>>>>>>>>> must compute the mapping from its inputs to
> >>>>>>>>>>>>>>>>>>>>>>>> an accept or reject state on the basis of
> >>>>>>>>>>>>>>>>>>>>>>>> the actual behavior that is actually
> >>>>>>>>>>>>>>>>>>>>>>>> specified by these inputs.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this implements
> >>>>>>>>>>>>>>>>>>>>>>>> that principle* Every simulating halt decider
> >>>>>>>>>>>>>>>>>>>>>>>> that correctly simulates its input until it
> >>>>>>>>>>>>>>>>>>>>>>>> correctly predicts that this simulated input
> >>>>>>>>>>>>>>>>>>>>>>>> would never terminate normally, correctly
> >>>>>>>>>>>>>>>>>>>>>>>> rejects this input as non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> *H is a Pure function*
> >>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
> >>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the basis
> >>>>>>>>>>>>>>>>>>>>>>>> of software engineering*
> >>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion
> >>>>>>>>>>>>>>>>>>>>>>> which I suppose is progress.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> I have shown that H/P does implement the HP's
> >>>>>>>>>>>>>>>>>>>>>> "impossible input" template.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting
> >>>>>>>>>>>>>>>>>>>>>> problem proofs that rely on this template.
> >>>>>>>>>>>>>>>>>>>>> Equating pathological input with non-halting is
> >>>>>>>>>>>>>>>>>>>>> erroneous: you are only doing that because your
> >>>>>>>>>>>>>>>>>>>>> broken solution treats it as "infinite
> >>>>>>>>>>>>>>>>>>>>> recursion". There is no recursion in [Strachey
> >>>>>>>>>>>>>>>>>>>>> 1965] and the HP proofs based on it.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> There is no recursion in any of the conventional
> >>>>>>>>>>>>>>>>>>>> proofs only because no one ever previously
> >>>>>>>>>>>>>>>>>>>> bothered to fully examine how a simulating halt
> >>>>>>>>>>>>>>>>>>>> decider would address these otherwise
> >>>>>>>>>>>>>>>>>>>> "impossible" inputs.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> I have shown that a simulating halt decider
> >>>>>>>>>>>>>>>>>>> needn't be recursive in nature:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> You sure do make it easy to review your work.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> "When the simulator detects the call to
> >>>>>>>>>>>>>>>>>> H in P it forks the simulation into a non-halting
> >>>>>>>>>>>>>>>>>> branch"
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> There is an infinite set of cases where this overly
> >>>>>>>>>>>>>>>>>> simplistic criteria gets the wrong answer.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> That is neither an honest review or any kind of
> >>>>>>>>>>>>>>>>> rebuttal: I have told you before: assertions made
> >>>>>>>>>>>>>>>>> without evidence can be dismissed without evidence.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> If you claim there are an infinite number of cases
> >>>>>>>>>>>>>>>>> where it gets the wrong answer then it shouldn't be
> >>>>>>>>>>>>>>>>> too hard for to provide ONE case backing up your
> >>>>>>>>>>>>>>>>> claim.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>> Sure:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> static int count = 3;
> >>>>>>>>>>>>>>>> count--;
> >>>>>>>>>>>>>>>> if (!count) goto exit;
> >>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>> exit:
> >>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>> Nope; you seem to have forgotten that my decider is
> >>>>>>>>>>>>>>> not recursive in nature: my decider will correctly
> >>>>>>>>>>>>>>> determine that that input is pathological so will
> >>>>>>>>>>>>>>> signal an exception.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> The above terminates normally so your decider gets the
> >>>>>>>>>>>>>> wrong answer.
> >>>>>>>>>>>>> It is a pathological input so neither halts nor doesn't
> >>>>>>>>>>>>> halt: pathological input is INVALID so the correct
> >>>>>>>>>>>>> "answer" is to signal an exception.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>
> >>>>>>>>>>>> So you don't know how static variables work?
> >>>>>>>>>>>> I am not surprised.
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> static int count = 0;
> >>>>>>>>>>>> if (count++ >= 2) goto exit;
> >>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>> exit:
> >>>>>>>>>>>> return;
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> int main()
> >>>>>>>>>>>> {
> >>>>>>>>>>>> Output("Input_Halts = ", H(P,P));
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> _Pm()
> >>>>>>>>>>>> [0000141e](01) 55 push ebp
> >>>>>>>>>>>> [0000141f](02) 8bec mov ebp,esp
> >>>>>>>>>>>> [00001421](03) 83ec08 sub esp,+08
> >>>>>>>>>>>> [00001424](05) a100000000 mov eax,[00000000]
> >>>>>>>>>>>> [00001429](03) 8945fc mov [ebp-04],eax
> >>>>>>>>>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
> >>>>>>>>>>>> [00001432](03) 83c101 add ecx,+01
> >>>>>>>>>>>> [00001435](06) 890d00000000 mov [00000000],ecx
> >>>>>>>>>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
> >>>>>>>>>>>> [0000143f](02) 7c02 jl 00001443
> >>>>>>>>>>>> [00001441](02) eb1b jmp 0000145e
> >>>>>>>>>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
> >>>>>>>>>>>> [00001446](01) 52 push edx
> >>>>>>>>>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>> [0000144a](01) 50 push eax
> >>>>>>>>>>>> [0000144b](05) e8defcffff call 0000112e
> >>>>>>>>>>>> [00001450](03) 83c408 add esp,+08
> >>>>>>>>>>>> [00001453](03) 8945f8 mov [ebp-08],eax
> >>>>>>>>>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
> >>>>>>>>>>>> [0000145a](02) 7402 jz 0000145e
> >>>>>>>>>>>> [0000145c](02) ebfe jmp 0000145c
> >>>>>>>>>>>> [0000145e](02) 8be5 mov esp,ebp
> >>>>>>>>>>>> [00001460](01) 5d pop ebp
> >>>>>>>>>>>> [00001461](01) c3 ret
> >>>>>>>>>>>> Size in bytes:(0068) [00001461]
> >>>>>>>>>>>>
> >>>>>>>>>>>> _main()
> >>>>>>>>>>>> [0000146e](01) 55 push ebp
> >>>>>>>>>>>> [0000146f](02) 8bec mov ebp,esp
> >>>>>>>>>>>> [00001471](05) 681e140000 push 0000141e
> >>>>>>>>>>>> [00001476](05) 681e140000 push 0000141e
> >>>>>>>>>>>> [0000147b](05) e8aefcffff call 0000112e
> >>>>>>>>>>>> [00001480](03) 83c408 add esp,+08
> >>>>>>>>>>>> [00001483](01) 50 push eax
> >>>>>>>>>>>> [00001484](05) 685f050000 push 0000055f
> >>>>>>>>>>>> [00001489](05) e820f1ffff call 000005ae
> >>>>>>>>>>>> [0000148e](03) 83c408 add esp,+08
> >>>>>>>>>>>> [00001491](02) 33c0 xor eax,eax
> >>>>>>>>>>>> [00001493](01) 5d pop ebp
> >>>>>>>>>>>> [00001494](01) c3 ret
> >>>>>>>>>>>> Size in bytes:(0039) [00001494]
> >>>>>>>>>>>>
> >>>>>>>>>>>> machine stack stack machine assembly
> >>>>>>>>>>>> address address data code language
> >>>>>>>>>>>> ======== ======== ======== =========
> >>>>>>>>>>>> ============= [0000146e][00102462][00000000] 55
> >>>>>>>>>>>> push ebp [0000146f][00102462][00000000] 8bec
> >>>>>>>>>>>> mov ebp,esp [00001471][0010245e][0000141e] 681e140000
> >>>>>>>>>>>> push 0000141e [00001476][0010245a][0000141e] 681e140000
> >>>>>>>>>>>> push 0000141e [0000147b][00102456][00001480] e8aefcffff
> >>>>>>>>>>>> call 0000112e
> >>>>>>>>>>>>
> >>>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:11250e
> >>>>>>>>>>>> Address_of_H:112e
> >>>>>>>>>>>> [0000141e][001124fa][001124fe] 55 push ebp
> >>>>>>>>>>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
> >>>>>>>>>>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
> >>>>>>>>>>>> [00001424][001124f2][90909090] a100000000 mov
> >>>>>>>>>>>> eax,[00000000] [00001429][001124f2][90909090] 8945fc
> >>>>>>>>>>>> mov [ebp-04],eax [0000142c][001124f2][90909090]
> >>>>>>>>>>>> 8b0d00000000 mov ecx,[00000000]
> >>>>>>>>>>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
> >>>>>>>>>>>> [00001435][001124f2][90909090] 890d00000000 mov
> >>>>>>>>>>>> [00000000],ecx [0000143b][001124f2][90909090] 837dfc02
> >>>>>>>>>>>> cmp dword [ebp-04],+02 [0000143f][001124f2][90909090]
> >>>>>>>>>>>> 7c02 jl 00001443 [00001441][001124f2][90909090] eb1b
> >>>>>>>>>>>> jmp 0000145e [0000145e][001124fa][001124fe] 8be5
> >>>>>>>>>>>> mov esp,ebp [00001460][001124fe][00001217] 5d
> >>>>>>>>>>>> pop ebp [00001461][00112502][0000141e] c3 ret
> >>>>>>>>>>>> H: End Simulation Input Terminated Normally
> >>>>>>>>>>>>
> >>>>>>>>>>>> [00001480][00102462][00000000] 83c408 add esp,+08
> >>>>>>>>>>>> [00001483][0010245e][00000001] 50 push eax
> >>>>>>>>>>>> [00001484][0010245a][0000055f] 685f050000 push 0000055f
> >>>>>>>>>>>> [00001489][0010245a][0000055f] e820f1ffff call 000005ae
> >>>>>>>>>>>> Input_Halts = 1
> >>>>>>>>>>>> [0000148e][00102462][00000000] 83c408 add esp,+08
> >>>>>>>>>>>> [00001491][00102462][00000000] 33c0 xor eax,eax
> >>>>>>>>>>>> [00001493][00102466][00000018] 5d pop ebp
> >>>>>>>>>>>> [00001494][0010246a][00000000] c3 ret
> >>>>>>>>>>>> Number of Instructions Executed(1317) == 20 Pages
> >>>>>>>>>>>
> >>>>>>>>>>> For this particular stack trace I notice that the function
> >>>>>>>>>>> symbol at the top of it is Pm not P which suggests to me
> >>>>>>>>>>> one of two things:
> >>>>>>>>>>
> >>>>>>>>>> I already had a P so I renamed it to Pm so it would not
> >>>>>>>>>> disturb my existing code. When I changed all the Pm
> >>>>>>>>>> references to your name I forgot one.
> >>>>>>>>>
> >>>>>>>>> Then I suggest you check the output of compilation/linking
> >>>>>>>>> is actually initializing static variables correctly. Are
> >>>>>>>>> you even using a linker or are you just executing an object
> >>>>>>>>> file? Static data normally goes into a separate data
> >>>>>>>>> segment during the linking process.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>
> >>>>>>>> I haven't used static data in such a long time that I forgot
> >>>>>>>> the compiler does not allocate any space for static
> >>>>>>>> variables unless they have been initialized to a non-zero
> >>>>>>>> value.
> >>>>>>>>
> >>>>>>>> void Pm(u32 x)
> >>>>>>>> {
> >>>>>>>> static int count = 0x777;
> >>>>>>>> if (count++ > 0x777) goto exit;
> >>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>> if (Halt_Status)
> >>>>>>>> HERE: goto HERE;
> >>>>>>>> exit:
> >>>>>>>> return;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> int main()
> >>>>>>>> {
> >>>>>>>> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> _Pm()
> >>>>>>>> [00000a1a](01) 55 push ebp
> >>>>>>>> [00000a1b](02) 8bec mov ebp,esp
> >>>>>>>> [00000a1d](03) 83ec08 sub esp,+08
> >>>>>>>> [00000a20](05) a107030000 mov eax,[00000307]
> >>>>>>>> [00000a25](03) 8945fc mov [ebp-04],eax
> >>>>>>>> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
> >>>>>>>> [00000a2e](03) 83c101 add ecx,+01
> >>>>>>>> [00000a31](06) 890d07030000 mov [00000307],ecx
> >>>>>>>> [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>>>>> [00000a3e](02) 7e02 jng 00000a42
> >>>>>>>> [00000a40](02) eb1b jmp 00000a5d
> >>>>>>>> [00000a42](03) 8b5508 mov edx,[ebp+08]
> >>>>>>>> [00000a45](01) 52 push edx
> >>>>>>>> [00000a46](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>> [00000a49](01) 50 push eax
> >>>>>>>> [00000a4a](05) e8ebfdffff call 0000083a // call H
> >>>>>>>> [00000a4f](03) 83c408 add esp,+08
> >>>>>>>> [00000a52](03) 8945f8 mov [ebp-08],eax
> >>>>>>>> [00000a55](04) 837df800 cmp dword [ebp-08],+00
> >>>>>>>> [00000a59](02) 7402 jz 00000a5d
> >>>>>>>> [00000a5b](02) ebfe jmp 00000a5b
> >>>>>>>> [00000a5d](02) 8be5 mov esp,ebp
> >>>>>>>> [00000a5f](01) 5d pop ebp
> >>>>>>>> [00000a60](01) c3 ret
> >>>>>>>> Size in bytes:(0071) [00000a60]
> >>>>>>>>
> >>>>>>>> _main()
> >>>>>>>> [00000a6a](01) 55 push ebp
> >>>>>>>> [00000a6b](02) 8bec mov ebp,esp
> >>>>>>>> [00000a6d](05) 681a0a0000 push 00000a1a // push address
> >>>>>>>> of P [00000a72](05) 681a0a0000 push 00000a1a // push
> >>>>>>>> address of P [00000a77](05) e8befdffff call 0000083a //
> >>>>>>>> call H [00000a7c](03) 83c408 add esp,+08
> >>>>>>>> [00000a7f](01) 50 push eax
> >>>>>>>> [00000a80](05) 680b030000 push 0000030b
> >>>>>>>> [00000a85](05) e8d0f8ffff call 0000035a
> >>>>>>>> [00000a8a](03) 83c408 add esp,+08
> >>>>>>>> [00000a8d](02) 33c0 xor eax,eax
> >>>>>>>> [00000a8f](01) 5d pop ebp
> >>>>>>>> [00000a90](01) c3 ret
> >>>>>>>> Size in bytes:(0039) [00000a90]
> >>>>>>>>
> >>>>>>>> machine stack stack machine assembly
> >>>>>>>> address address data code language
> >>>>>>>> ======== ======== ======== ========= =============
> >>>>>>>> ...[00000a6a][0010137b][00000000] 55 push ebp
> >>>>>>>> ...[00000a6b][0010137b][00000000] 8bec mov ebp,esp
> >>>>>>>> ...[00000a6d][00101377][00000a1a] 681a0a0000 push
> >>>>>>>> 00000a1a ...[00000a72][00101373][00000a1a] 681a0a0000
> >>>>>>>> push 00000a1a ...[00000a77][0010136f][00000a7c] e8befdffff
> >>>>>>>> call 0000083a New slave_stack at:201427
> >>>>>>>>
> >>>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
> >>>>>>>> at:21142f ...[00000a1a][0021141b][0021141f] 55
> >>>>>>>> push ebp ...[00000a1b][0021141b][0021141f] 8bec
> >>>>>>>> mov ebp,esp ...[00000a1d][00211413][90909090] 83ec08
> >>>>>>>> sub esp,+08 ...[00000a20][00211413][90909090] a107030000
> >>>>>>>> mov eax,[00000307] ...[00000a25][00211413][90909090] 8945fc
> >>>>>>>> mov [ebp-04],eax ...[00000a28][00211413][90909090]
> >>>>>>>> 8b0d07030000 mov ecx,[00000307]
> >>>>>>>> ...[00000a2e][00211413][90909090] 83c101 add ecx,+01
> >>>>>>>> ...[00000a31][00211413][90909090] 890d07030000 mov
> >>>>>>>> [00000307],ecx ...[00000a37][00211413][90909090]
> >>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>>>>> ...[00000a3e][00211413][90909090] 7e02 jng
> >>>>>>>> 00000a42 ...[00000a42][00211413][90909090] 8b5508
> >>>>>>>> mov edx,[ebp+08] ...[00000a45][0021140f][00000a1a] 52 push
> >>>>>>>> edx // push address of P
> >>>>>>>> ...[00000a46][0021140f][00000a1a] 8b4508 mov
> >>>>>>>> eax,[ebp+08] ...[00000a49][0021140b][00000a1a] 50 push eax
> >>>>>>>> // push address of P ...[00000a4a][00211407][00000a4f]
> >>>>>>>> e8ebfdffff call 0000083a // call H New slave_stack
> >>>>>>>> at:24be4f ...[00000a1a][0025be43][0025be47] 55
> >>>>>>>> push ebp ...[00000a1b][0025be43][0025be47] 8bec
> >>>>>>>> mov ebp,esp ...[00000a1d][0025be3b][90909090] 83ec08
> >>>>>>>> sub esp,+08 ...[00000a20][0025be3b][90909090] a107030000
> >>>>>>>> mov eax,[00000307] ...[00000a25][0025be3b][90909090] 8945fc
> >>>>>>>> mov [ebp-04],eax ...[00000a28][0025be3b][90909090]
> >>>>>>>> 8b0d07030000 mov ecx,[00000307]
> >>>>>>>> ...[00000a2e][0025be3b][90909090] 83c101 add ecx,+01
> >>>>>>>> ...[00000a31][0025be3b][90909090] 890d07030000 mov
> >>>>>>>> [00000307],ecx ...[00000a37][0025be3b][90909090]
> >>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>>>>> ...[00000a3e][0025be3b][90909090] 7e02 jng
> >>>>>>>> 00000a42 ...[00000a40][0025be3b][90909090] eb1b
> >>>>>>>> jmp 00000a5d // jmp to exit
> >>>>>>>> ...[00000a5d][0025be43][0025be47] 8be5 mov
> >>>>>>>> esp,ebp ...[00000a5f][0025be47][00000904] 5d
> >>>>>>>> pop ebp ...[00000a60][0025be4b][00000a1a] c3
> >>>>>>>> ret ...[00000a7c][0010137b][00000000] 83c408 add
> >>>>>>>> esp,+08 ...[00000a7f][00101377][00000001] 50
> >>>>>>>> push eax ...[00000a80][00101373][0000030b] 680b030000
> >>>>>>>> push 0000030b ---[00000a85][00101373][0000030b] e8d0f8ffff
> >>>>>>>> call 0000035a Input_Halts = 1
> >>>>>>>> ...[00000a8a][0010137b][00000000] 83c408 add
> >>>>>>>> esp,+08 ...[00000a8d][0010137b][00000000] 33c0
> >>>>>>>> xor eax,eax ...[00000a8f][0010137f][00100000] 5d
> >>>>>>>> pop ebp ...[00000a90][00101383][00000004] c3
> >>>>>>>> ret Number of Instructions Executed(27278)
> >>>>>>>
> >>>>>>> Still seems wrong: post increment of the static variable
> >>>>>>> should ensure that it does NOT goto exit but instead should
> >>>>>>> call H which should presumably cause your "infinite recursion
> >>>>>>> detected" bollocks to manifest.
> >>>>>>
> >>>>>> OK, I've looked at your assembly trace and it is recursing
> >>>>>> into Pm from H and then halting but I am not sure what you are
> >>>>>> trying to prove? Again [Strachey 1965] and associated proofs
> >>>>>> are not recursive in nature.
> >>>>>>
> >>>>>> /Flibble
> >>>>>
> >>>>> (1) H cannot correctly determine the halt status of the HP
> >>>>> counter-examples unless H is a simulating halt decider.
> >>>>>
> >>>>> (2) The claim of the halting problem proofs is that no H in the
> >>>>> universe can possibly correctly determine the halt status of its
> >>>>> corresponding pathological input.
> >>>>>
> >>>>> (3) H(P,P) does correctly determine that its correponding
> >>>>> pathological input would never halt.
> >>>>>
> >>>>> (4) It is ridiculously stupid of you to say that [Strachey 1965]
> >>>>> does not specify infinitely recursive simulation when it is an
> >>>>> easily verified fact that when Strachey T <is> a simulating halt
> >>>>> decider that Strachey P <does> specify infinitely recursive
> >>>>> simulation.
> >>>>>
> >>>>> It does not say this directly in [Strachey 1965] only because no
> >>>>> one ever previously bothered to fully examine the effect of a
> >>>>> simulating halt decider on the HP's pathological inputs.
> >>>>
> >>>> I see I have to repeat myself yet again: a simulating halt
> >>>> decider needn't be recursive in nature and I have sketched a
> >>>> design of such a halt decider:
> >>>>
> >>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>>
> >>>> You are incorrect to claim an equivalence between pathological
> >>>> input and non-halting.
> >>>>
> >>>> /Flibble
> >>>>
> >>>
> >>> 19 When the simulator detects the call to H in P it forks the
> >>> simulation 20 into a non-halting branch (returning 0 to P) and a
> >>> halting branch 21 (returning 1 to P)
> >>>
> >>> Software engineers at the low end of technical competence may not
> >>> fully comprehend the common knowledge that:
> >>>
> >>> Whenever a function is called in what is essentially infinite
> >>> recursion this function cannot possibly correctly return any
> >>> value to its caller. You don't seem to understand that.
> >>
> >> Why are you so fucking obtuse? My forking simulating decider IS NOT
> >> RECURSIVE.
> >
> > It is directly disobeying the actual behavior specified by the
> > actual input by returning a value to a function that called it in
> > infinite recursion.
> >
> >
>
> Even if we did accept that your pathological self-reference detector
> is valid it is only a copycat of my idea and it provides a weaker
> result. It answers: I don't know and mine answers: non-halting.
I could trivially change my decider to return a decision of non-halting
instead of signaling an exception if I believed such a mapping was
correct, but I don't, so I won't.
>
> Because you did not even copycat my criteria correctly your H gets
> the wrong answer on this input.
>
> int add(int N)
> {
> return N + 3;
> }
>
> void Pc(ptr x)
> {
> H(add, (ptr)7);
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H(Pc,Pc));
> }
My decider would correctly answer that Pc halts: passing a different
input to H would be equivalent to the call to H from main(), i.e. it
would be a function call rather than a fork detection: forks only
happen if H is called with the same input more than once.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2022-07-15 14:04 -0500 |
| Message-ID | <y6qdnTUA2dGqJ0z_nZ2dnUU7_83NnZ2d@giganews.com> |
| In reply to | #85265 |
On 7/15/2022 1:41 PM, Mr Flibble wrote:
> On Fri, 15 Jul 2022 13:31:50 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/15/2022 1:17 PM, olcott wrote:
>>> On 7/15/2022 1:04 PM, Mr Flibble wrote:
>>>> On Fri, 15 Jul 2022 12:57:53 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>>> On 7/15/2022 12:46 PM, Mr Flibble wrote:
>>>>>> On Fri, 15 Jul 2022 12:39:31 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 7/15/2022 12:28 PM, Mr Flibble wrote:
>>>>>>>> On Fri, 15 Jul 2022 18:08:22 +0100
>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
>>>>>>>>> On Fri, 15 Jul 2022 12:00:59 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 15 Jul 2022 10:58:14 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> This is an explanation of a key new insight
>>>>>>>>>>>>>>>>>>>>>>>>>> into the halting problem provided in the
>>>>>>>>>>>>>>>>>>>>>>>>>> language of software engineering. Technical
>>>>>>>>>>>>>>>>>>>>>>>>>> computer science terms are explained using
>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering terms. No knowledge of
>>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem is required.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is based on fully operational software
>>>>>>>>>>>>>>>>>>>>>>>>>> executed in the x86utm operating system. The
>>>>>>>>>>>>>>>>>>>>>>>>>> x86utm operating system (based on an
>>>>>>>>>>>>>>>>>>>>>>>>>> excellent open source x86 emulator) was
>>>>>>>>>>>>>>>>>>>>>>>>>> created to study the details of the halting
>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof counter-examples at the much
>>>>>>>>>>>>>>>>>>>>>>>>>> higher level of abstraction of C/x86.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P,
>>>>>>>>>>>>>>>>>>>>>>>>>> P)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P) simulates
>>>>>>>>>>>>>>>>>>>>>>>>>> its input we can see that: (1) Function H()
>>>>>>>>>>>>>>>>>>>>>>>>>> is called from P(). (2) With the same
>>>>>>>>>>>>>>>>>>>>>>>>>> arguments to H(). (3) With no instructions
>>>>>>>>>>>>>>>>>>>>>>>>>> in P preceding its invocation of H(P,P).
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The above shows that the simulated P cannot
>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. Because H can
>>>>>>>>>>>>>>>>>>>>>>>>>> see the same (1)(2)(3) that we see H aborts
>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation of P and rejects P as
>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> In computability theory, the
>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem is the problem of
>>>>>>>>>>>>>>>>>>>>>>>>>> determining, from a description of an
>>>>>>>>>>>>>>>>>>>>>>>>>> arbitrary computer program and an input,
>>>>>>>>>>>>>>>>>>>>>>>>>> whether the program will finish running, or
>>>>>>>>>>>>>>>>>>>>>>>>>> continue to run forever. Alan Turing proved
>>>>>>>>>>>>>>>>>>>>>>>>>> in 1936 that a general algorithm to solve
>>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem for all possible
>>>>>>>>>>>>>>>>>>>>>>>>>> program- input pairs cannot exist.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> For any program H that might
>>>>>>>>>>>>>>>>>>>>>>>>>> determine if programs halt, a "pathological"
>>>>>>>>>>>>>>>>>>>>>>>>>> program P, called with some input, can pass
>>>>>>>>>>>>>>>>>>>>>>>>>> its own source and its input to H and then
>>>>>>>>>>>>>>>>>>>>>>>>>> specifically do the opposite of what H
>>>>>>>>>>>>>>>>>>>>>>>>>> predicts P will do. No H can exist that
>>>>>>>>>>>>>>>>>>>>>>>>>> handles this case.
>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
>>>>>>>>>>>>>>>>>>>>>>>>>> relationship to each other as described
>>>>>>>>>>>>>>>>>>>>>>>>>> above. Because H(P,P) does handle this case
>>>>>>>>>>>>>>>>>>>>>>>>>> the above halting problem undecidable input
>>>>>>>>>>>>>>>>>>>>>>>>>> template has been refuted.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *When this halt deciding principle
>>>>>>>>>>>>>>>>>>>>>>>>>> understood to be correct* A halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>> must compute the mapping from its inputs to
>>>>>>>>>>>>>>>>>>>>>>>>>> an accept or reject state on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior that is actually
>>>>>>>>>>>>>>>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this implements
>>>>>>>>>>>>>>>>>>>>>>>>>> that principle* Every simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly simulates its input until it
>>>>>>>>>>>>>>>>>>>>>>>>>> correctly predicts that this simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>> would never terminate normally, correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> rejects this input as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *H is a Pure function*
>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the basis
>>>>>>>>>>>>>>>>>>>>>>>>>> of software engineering*
>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion
>>>>>>>>>>>>>>>>>>>>>>>>> which I suppose is progress.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I have shown that H/P does implement the HP's
>>>>>>>>>>>>>>>>>>>>>>>> "impossible input" template.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting
>>>>>>>>>>>>>>>>>>>>>>>> problem proofs that rely on this template.
>>>>>>>>>>>>>>>>>>>>>>> Equating pathological input with non-halting is
>>>>>>>>>>>>>>>>>>>>>>> erroneous: you are only doing that because your
>>>>>>>>>>>>>>>>>>>>>>> broken solution treats it as "infinite
>>>>>>>>>>>>>>>>>>>>>>> recursion". There is no recursion in [Strachey
>>>>>>>>>>>>>>>>>>>>>>> 1965] and the HP proofs based on it.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> There is no recursion in any of the conventional
>>>>>>>>>>>>>>>>>>>>>> proofs only because no one ever previously
>>>>>>>>>>>>>>>>>>>>>> bothered to fully examine how a simulating halt
>>>>>>>>>>>>>>>>>>>>>> decider would address these otherwise
>>>>>>>>>>>>>>>>>>>>>> "impossible" inputs.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I have shown that a simulating halt decider
>>>>>>>>>>>>>>>>>>>>> needn't be recursive in nature:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You sure do make it easy to review your work.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> "When the simulator detects the call to
>>>>>>>>>>>>>>>>>>>> H in P it forks the simulation into a non-halting
>>>>>>>>>>>>>>>>>>>> branch"
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> There is an infinite set of cases where this overly
>>>>>>>>>>>>>>>>>>>> simplistic criteria gets the wrong answer.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That is neither an honest review or any kind of
>>>>>>>>>>>>>>>>>>> rebuttal: I have told you before: assertions made
>>>>>>>>>>>>>>>>>>> without evidence can be dismissed without evidence.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If you claim there are an infinite number of cases
>>>>>>>>>>>>>>>>>>> where it gets the wrong answer then it shouldn't be
>>>>>>>>>>>>>>>>>>> too hard for to provide ONE case backing up your
>>>>>>>>>>>>>>>>>>> claim.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>> Sure:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> static int count = 3;
>>>>>>>>>>>>>>>>>> count--;
>>>>>>>>>>>>>>>>>> if (!count) goto exit;
>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>> exit:
>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>> Nope; you seem to have forgotten that my decider is
>>>>>>>>>>>>>>>>> not recursive in nature: my decider will correctly
>>>>>>>>>>>>>>>>> determine that that input is pathological so will
>>>>>>>>>>>>>>>>> signal an exception.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The above terminates normally so your decider gets the
>>>>>>>>>>>>>>>> wrong answer.
>>>>>>>>>>>>>>> It is a pathological input so neither halts nor doesn't
>>>>>>>>>>>>>>> halt: pathological input is INVALID so the correct
>>>>>>>>>>>>>>> "answer" is to signal an exception.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So you don't know how static variables work?
>>>>>>>>>>>>>> I am not surprised.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> static int count = 0;
>>>>>>>>>>>>>> if (count++ >= 2) goto exit;
>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>> exit:
>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> Output("Input_Halts = ", H(P,P));
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _Pm()
>>>>>>>>>>>>>> [0000141e](01) 55 push ebp
>>>>>>>>>>>>>> [0000141f](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [00001421](03) 83ec08 sub esp,+08
>>>>>>>>>>>>>> [00001424](05) a100000000 mov eax,[00000000]
>>>>>>>>>>>>>> [00001429](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
>>>>>>>>>>>>>> [00001432](03) 83c101 add ecx,+01
>>>>>>>>>>>>>> [00001435](06) 890d00000000 mov [00000000],ecx
>>>>>>>>>>>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
>>>>>>>>>>>>>> [0000143f](02) 7c02 jl 00001443
>>>>>>>>>>>>>> [00001441](02) eb1b jmp 0000145e
>>>>>>>>>>>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
>>>>>>>>>>>>>> [00001446](01) 52 push edx
>>>>>>>>>>>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>> [0000144a](01) 50 push eax
>>>>>>>>>>>>>> [0000144b](05) e8defcffff call 0000112e
>>>>>>>>>>>>>> [00001450](03) 83c408 add esp,+08
>>>>>>>>>>>>>> [00001453](03) 8945f8 mov [ebp-08],eax
>>>>>>>>>>>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
>>>>>>>>>>>>>> [0000145a](02) 7402 jz 0000145e
>>>>>>>>>>>>>> [0000145c](02) ebfe jmp 0000145c
>>>>>>>>>>>>>> [0000145e](02) 8be5 mov esp,ebp
>>>>>>>>>>>>>> [00001460](01) 5d pop ebp
>>>>>>>>>>>>>> [00001461](01) c3 ret
>>>>>>>>>>>>>> Size in bytes:(0068) [00001461]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>> [0000146e](01) 55 push ebp
>>>>>>>>>>>>>> [0000146f](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [00001471](05) 681e140000 push 0000141e
>>>>>>>>>>>>>> [00001476](05) 681e140000 push 0000141e
>>>>>>>>>>>>>> [0000147b](05) e8aefcffff call 0000112e
>>>>>>>>>>>>>> [00001480](03) 83c408 add esp,+08
>>>>>>>>>>>>>> [00001483](01) 50 push eax
>>>>>>>>>>>>>> [00001484](05) 685f050000 push 0000055f
>>>>>>>>>>>>>> [00001489](05) e820f1ffff call 000005ae
>>>>>>>>>>>>>> [0000148e](03) 83c408 add esp,+08
>>>>>>>>>>>>>> [00001491](02) 33c0 xor eax,eax
>>>>>>>>>>>>>> [00001493](01) 5d pop ebp
>>>>>>>>>>>>>> [00001494](01) c3 ret
>>>>>>>>>>>>>> Size in bytes:(0039) [00001494]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>>>>> address address data code language
>>>>>>>>>>>>>> ======== ======== ======== =========
>>>>>>>>>>>>>> ============= [0000146e][00102462][00000000] 55
>>>>>>>>>>>>>> push ebp [0000146f][00102462][00000000] 8bec
>>>>>>>>>>>>>> mov ebp,esp [00001471][0010245e][0000141e] 681e140000
>>>>>>>>>>>>>> push 0000141e [00001476][0010245a][0000141e] 681e140000
>>>>>>>>>>>>>> push 0000141e [0000147b][00102456][00001480] e8aefcffff
>>>>>>>>>>>>>> call 0000112e
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:11250e
>>>>>>>>>>>>>> Address_of_H:112e
>>>>>>>>>>>>>> [0000141e][001124fa][001124fe] 55 push ebp
>>>>>>>>>>>>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
>>>>>>>>>>>>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
>>>>>>>>>>>>>> [00001424][001124f2][90909090] a100000000 mov
>>>>>>>>>>>>>> eax,[00000000] [00001429][001124f2][90909090] 8945fc
>>>>>>>>>>>>>> mov [ebp-04],eax [0000142c][001124f2][90909090]
>>>>>>>>>>>>>> 8b0d00000000 mov ecx,[00000000]
>>>>>>>>>>>>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
>>>>>>>>>>>>>> [00001435][001124f2][90909090] 890d00000000 mov
>>>>>>>>>>>>>> [00000000],ecx [0000143b][001124f2][90909090] 837dfc02
>>>>>>>>>>>>>> cmp dword [ebp-04],+02 [0000143f][001124f2][90909090]
>>>>>>>>>>>>>> 7c02 jl 00001443 [00001441][001124f2][90909090] eb1b
>>>>>>>>>>>>>> jmp 0000145e [0000145e][001124fa][001124fe] 8be5
>>>>>>>>>>>>>> mov esp,ebp [00001460][001124fe][00001217] 5d
>>>>>>>>>>>>>> pop ebp [00001461][00112502][0000141e] c3 ret
>>>>>>>>>>>>>> H: End Simulation Input Terminated Normally
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> [00001480][00102462][00000000] 83c408 add esp,+08
>>>>>>>>>>>>>> [00001483][0010245e][00000001] 50 push eax
>>>>>>>>>>>>>> [00001484][0010245a][0000055f] 685f050000 push 0000055f
>>>>>>>>>>>>>> [00001489][0010245a][0000055f] e820f1ffff call 000005ae
>>>>>>>>>>>>>> Input_Halts = 1
>>>>>>>>>>>>>> [0000148e][00102462][00000000] 83c408 add esp,+08
>>>>>>>>>>>>>> [00001491][00102462][00000000] 33c0 xor eax,eax
>>>>>>>>>>>>>> [00001493][00102466][00000018] 5d pop ebp
>>>>>>>>>>>>>> [00001494][0010246a][00000000] c3 ret
>>>>>>>>>>>>>> Number of Instructions Executed(1317) == 20 Pages
>>>>>>>>>>>>>
>>>>>>>>>>>>> For this particular stack trace I notice that the function
>>>>>>>>>>>>> symbol at the top of it is Pm not P which suggests to me
>>>>>>>>>>>>> one of two things:
>>>>>>>>>>>>
>>>>>>>>>>>> I already had a P so I renamed it to Pm so it would not
>>>>>>>>>>>> disturb my existing code. When I changed all the Pm
>>>>>>>>>>>> references to your name I forgot one.
>>>>>>>>>>>
>>>>>>>>>>> Then I suggest you check the output of compilation/linking
>>>>>>>>>>> is actually initializing static variables correctly. Are
>>>>>>>>>>> you even using a linker or are you just executing an object
>>>>>>>>>>> file? Static data normally goes into a separate data
>>>>>>>>>>> segment during the linking process.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> I haven't used static data in such a long time that I forgot
>>>>>>>>>> the compiler does not allocate any space for static
>>>>>>>>>> variables unless they have been initialized to a non-zero
>>>>>>>>>> value.
>>>>>>>>>>
>>>>>>>>>> void Pm(u32 x)
>>>>>>>>>> {
>>>>>>>>>> static int count = 0x777;
>>>>>>>>>> if (count++ > 0x777) goto exit;
>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>> if (Halt_Status)
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> exit:
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> _Pm()
>>>>>>>>>> [00000a1a](01) 55 push ebp
>>>>>>>>>> [00000a1b](02) 8bec mov ebp,esp
>>>>>>>>>> [00000a1d](03) 83ec08 sub esp,+08
>>>>>>>>>> [00000a20](05) a107030000 mov eax,[00000307]
>>>>>>>>>> [00000a25](03) 8945fc mov [ebp-04],eax
>>>>>>>>>> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
>>>>>>>>>> [00000a2e](03) 83c101 add ecx,+01
>>>>>>>>>> [00000a31](06) 890d07030000 mov [00000307],ecx
>>>>>>>>>> [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>>>>> [00000a3e](02) 7e02 jng 00000a42
>>>>>>>>>> [00000a40](02) eb1b jmp 00000a5d
>>>>>>>>>> [00000a42](03) 8b5508 mov edx,[ebp+08]
>>>>>>>>>> [00000a45](01) 52 push edx
>>>>>>>>>> [00000a46](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>> [00000a49](01) 50 push eax
>>>>>>>>>> [00000a4a](05) e8ebfdffff call 0000083a // call H
>>>>>>>>>> [00000a4f](03) 83c408 add esp,+08
>>>>>>>>>> [00000a52](03) 8945f8 mov [ebp-08],eax
>>>>>>>>>> [00000a55](04) 837df800 cmp dword [ebp-08],+00
>>>>>>>>>> [00000a59](02) 7402 jz 00000a5d
>>>>>>>>>> [00000a5b](02) ebfe jmp 00000a5b
>>>>>>>>>> [00000a5d](02) 8be5 mov esp,ebp
>>>>>>>>>> [00000a5f](01) 5d pop ebp
>>>>>>>>>> [00000a60](01) c3 ret
>>>>>>>>>> Size in bytes:(0071) [00000a60]
>>>>>>>>>>
>>>>>>>>>> _main()
>>>>>>>>>> [00000a6a](01) 55 push ebp
>>>>>>>>>> [00000a6b](02) 8bec mov ebp,esp
>>>>>>>>>> [00000a6d](05) 681a0a0000 push 00000a1a // push address
>>>>>>>>>> of P [00000a72](05) 681a0a0000 push 00000a1a // push
>>>>>>>>>> address of P [00000a77](05) e8befdffff call 0000083a //
>>>>>>>>>> call H [00000a7c](03) 83c408 add esp,+08
>>>>>>>>>> [00000a7f](01) 50 push eax
>>>>>>>>>> [00000a80](05) 680b030000 push 0000030b
>>>>>>>>>> [00000a85](05) e8d0f8ffff call 0000035a
>>>>>>>>>> [00000a8a](03) 83c408 add esp,+08
>>>>>>>>>> [00000a8d](02) 33c0 xor eax,eax
>>>>>>>>>> [00000a8f](01) 5d pop ebp
>>>>>>>>>> [00000a90](01) c3 ret
>>>>>>>>>> Size in bytes:(0039) [00000a90]
>>>>>>>>>>
>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>> address address data code language
>>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>>> ...[00000a6a][0010137b][00000000] 55 push ebp
>>>>>>>>>> ...[00000a6b][0010137b][00000000] 8bec mov ebp,esp
>>>>>>>>>> ...[00000a6d][00101377][00000a1a] 681a0a0000 push
>>>>>>>>>> 00000a1a ...[00000a72][00101373][00000a1a] 681a0a0000
>>>>>>>>>> push 00000a1a ...[00000a77][0010136f][00000a7c] e8befdffff
>>>>>>>>>> call 0000083a New slave_stack at:201427
>>>>>>>>>>
>>>>>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>>>>>>>>> at:21142f ...[00000a1a][0021141b][0021141f] 55
>>>>>>>>>> push ebp ...[00000a1b][0021141b][0021141f] 8bec
>>>>>>>>>> mov ebp,esp ...[00000a1d][00211413][90909090] 83ec08
>>>>>>>>>> sub esp,+08 ...[00000a20][00211413][90909090] a107030000
>>>>>>>>>> mov eax,[00000307] ...[00000a25][00211413][90909090] 8945fc
>>>>>>>>>> mov [ebp-04],eax ...[00000a28][00211413][90909090]
>>>>>>>>>> 8b0d07030000 mov ecx,[00000307]
>>>>>>>>>> ...[00000a2e][00211413][90909090] 83c101 add ecx,+01
>>>>>>>>>> ...[00000a31][00211413][90909090] 890d07030000 mov
>>>>>>>>>> [00000307],ecx ...[00000a37][00211413][90909090]
>>>>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>>>>> ...[00000a3e][00211413][90909090] 7e02 jng
>>>>>>>>>> 00000a42 ...[00000a42][00211413][90909090] 8b5508
>>>>>>>>>> mov edx,[ebp+08] ...[00000a45][0021140f][00000a1a] 52 push
>>>>>>>>>> edx // push address of P
>>>>>>>>>> ...[00000a46][0021140f][00000a1a] 8b4508 mov
>>>>>>>>>> eax,[ebp+08] ...[00000a49][0021140b][00000a1a] 50 push eax
>>>>>>>>>> // push address of P ...[00000a4a][00211407][00000a4f]
>>>>>>>>>> e8ebfdffff call 0000083a // call H New slave_stack
>>>>>>>>>> at:24be4f ...[00000a1a][0025be43][0025be47] 55
>>>>>>>>>> push ebp ...[00000a1b][0025be43][0025be47] 8bec
>>>>>>>>>> mov ebp,esp ...[00000a1d][0025be3b][90909090] 83ec08
>>>>>>>>>> sub esp,+08 ...[00000a20][0025be3b][90909090] a107030000
>>>>>>>>>> mov eax,[00000307] ...[00000a25][0025be3b][90909090] 8945fc
>>>>>>>>>> mov [ebp-04],eax ...[00000a28][0025be3b][90909090]
>>>>>>>>>> 8b0d07030000 mov ecx,[00000307]
>>>>>>>>>> ...[00000a2e][0025be3b][90909090] 83c101 add ecx,+01
>>>>>>>>>> ...[00000a31][0025be3b][90909090] 890d07030000 mov
>>>>>>>>>> [00000307],ecx ...[00000a37][0025be3b][90909090]
>>>>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>>>>> ...[00000a3e][0025be3b][90909090] 7e02 jng
>>>>>>>>>> 00000a42 ...[00000a40][0025be3b][90909090] eb1b
>>>>>>>>>> jmp 00000a5d // jmp to exit
>>>>>>>>>> ...[00000a5d][0025be43][0025be47] 8be5 mov
>>>>>>>>>> esp,ebp ...[00000a5f][0025be47][00000904] 5d
>>>>>>>>>> pop ebp ...[00000a60][0025be4b][00000a1a] c3
>>>>>>>>>> ret ...[00000a7c][0010137b][00000000] 83c408 add
>>>>>>>>>> esp,+08 ...[00000a7f][00101377][00000001] 50
>>>>>>>>>> push eax ...[00000a80][00101373][0000030b] 680b030000
>>>>>>>>>> push 0000030b ---[00000a85][00101373][0000030b] e8d0f8ffff
>>>>>>>>>> call 0000035a Input_Halts = 1
>>>>>>>>>> ...[00000a8a][0010137b][00000000] 83c408 add
>>>>>>>>>> esp,+08 ...[00000a8d][0010137b][00000000] 33c0
>>>>>>>>>> xor eax,eax ...[00000a8f][0010137f][00100000] 5d
>>>>>>>>>> pop ebp ...[00000a90][00101383][00000004] c3
>>>>>>>>>> ret Number of Instructions Executed(27278)
>>>>>>>>>
>>>>>>>>> Still seems wrong: post increment of the static variable
>>>>>>>>> should ensure that it does NOT goto exit but instead should
>>>>>>>>> call H which should presumably cause your "infinite recursion
>>>>>>>>> detected" bollocks to manifest.
>>>>>>>>
>>>>>>>> OK, I've looked at your assembly trace and it is recursing
>>>>>>>> into Pm from H and then halting but I am not sure what you are
>>>>>>>> trying to prove? Again [Strachey 1965] and associated proofs
>>>>>>>> are not recursive in nature.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> (1) H cannot correctly determine the halt status of the HP
>>>>>>> counter-examples unless H is a simulating halt decider.
>>>>>>>
>>>>>>> (2) The claim of the halting problem proofs is that no H in the
>>>>>>> universe can possibly correctly determine the halt status of its
>>>>>>> corresponding pathological input.
>>>>>>>
>>>>>>> (3) H(P,P) does correctly determine that its correponding
>>>>>>> pathological input would never halt.
>>>>>>>
>>>>>>> (4) It is ridiculously stupid of you to say that [Strachey 1965]
>>>>>>> does not specify infinitely recursive simulation when it is an
>>>>>>> easily verified fact that when Strachey T <is> a simulating halt
>>>>>>> decider that Strachey P <does> specify infinitely recursive
>>>>>>> simulation.
>>>>>>>
>>>>>>> It does not say this directly in [Strachey 1965] only because no
>>>>>>> one ever previously bothered to fully examine the effect of a
>>>>>>> simulating halt decider on the HP's pathological inputs.
>>>>>>
>>>>>> I see I have to repeat myself yet again: a simulating halt
>>>>>> decider needn't be recursive in nature and I have sketched a
>>>>>> design of such a halt decider:
>>>>>>
>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>>>
>>>>>> You are incorrect to claim an equivalence between pathological
>>>>>> input and non-halting.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> 19 When the simulator detects the call to H in P it forks the
>>>>> simulation 20 into a non-halting branch (returning 0 to P) and a
>>>>> halting branch 21 (returning 1 to P)
>>>>>
>>>>> Software engineers at the low end of technical competence may not
>>>>> fully comprehend the common knowledge that:
>>>>>
>>>>> Whenever a function is called in what is essentially infinite
>>>>> recursion this function cannot possibly correctly return any
>>>>> value to its caller. You don't seem to understand that.
>>>>
>>>> Why are you so fucking obtuse? My forking simulating decider IS NOT
>>>> RECURSIVE.
>>>
>>> It is directly disobeying the actual behavior specified by the
>>> actual input by returning a value to a function that called it in
>>> infinite recursion.
>>>
>>>
>>
>> Even if we did accept that your pathological self-reference detector
>> is valid it is only a copycat of my idea and it provides a weaker
>> result. It answers: I don't know and mine answers: non-halting.
>
> I could trivially change my decider to return a decision of non-halting
> instead of signaling an exception if I believed such a mapping was
> correct, but I don't, so I won't.
>
>>
>> Because you did not even copycat my criteria correctly your H gets
>> the wrong answer on this input.
>>
>> int add(int N)
>> {
>> return N + 3;
>> }
>>
>> void Pc(ptr x)
>> {
>> H(add, (ptr)7);
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(Pc,Pc));
>> }
>
> My decider would correctly answer that Pc halts: passing a different
> input to H would be equivalent to the call to H from main(), i.e. it
> would be a function call rather than a fork detection: forks only
> happen if H is called with the same input more than once.
>
> /Flibble
>
https://github.com/i42output/halting-problem/blob/main/README.txt
You did not bother to copycat my criteria: "with the same input"
therefore your specification fails the above test.
When simulating halt decider H(P,P) simulates its input we can see that:
(1) Function H() is called from P().
(2) With the same arguments to H().
(3) With no instructions in P preceding its invocation of H(P,P).
As already shown before you also did not bother to copycat my criteria
(3) which provides another escape route from non-termination.
When you add these crriteria I insist on a reference to my copyright
notice for these criteria.
*Halting problem proofs refuted on the basis of software engineering*
https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
A copy of your github post as of 2022-07-15 1:58 PM CDT
Hi!
I have an idea for a simulating halt decider that forks the
simulation into two branches if the input calls the halt decider as
per [Strachey 1965]'s "Impossible Program":
void P(void (*x)())
{
if (H(x, x))
infinite_loop: goto infinite_loop;
return;
}
int main()
{
std::cout << "Input halts: " << H(P, P) << std::endl;
}
*When the simulator detects the call to H in P* it forks the simulation
into a non-halting branch (returning 0 to P) and a halting branch
(returning 1 to P) and continues the simulation of these two branches
in parallel.
If the non-halting branch is determined to halt AND the halting branch
is determined to not halt then pathology is detected and reported.
If EITHER branch is determined to be correctly decided then that will
be the decision of the halting decider.
Crucially this scheme will handle (and correctly decide) the
following case whereby the result of H is discarded by the input:
void Px(void (*x)())
{
(void) H(x, x);
return;
}
Thoughts? I am probably missing something obvious.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-07-15 20:11 +0100 |
| Message-ID | <20220715201115.000077ac@reddwarf.jmc.corp> |
| In reply to | #85268 |
On Fri, 15 Jul 2022 14:04:22 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/15/2022 1:41 PM, Mr Flibble wrote:
> > On Fri, 15 Jul 2022 13:31:50 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 7/15/2022 1:17 PM, olcott wrote:
> >>> On 7/15/2022 1:04 PM, Mr Flibble wrote:
> >>>> On Fri, 15 Jul 2022 12:57:53 -0500
> >>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>
> >>>>> On 7/15/2022 12:46 PM, Mr Flibble wrote:
> >>>>>> On Fri, 15 Jul 2022 12:39:31 -0500
> >>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>> On 7/15/2022 12:28 PM, Mr Flibble wrote:
> >>>>>>>> On Fri, 15 Jul 2022 18:08:22 +0100
> >>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
> >>>>>>>>> On Fri, 15 Jul 2022 12:00:59 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 15 Jul 2022 10:58:14 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
> >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
> >>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
> >>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
> >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
> >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
> >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> This is an explanation of a key new insight
> >>>>>>>>>>>>>>>>>>>>>>>>>> into the halting problem provided in the
> >>>>>>>>>>>>>>>>>>>>>>>>>> language of software engineering. Technical
> >>>>>>>>>>>>>>>>>>>>>>>>>> computer science terms are explained using
> >>>>>>>>>>>>>>>>>>>>>>>>>> software engineering terms. No knowledge of
> >>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem is required.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> It is based on fully operational software
> >>>>>>>>>>>>>>>>>>>>>>>>>> executed in the x86utm operating system.
> >>>>>>>>>>>>>>>>>>>>>>>>>> The x86utm operating system (based on an
> >>>>>>>>>>>>>>>>>>>>>>>>>> excellent open source x86 emulator) was
> >>>>>>>>>>>>>>>>>>>>>>>>>> created to study the details of the halting
> >>>>>>>>>>>>>>>>>>>>>>>>>> problem proof counter-examples at the much
> >>>>>>>>>>>>>>>>>>>>>>>>>> higher level of abstraction of C/x86.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt
> >>>>>>>>>>>>>>>>>>>>>>>>>> decider
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
> >>>>>>>>>>>>>>>>>>>>>>>>>> H(P, P)); }
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input we can see that: (1)
> >>>>>>>>>>>>>>>>>>>>>>>>>> Function H() is called from P(). (2) With
> >>>>>>>>>>>>>>>>>>>>>>>>>> the same arguments to H(). (3) With no
> >>>>>>>>>>>>>>>>>>>>>>>>>> instructions in P preceding its invocation
> >>>>>>>>>>>>>>>>>>>>>>>>>> of H(P,P).
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> The above shows that the simulated P cannot
> >>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. Because H can
> >>>>>>>>>>>>>>>>>>>>>>>>>> see the same (1)(2)(3) that we see H aborts
> >>>>>>>>>>>>>>>>>>>>>>>>>> its simulation of P and rejects P as
> >>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> In computability theory,
> >>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem is the problem of
> >>>>>>>>>>>>>>>>>>>>>>>>>> determining, from a description of an
> >>>>>>>>>>>>>>>>>>>>>>>>>> arbitrary computer program and an input,
> >>>>>>>>>>>>>>>>>>>>>>>>>> whether the program will finish running, or
> >>>>>>>>>>>>>>>>>>>>>>>>>> continue to run forever. Alan Turing proved
> >>>>>>>>>>>>>>>>>>>>>>>>>> in 1936 that a general algorithm to solve
> >>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem for all possible
> >>>>>>>>>>>>>>>>>>>>>>>>>> program- input pairs cannot exist.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> For any program H that
> >>>>>>>>>>>>>>>>>>>>>>>>>> might determine if programs halt, a
> >>>>>>>>>>>>>>>>>>>>>>>>>> "pathological" program P, called with some
> >>>>>>>>>>>>>>>>>>>>>>>>>> input, can pass its own source and its
> >>>>>>>>>>>>>>>>>>>>>>>>>> input to H and then specifically do the
> >>>>>>>>>>>>>>>>>>>>>>>>>> opposite of what H predicts P will do. No
> >>>>>>>>>>>>>>>>>>>>>>>>>> H can exist that handles this case.
> >>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
> >>>>>>>>>>>>>>>>>>>>>>>>>> relationship to each other as described
> >>>>>>>>>>>>>>>>>>>>>>>>>> above. Because H(P,P) does handle this case
> >>>>>>>>>>>>>>>>>>>>>>>>>> the above halting problem undecidable input
> >>>>>>>>>>>>>>>>>>>>>>>>>> template has been refuted.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> *When this halt deciding principle
> >>>>>>>>>>>>>>>>>>>>>>>>>> understood to be correct* A halt decider
> >>>>>>>>>>>>>>>>>>>>>>>>>> must compute the mapping from its inputs to
> >>>>>>>>>>>>>>>>>>>>>>>>>> an accept or reject state on the basis of
> >>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior that is actually
> >>>>>>>>>>>>>>>>>>>>>>>>>> specified by these inputs.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this
> >>>>>>>>>>>>>>>>>>>>>>>>>> implements that principle* Every
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider that correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input until it correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>> predicts that this simulated input would
> >>>>>>>>>>>>>>>>>>>>>>>>>> never terminate normally, correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>> rejects this input as non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> *H is a Pure function*
> >>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
> >>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the
> >>>>>>>>>>>>>>>>>>>>>>>>>> basis of software engineering*
> >>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion
> >>>>>>>>>>>>>>>>>>>>>>>>> which I suppose is progress.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> I have shown that H/P does implement the HP's
> >>>>>>>>>>>>>>>>>>>>>>>> "impossible input" template.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting
> >>>>>>>>>>>>>>>>>>>>>>>> problem proofs that rely on this template.
> >>>>>>>>>>>>>>>>>>>>>>> Equating pathological input with non-halting
> >>>>>>>>>>>>>>>>>>>>>>> is erroneous: you are only doing that because
> >>>>>>>>>>>>>>>>>>>>>>> your broken solution treats it as "infinite
> >>>>>>>>>>>>>>>>>>>>>>> recursion". There is no recursion in [Strachey
> >>>>>>>>>>>>>>>>>>>>>>> 1965] and the HP proofs based on it.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> There is no recursion in any of the
> >>>>>>>>>>>>>>>>>>>>>> conventional proofs only because no one ever
> >>>>>>>>>>>>>>>>>>>>>> previously bothered to fully examine how a
> >>>>>>>>>>>>>>>>>>>>>> simulating halt decider would address these
> >>>>>>>>>>>>>>>>>>>>>> otherwise "impossible" inputs.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> I have shown that a simulating halt decider
> >>>>>>>>>>>>>>>>>>>>> needn't be recursive in nature:
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> You sure do make it easy to review your work.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> "When the simulator detects the call
> >>>>>>>>>>>>>>>>>>>> to H in P it forks the simulation into a
> >>>>>>>>>>>>>>>>>>>> non-halting branch"
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> There is an infinite set of cases where this
> >>>>>>>>>>>>>>>>>>>> overly simplistic criteria gets the wrong
> >>>>>>>>>>>>>>>>>>>> answer.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> That is neither an honest review or any kind of
> >>>>>>>>>>>>>>>>>>> rebuttal: I have told you before: assertions made
> >>>>>>>>>>>>>>>>>>> without evidence can be dismissed without
> >>>>>>>>>>>>>>>>>>> evidence.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> If you claim there are an infinite number of cases
> >>>>>>>>>>>>>>>>>>> where it gets the wrong answer then it shouldn't
> >>>>>>>>>>>>>>>>>>> be too hard for to provide ONE case backing up
> >>>>>>>>>>>>>>>>>>> your claim.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>> Sure:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> static int count = 3;
> >>>>>>>>>>>>>>>>>> count--;
> >>>>>>>>>>>>>>>>>> if (!count) goto exit;
> >>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>> exit:
> >>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>> Nope; you seem to have forgotten that my decider is
> >>>>>>>>>>>>>>>>> not recursive in nature: my decider will correctly
> >>>>>>>>>>>>>>>>> determine that that input is pathological so will
> >>>>>>>>>>>>>>>>> signal an exception.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> The above terminates normally so your decider gets
> >>>>>>>>>>>>>>>> the wrong answer.
> >>>>>>>>>>>>>>> It is a pathological input so neither halts nor
> >>>>>>>>>>>>>>> doesn't halt: pathological input is INVALID so the
> >>>>>>>>>>>>>>> correct "answer" is to signal an exception.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> So you don't know how static variables work?
> >>>>>>>>>>>>>> I am not surprised.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> static int count = 0;
> >>>>>>>>>>>>>> if (count++ >= 2) goto exit;
> >>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>> exit:
> >>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> Output("Input_Halts = ", H(P,P));
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> _Pm()
> >>>>>>>>>>>>>> [0000141e](01) 55 push ebp
> >>>>>>>>>>>>>> [0000141f](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>> [00001421](03) 83ec08 sub esp,+08
> >>>>>>>>>>>>>> [00001424](05) a100000000 mov eax,[00000000]
> >>>>>>>>>>>>>> [00001429](03) 8945fc mov [ebp-04],eax
> >>>>>>>>>>>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
> >>>>>>>>>>>>>> [00001432](03) 83c101 add ecx,+01
> >>>>>>>>>>>>>> [00001435](06) 890d00000000 mov [00000000],ecx
> >>>>>>>>>>>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
> >>>>>>>>>>>>>> [0000143f](02) 7c02 jl 00001443
> >>>>>>>>>>>>>> [00001441](02) eb1b jmp 0000145e
> >>>>>>>>>>>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
> >>>>>>>>>>>>>> [00001446](01) 52 push edx
> >>>>>>>>>>>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>> [0000144a](01) 50 push eax
> >>>>>>>>>>>>>> [0000144b](05) e8defcffff call 0000112e
> >>>>>>>>>>>>>> [00001450](03) 83c408 add esp,+08
> >>>>>>>>>>>>>> [00001453](03) 8945f8 mov [ebp-08],eax
> >>>>>>>>>>>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
> >>>>>>>>>>>>>> [0000145a](02) 7402 jz 0000145e
> >>>>>>>>>>>>>> [0000145c](02) ebfe jmp 0000145c
> >>>>>>>>>>>>>> [0000145e](02) 8be5 mov esp,ebp
> >>>>>>>>>>>>>> [00001460](01) 5d pop ebp
> >>>>>>>>>>>>>> [00001461](01) c3 ret
> >>>>>>>>>>>>>> Size in bytes:(0068) [00001461]
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> _main()
> >>>>>>>>>>>>>> [0000146e](01) 55 push ebp
> >>>>>>>>>>>>>> [0000146f](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>> [00001471](05) 681e140000 push 0000141e
> >>>>>>>>>>>>>> [00001476](05) 681e140000 push 0000141e
> >>>>>>>>>>>>>> [0000147b](05) e8aefcffff call 0000112e
> >>>>>>>>>>>>>> [00001480](03) 83c408 add esp,+08
> >>>>>>>>>>>>>> [00001483](01) 50 push eax
> >>>>>>>>>>>>>> [00001484](05) 685f050000 push 0000055f
> >>>>>>>>>>>>>> [00001489](05) e820f1ffff call 000005ae
> >>>>>>>>>>>>>> [0000148e](03) 83c408 add esp,+08
> >>>>>>>>>>>>>> [00001491](02) 33c0 xor eax,eax
> >>>>>>>>>>>>>> [00001493](01) 5d pop ebp
> >>>>>>>>>>>>>> [00001494](01) c3 ret
> >>>>>>>>>>>>>> Size in bytes:(0039) [00001494]
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> machine stack stack machine
> >>>>>>>>>>>>>> assembly address address data code
> >>>>>>>>>>>>>> language ======== ======== ======== =========
> >>>>>>>>>>>>>> ============= [0000146e][00102462][00000000] 55
> >>>>>>>>>>>>>> push ebp [0000146f][00102462][00000000] 8bec
> >>>>>>>>>>>>>> mov ebp,esp [00001471][0010245e][0000141e] 681e140000
> >>>>>>>>>>>>>> push 0000141e [00001476][0010245a][0000141e] 681e140000
> >>>>>>>>>>>>>> push 0000141e [0000147b][00102456][00001480]
> >>>>>>>>>>>>>> e8aefcffff call 0000112e
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:11250e
> >>>>>>>>>>>>>> Address_of_H:112e
> >>>>>>>>>>>>>> [0000141e][001124fa][001124fe] 55 push ebp
> >>>>>>>>>>>>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
> >>>>>>>>>>>>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
> >>>>>>>>>>>>>> [00001424][001124f2][90909090] a100000000 mov
> >>>>>>>>>>>>>> eax,[00000000] [00001429][001124f2][90909090] 8945fc
> >>>>>>>>>>>>>> mov [ebp-04],eax [0000142c][001124f2][90909090]
> >>>>>>>>>>>>>> 8b0d00000000 mov ecx,[00000000]
> >>>>>>>>>>>>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
> >>>>>>>>>>>>>> [00001435][001124f2][90909090] 890d00000000 mov
> >>>>>>>>>>>>>> [00000000],ecx [0000143b][001124f2][90909090] 837dfc02
> >>>>>>>>>>>>>> cmp dword [ebp-04],+02 [0000143f][001124f2][90909090]
> >>>>>>>>>>>>>> 7c02 jl 00001443 [00001441][001124f2][90909090] eb1b
> >>>>>>>>>>>>>> jmp 0000145e [0000145e][001124fa][001124fe] 8be5
> >>>>>>>>>>>>>> mov esp,ebp [00001460][001124fe][00001217] 5d
> >>>>>>>>>>>>>> pop ebp [00001461][00112502][0000141e] c3 ret
> >>>>>>>>>>>>>> H: End Simulation Input Terminated Normally
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> [00001480][00102462][00000000] 83c408 add esp,+08
> >>>>>>>>>>>>>> [00001483][0010245e][00000001] 50 push eax
> >>>>>>>>>>>>>> [00001484][0010245a][0000055f] 685f050000 push
> >>>>>>>>>>>>>> 0000055f [00001489][0010245a][0000055f] e820f1ffff
> >>>>>>>>>>>>>> call 000005ae Input_Halts = 1
> >>>>>>>>>>>>>> [0000148e][00102462][00000000] 83c408 add esp,+08
> >>>>>>>>>>>>>> [00001491][00102462][00000000] 33c0 xor eax,eax
> >>>>>>>>>>>>>> [00001493][00102466][00000018] 5d pop ebp
> >>>>>>>>>>>>>> [00001494][0010246a][00000000] c3 ret
> >>>>>>>>>>>>>> Number of Instructions Executed(1317) == 20 Pages
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> For this particular stack trace I notice that the
> >>>>>>>>>>>>> function symbol at the top of it is Pm not P which
> >>>>>>>>>>>>> suggests to me one of two things:
> >>>>>>>>>>>>
> >>>>>>>>>>>> I already had a P so I renamed it to Pm so it would not
> >>>>>>>>>>>> disturb my existing code. When I changed all the Pm
> >>>>>>>>>>>> references to your name I forgot one.
> >>>>>>>>>>>
> >>>>>>>>>>> Then I suggest you check the output of compilation/linking
> >>>>>>>>>>> is actually initializing static variables correctly. Are
> >>>>>>>>>>> you even using a linker or are you just executing an
> >>>>>>>>>>> object file? Static data normally goes into a separate
> >>>>>>>>>>> data segment during the linking process.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>
> >>>>>>>>>> I haven't used static data in such a long time that I
> >>>>>>>>>> forgot the compiler does not allocate any space for static
> >>>>>>>>>> variables unless they have been initialized to a non-zero
> >>>>>>>>>> value.
> >>>>>>>>>>
> >>>>>>>>>> void Pm(u32 x)
> >>>>>>>>>> {
> >>>>>>>>>> static int count = 0x777;
> >>>>>>>>>> if (count++ > 0x777) goto exit;
> >>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>> if (Halt_Status)
> >>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>> exit:
> >>>>>>>>>> return;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> int main()
> >>>>>>>>>> {
> >>>>>>>>>> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> _Pm()
> >>>>>>>>>> [00000a1a](01) 55 push ebp
> >>>>>>>>>> [00000a1b](02) 8bec mov ebp,esp
> >>>>>>>>>> [00000a1d](03) 83ec08 sub esp,+08
> >>>>>>>>>> [00000a20](05) a107030000 mov eax,[00000307]
> >>>>>>>>>> [00000a25](03) 8945fc mov [ebp-04],eax
> >>>>>>>>>> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
> >>>>>>>>>> [00000a2e](03) 83c101 add ecx,+01
> >>>>>>>>>> [00000a31](06) 890d07030000 mov [00000307],ecx
> >>>>>>>>>> [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>>>>>>> [00000a3e](02) 7e02 jng 00000a42
> >>>>>>>>>> [00000a40](02) eb1b jmp 00000a5d
> >>>>>>>>>> [00000a42](03) 8b5508 mov edx,[ebp+08]
> >>>>>>>>>> [00000a45](01) 52 push edx
> >>>>>>>>>> [00000a46](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>> [00000a49](01) 50 push eax
> >>>>>>>>>> [00000a4a](05) e8ebfdffff call 0000083a // call H
> >>>>>>>>>> [00000a4f](03) 83c408 add esp,+08
> >>>>>>>>>> [00000a52](03) 8945f8 mov [ebp-08],eax
> >>>>>>>>>> [00000a55](04) 837df800 cmp dword [ebp-08],+00
> >>>>>>>>>> [00000a59](02) 7402 jz 00000a5d
> >>>>>>>>>> [00000a5b](02) ebfe jmp 00000a5b
> >>>>>>>>>> [00000a5d](02) 8be5 mov esp,ebp
> >>>>>>>>>> [00000a5f](01) 5d pop ebp
> >>>>>>>>>> [00000a60](01) c3 ret
> >>>>>>>>>> Size in bytes:(0071) [00000a60]
> >>>>>>>>>>
> >>>>>>>>>> _main()
> >>>>>>>>>> [00000a6a](01) 55 push ebp
> >>>>>>>>>> [00000a6b](02) 8bec mov ebp,esp
> >>>>>>>>>> [00000a6d](05) 681a0a0000 push 00000a1a // push
> >>>>>>>>>> address of P [00000a72](05) 681a0a0000 push 00000a1a
> >>>>>>>>>> // push address of P [00000a77](05) e8befdffff call
> >>>>>>>>>> 0000083a // call H [00000a7c](03) 83c408 add
> >>>>>>>>>> esp,+08 [00000a7f](01) 50 push eax
> >>>>>>>>>> [00000a80](05) 680b030000 push 0000030b
> >>>>>>>>>> [00000a85](05) e8d0f8ffff call 0000035a
> >>>>>>>>>> [00000a8a](03) 83c408 add esp,+08
> >>>>>>>>>> [00000a8d](02) 33c0 xor eax,eax
> >>>>>>>>>> [00000a8f](01) 5d pop ebp
> >>>>>>>>>> [00000a90](01) c3 ret
> >>>>>>>>>> Size in bytes:(0039) [00000a90]
> >>>>>>>>>>
> >>>>>>>>>> machine stack stack machine assembly
> >>>>>>>>>> address address data code language
> >>>>>>>>>> ======== ======== ======== =========
> >>>>>>>>>> ============= ...[00000a6a][0010137b][00000000] 55
> >>>>>>>>>> push ebp ...[00000a6b][0010137b][00000000] 8bec
> >>>>>>>>>> mov ebp,esp ...[00000a6d][00101377][00000a1a]
> >>>>>>>>>> 681a0a0000 push 00000a1a
> >>>>>>>>>> ...[00000a72][00101373][00000a1a] 681a0a0000 push 00000a1a
> >>>>>>>>>> ...[00000a77][0010136f][00000a7c] e8befdffff call 0000083a
> >>>>>>>>>> New slave_stack at:201427
> >>>>>>>>>>
> >>>>>>>>>> Begin Local Halt Decider Simulation Execution Trace
> >>>>>>>>>> Stored at:21142f ...[00000a1a][0021141b][0021141f] 55
> >>>>>>>>>> push ebp ...[00000a1b][0021141b][0021141f] 8bec
> >>>>>>>>>> mov ebp,esp ...[00000a1d][00211413][90909090] 83ec08
> >>>>>>>>>> sub esp,+08 ...[00000a20][00211413][90909090] a107030000
> >>>>>>>>>> mov eax,[00000307] ...[00000a25][00211413][90909090]
> >>>>>>>>>> 8945fc mov [ebp-04],eax ...[00000a28][00211413][90909090]
> >>>>>>>>>> 8b0d07030000 mov ecx,[00000307]
> >>>>>>>>>> ...[00000a2e][00211413][90909090] 83c101 add ecx,+01
> >>>>>>>>>> ...[00000a31][00211413][90909090] 890d07030000 mov
> >>>>>>>>>> [00000307],ecx ...[00000a37][00211413][90909090]
> >>>>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>>>>>>> ...[00000a3e][00211413][90909090] 7e02 jng
> >>>>>>>>>> 00000a42 ...[00000a42][00211413][90909090] 8b5508
> >>>>>>>>>> mov edx,[ebp+08] ...[00000a45][0021140f][00000a1a] 52 push
> >>>>>>>>>> edx // push address of P
> >>>>>>>>>> ...[00000a46][0021140f][00000a1a] 8b4508 mov
> >>>>>>>>>> eax,[ebp+08] ...[00000a49][0021140b][00000a1a] 50 push eax
> >>>>>>>>>> // push address of P ...[00000a4a][00211407][00000a4f]
> >>>>>>>>>> e8ebfdffff call 0000083a // call H New slave_stack
> >>>>>>>>>> at:24be4f ...[00000a1a][0025be43][0025be47] 55
> >>>>>>>>>> push ebp ...[00000a1b][0025be43][0025be47] 8bec
> >>>>>>>>>> mov ebp,esp ...[00000a1d][0025be3b][90909090] 83ec08
> >>>>>>>>>> sub esp,+08 ...[00000a20][0025be3b][90909090] a107030000
> >>>>>>>>>> mov eax,[00000307] ...[00000a25][0025be3b][90909090]
> >>>>>>>>>> 8945fc mov [ebp-04],eax ...[00000a28][0025be3b][90909090]
> >>>>>>>>>> 8b0d07030000 mov ecx,[00000307]
> >>>>>>>>>> ...[00000a2e][0025be3b][90909090] 83c101 add ecx,+01
> >>>>>>>>>> ...[00000a31][0025be3b][90909090] 890d07030000 mov
> >>>>>>>>>> [00000307],ecx ...[00000a37][0025be3b][90909090]
> >>>>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>>>>>>> ...[00000a3e][0025be3b][90909090] 7e02 jng
> >>>>>>>>>> 00000a42 ...[00000a40][0025be3b][90909090] eb1b
> >>>>>>>>>> jmp 00000a5d // jmp to exit
> >>>>>>>>>> ...[00000a5d][0025be43][0025be47] 8be5 mov
> >>>>>>>>>> esp,ebp ...[00000a5f][0025be47][00000904] 5d
> >>>>>>>>>> pop ebp ...[00000a60][0025be4b][00000a1a] c3
> >>>>>>>>>> ret ...[00000a7c][0010137b][00000000] 83c408 add
> >>>>>>>>>> esp,+08 ...[00000a7f][00101377][00000001] 50
> >>>>>>>>>> push eax ...[00000a80][00101373][0000030b] 680b030000
> >>>>>>>>>> push 0000030b ---[00000a85][00101373][0000030b] e8d0f8ffff
> >>>>>>>>>> call 0000035a Input_Halts = 1
> >>>>>>>>>> ...[00000a8a][0010137b][00000000] 83c408 add
> >>>>>>>>>> esp,+08 ...[00000a8d][0010137b][00000000] 33c0
> >>>>>>>>>> xor eax,eax ...[00000a8f][0010137f][00100000] 5d
> >>>>>>>>>> pop ebp ...[00000a90][00101383][00000004] c3
> >>>>>>>>>> ret Number of Instructions Executed(27278)
> >>>>>>>>>
> >>>>>>>>> Still seems wrong: post increment of the static variable
> >>>>>>>>> should ensure that it does NOT goto exit but instead should
> >>>>>>>>> call H which should presumably cause your "infinite
> >>>>>>>>> recursion detected" bollocks to manifest.
> >>>>>>>>
> >>>>>>>> OK, I've looked at your assembly trace and it is recursing
> >>>>>>>> into Pm from H and then halting but I am not sure what you
> >>>>>>>> are trying to prove? Again [Strachey 1965] and associated
> >>>>>>>> proofs are not recursive in nature.
> >>>>>>>>
> >>>>>>>> /Flibble
> >>>>>>>
> >>>>>>> (1) H cannot correctly determine the halt status of the HP
> >>>>>>> counter-examples unless H is a simulating halt decider.
> >>>>>>>
> >>>>>>> (2) The claim of the halting problem proofs is that no H in
> >>>>>>> the universe can possibly correctly determine the halt status
> >>>>>>> of its corresponding pathological input.
> >>>>>>>
> >>>>>>> (3) H(P,P) does correctly determine that its correponding
> >>>>>>> pathological input would never halt.
> >>>>>>>
> >>>>>>> (4) It is ridiculously stupid of you to say that [Strachey
> >>>>>>> 1965] does not specify infinitely recursive simulation when
> >>>>>>> it is an easily verified fact that when Strachey T <is> a
> >>>>>>> simulating halt decider that Strachey P <does> specify
> >>>>>>> infinitely recursive simulation.
> >>>>>>>
> >>>>>>> It does not say this directly in [Strachey 1965] only because
> >>>>>>> no one ever previously bothered to fully examine the effect
> >>>>>>> of a simulating halt decider on the HP's pathological inputs.
> >>>>>>>
> >>>>>>
> >>>>>> I see I have to repeat myself yet again: a simulating halt
> >>>>>> decider needn't be recursive in nature and I have sketched a
> >>>>>> design of such a halt decider:
> >>>>>>
> >>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>>>>
> >>>>>> You are incorrect to claim an equivalence between pathological
> >>>>>> input and non-halting.
> >>>>>>
> >>>>>> /Flibble
> >>>>>>
> >>>>>
> >>>>> 19 When the simulator detects the call to H in P it forks the
> >>>>> simulation 20 into a non-halting branch (returning 0 to P) and a
> >>>>> halting branch 21 (returning 1 to P)
> >>>>>
> >>>>> Software engineers at the low end of technical competence may
> >>>>> not fully comprehend the common knowledge that:
> >>>>>
> >>>>> Whenever a function is called in what is essentially infinite
> >>>>> recursion this function cannot possibly correctly return any
> >>>>> value to its caller. You don't seem to understand that.
> >>>>
> >>>> Why are you so fucking obtuse? My forking simulating decider IS
> >>>> NOT RECURSIVE.
> >>>
> >>> It is directly disobeying the actual behavior specified by the
> >>> actual input by returning a value to a function that called it in
> >>> infinite recursion.
> >>>
> >>>
> >>
> >> Even if we did accept that your pathological self-reference
> >> detector is valid it is only a copycat of my idea and it provides
> >> a weaker result. It answers: I don't know and mine answers:
> >> non-halting.
> >
> > I could trivially change my decider to return a decision of
> > non-halting instead of signaling an exception if I believed such a
> > mapping was correct, but I don't, so I won't.
> >
> >>
> >> Because you did not even copycat my criteria correctly your H gets
> >> the wrong answer on this input.
> >>
> >> int add(int N)
> >> {
> >> return N + 3;
> >> }
> >>
> >> void Pc(ptr x)
> >> {
> >> H(add, (ptr)7);
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H(Pc,Pc));
> >> }
> >
> > My decider would correctly answer that Pc halts: passing a different
> > input to H would be equivalent to the call to H from main(), i.e. it
> > would be a function call rather than a fork detection: forks only
> > happen if H is called with the same input more than once.
> >
> > /Flibble
> >
>
> https://github.com/i42output/halting-problem/blob/main/README.txt
>
> You did not bother to copycat my criteria: "with the same input"
> therefore your specification fails the above test.
The only thing my decider and your decider have in common is that they
are both simulating halt deciders.
>
> When simulating halt decider H(P,P) simulates its input we can see
> that: (1) Function H() is called from P().
> (2) With the same arguments to H().
> (3) With no instructions in P preceding its invocation of H(P,P).
>
> As already shown before you also did not bother to copycat my
> criteria (3) which provides another escape route from non-termination.
>
> When you add these crriteria I insist on a reference to my copyright
> notice for these criteria.
>
> *Halting problem proofs refuted on the basis of software engineering*
> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
No. You cannot copyright the idea of a simulating halt decider; you only
have a copyright for your broken simulating halt decider.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2022-07-15 14:28 -0500 |
| Subject | Re: Halting problem proofs refuted on the basis of software engineering [ establishing my authorship and asserting my copyrights ] |
| Message-ID | <ppidncG2cMtZIkz_nZ2dnUU7_8zNnZ2d@giganews.com> |
| In reply to | #85269 |
On 7/15/2022 2:11 PM, Mr Flibble wrote:
> On Fri, 15 Jul 2022 14:04:22 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/15/2022 1:41 PM, Mr Flibble wrote:
>>> On Fri, 15 Jul 2022 13:31:50 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 7/15/2022 1:17 PM, olcott wrote:
>>>>> On 7/15/2022 1:04 PM, Mr Flibble wrote:
>>>>>> On Fri, 15 Jul 2022 12:57:53 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>
>>>>>>> On 7/15/2022 12:46 PM, Mr Flibble wrote:
>>>>>>>> On Fri, 15 Jul 2022 12:39:31 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> On 7/15/2022 12:28 PM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 15 Jul 2022 18:08:22 +0100
>>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
>>>>>>>>>>> On Fri, 15 Jul 2022 12:00:59 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 15 Jul 2022 10:58:14 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is an explanation of a key new insight
>>>>>>>>>>>>>>>>>>>>>>>>>>>> into the halting problem provided in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> language of software engineering. Technical
>>>>>>>>>>>>>>>>>>>>>>>>>>>> computer science terms are explained using
>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering terms. No knowledge of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem is required.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is based on fully operational software
>>>>>>>>>>>>>>>>>>>>>>>>>>>> executed in the x86utm operating system.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The x86utm operating system (based on an
>>>>>>>>>>>>>>>>>>>>>>>>>>>> excellent open source x86 emulator) was
>>>>>>>>>>>>>>>>>>>>>>>>>>>> created to study the details of the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof counter-examples at the much
>>>>>>>>>>>>>>>>>>>>>>>>>>>> higher level of abstraction of C/x86.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P, P)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input we can see that: (1)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Function H() is called from P(). (2) With
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same arguments to H(). (3) With no
>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions in P preceding its invocation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of H(P,P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above shows that the simulated P cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. Because H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>> see the same (1)(2)(3) that we see H aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation of P and rejects P as
>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> In computability theory,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem is the problem of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> determining, from a description of an
>>>>>>>>>>>>>>>>>>>>>>>>>>>> arbitrary computer program and an input,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether the program will finish running, or
>>>>>>>>>>>>>>>>>>>>>>>>>>>> continue to run forever. Alan Turing proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>> in 1936 that a general algorithm to solve
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem for all possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>> program- input pairs cannot exist.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> For any program H that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> might determine if programs halt, a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> "pathological" program P, called with some
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input, can pass its own source and its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H and then specifically do the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> opposite of what H predicts P will do. No
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H can exist that handles this case.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
>>>>>>>>>>>>>>>>>>>>>>>>>>>> relationship to each other as described
>>>>>>>>>>>>>>>>>>>>>>>>>>>> above. Because H(P,P) does handle this case
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the above halting problem undecidable input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> template has been refuted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *When this halt deciding principle
>>>>>>>>>>>>>>>>>>>>>>>>>>>> understood to be correct* A halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>> must compute the mapping from its inputs to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> an accept or reject state on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior that is actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this
>>>>>>>>>>>>>>>>>>>>>>>>>>>> implements that principle* Every
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider that correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input until it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> predicts that this simulated input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>> never terminate normally, correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> rejects this input as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *H is a Pure function*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of software engineering*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>> which I suppose is progress.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I have shown that H/P does implement the HP's
>>>>>>>>>>>>>>>>>>>>>>>>>> "impossible input" template.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting
>>>>>>>>>>>>>>>>>>>>>>>>>> problem proofs that rely on this template.
>>>>>>>>>>>>>>>>>>>>>>>>> Equating pathological input with non-halting
>>>>>>>>>>>>>>>>>>>>>>>>> is erroneous: you are only doing that because
>>>>>>>>>>>>>>>>>>>>>>>>> your broken solution treats it as "infinite
>>>>>>>>>>>>>>>>>>>>>>>>> recursion". There is no recursion in [Strachey
>>>>>>>>>>>>>>>>>>>>>>>>> 1965] and the HP proofs based on it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> There is no recursion in any of the
>>>>>>>>>>>>>>>>>>>>>>>> conventional proofs only because no one ever
>>>>>>>>>>>>>>>>>>>>>>>> previously bothered to fully examine how a
>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider would address these
>>>>>>>>>>>>>>>>>>>>>>>> otherwise "impossible" inputs.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I have shown that a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>> needn't be recursive in nature:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You sure do make it easy to review your work.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> "When the simulator detects the call
>>>>>>>>>>>>>>>>>>>>>> to H in P it forks the simulation into a
>>>>>>>>>>>>>>>>>>>>>> non-halting branch"
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> There is an infinite set of cases where this
>>>>>>>>>>>>>>>>>>>>>> overly simplistic criteria gets the wrong
>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That is neither an honest review or any kind of
>>>>>>>>>>>>>>>>>>>>> rebuttal: I have told you before: assertions made
>>>>>>>>>>>>>>>>>>>>> without evidence can be dismissed without
>>>>>>>>>>>>>>>>>>>>> evidence.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If you claim there are an infinite number of cases
>>>>>>>>>>>>>>>>>>>>> where it gets the wrong answer then it shouldn't
>>>>>>>>>>>>>>>>>>>>> be too hard for to provide ONE case backing up
>>>>>>>>>>>>>>>>>>>>> your claim.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>> Sure:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> static int count = 3;
>>>>>>>>>>>>>>>>>>>> count--;
>>>>>>>>>>>>>>>>>>>> if (!count) goto exit;
>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> exit:
>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> Nope; you seem to have forgotten that my decider is
>>>>>>>>>>>>>>>>>>> not recursive in nature: my decider will correctly
>>>>>>>>>>>>>>>>>>> determine that that input is pathological so will
>>>>>>>>>>>>>>>>>>> signal an exception.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The above terminates normally so your decider gets
>>>>>>>>>>>>>>>>>> the wrong answer.
>>>>>>>>>>>>>>>>> It is a pathological input so neither halts nor
>>>>>>>>>>>>>>>>> doesn't halt: pathological input is INVALID so the
>>>>>>>>>>>>>>>>> correct "answer" is to signal an exception.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So you don't know how static variables work?
>>>>>>>>>>>>>>>> I am not surprised.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> static int count = 0;
>>>>>>>>>>>>>>>> if (count++ >= 2) goto exit;
>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>> exit:
>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P,P));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _Pm()
>>>>>>>>>>>>>>>> [0000141e](01) 55 push ebp
>>>>>>>>>>>>>>>> [0000141f](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [00001421](03) 83ec08 sub esp,+08
>>>>>>>>>>>>>>>> [00001424](05) a100000000 mov eax,[00000000]
>>>>>>>>>>>>>>>> [00001429](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>>>>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
>>>>>>>>>>>>>>>> [00001432](03) 83c101 add ecx,+01
>>>>>>>>>>>>>>>> [00001435](06) 890d00000000 mov [00000000],ecx
>>>>>>>>>>>>>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
>>>>>>>>>>>>>>>> [0000143f](02) 7c02 jl 00001443
>>>>>>>>>>>>>>>> [00001441](02) eb1b jmp 0000145e
>>>>>>>>>>>>>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
>>>>>>>>>>>>>>>> [00001446](01) 52 push edx
>>>>>>>>>>>>>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>> [0000144a](01) 50 push eax
>>>>>>>>>>>>>>>> [0000144b](05) e8defcffff call 0000112e
>>>>>>>>>>>>>>>> [00001450](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>> [00001453](03) 8945f8 mov [ebp-08],eax
>>>>>>>>>>>>>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
>>>>>>>>>>>>>>>> [0000145a](02) 7402 jz 0000145e
>>>>>>>>>>>>>>>> [0000145c](02) ebfe jmp 0000145c
>>>>>>>>>>>>>>>> [0000145e](02) 8be5 mov esp,ebp
>>>>>>>>>>>>>>>> [00001460](01) 5d pop ebp
>>>>>>>>>>>>>>>> [00001461](01) c3 ret
>>>>>>>>>>>>>>>> Size in bytes:(0068) [00001461]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>> [0000146e](01) 55 push ebp
>>>>>>>>>>>>>>>> [0000146f](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [00001471](05) 681e140000 push 0000141e
>>>>>>>>>>>>>>>> [00001476](05) 681e140000 push 0000141e
>>>>>>>>>>>>>>>> [0000147b](05) e8aefcffff call 0000112e
>>>>>>>>>>>>>>>> [00001480](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>> [00001483](01) 50 push eax
>>>>>>>>>>>>>>>> [00001484](05) 685f050000 push 0000055f
>>>>>>>>>>>>>>>> [00001489](05) e820f1ffff call 000005ae
>>>>>>>>>>>>>>>> [0000148e](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>> [00001491](02) 33c0 xor eax,eax
>>>>>>>>>>>>>>>> [00001493](01) 5d pop ebp
>>>>>>>>>>>>>>>> [00001494](01) c3 ret
>>>>>>>>>>>>>>>> Size in bytes:(0039) [00001494]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> machine stack stack machine
>>>>>>>>>>>>>>>> assembly address address data code
>>>>>>>>>>>>>>>> language ======== ======== ======== =========
>>>>>>>>>>>>>>>> ============= [0000146e][00102462][00000000] 55
>>>>>>>>>>>>>>>> push ebp [0000146f][00102462][00000000] 8bec
>>>>>>>>>>>>>>>> mov ebp,esp [00001471][0010245e][0000141e] 681e140000
>>>>>>>>>>>>>>>> push 0000141e [00001476][0010245a][0000141e] 681e140000
>>>>>>>>>>>>>>>> push 0000141e [0000147b][00102456][00001480]
>>>>>>>>>>>>>>>> e8aefcffff call 0000112e
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:11250e
>>>>>>>>>>>>>>>> Address_of_H:112e
>>>>>>>>>>>>>>>> [0000141e][001124fa][001124fe] 55 push ebp
>>>>>>>>>>>>>>>> [0000141f][001124fa][001124fe] 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [00001421][001124f2][90909090] 83ec08 sub esp,+08
>>>>>>>>>>>>>>>> [00001424][001124f2][90909090] a100000000 mov
>>>>>>>>>>>>>>>> eax,[00000000] [00001429][001124f2][90909090] 8945fc
>>>>>>>>>>>>>>>> mov [ebp-04],eax [0000142c][001124f2][90909090]
>>>>>>>>>>>>>>>> 8b0d00000000 mov ecx,[00000000]
>>>>>>>>>>>>>>>> [00001432][001124f2][90909090] 83c101 add ecx,+01
>>>>>>>>>>>>>>>> [00001435][001124f2][90909090] 890d00000000 mov
>>>>>>>>>>>>>>>> [00000000],ecx [0000143b][001124f2][90909090] 837dfc02
>>>>>>>>>>>>>>>> cmp dword [ebp-04],+02 [0000143f][001124f2][90909090]
>>>>>>>>>>>>>>>> 7c02 jl 00001443 [00001441][001124f2][90909090] eb1b
>>>>>>>>>>>>>>>> jmp 0000145e [0000145e][001124fa][001124fe] 8be5
>>>>>>>>>>>>>>>> mov esp,ebp [00001460][001124fe][00001217] 5d
>>>>>>>>>>>>>>>> pop ebp [00001461][00112502][0000141e] c3 ret
>>>>>>>>>>>>>>>> H: End Simulation Input Terminated Normally
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> [00001480][00102462][00000000] 83c408 add esp,+08
>>>>>>>>>>>>>>>> [00001483][0010245e][00000001] 50 push eax
>>>>>>>>>>>>>>>> [00001484][0010245a][0000055f] 685f050000 push
>>>>>>>>>>>>>>>> 0000055f [00001489][0010245a][0000055f] e820f1ffff
>>>>>>>>>>>>>>>> call 000005ae Input_Halts = 1
>>>>>>>>>>>>>>>> [0000148e][00102462][00000000] 83c408 add esp,+08
>>>>>>>>>>>>>>>> [00001491][00102462][00000000] 33c0 xor eax,eax
>>>>>>>>>>>>>>>> [00001493][00102466][00000018] 5d pop ebp
>>>>>>>>>>>>>>>> [00001494][0010246a][00000000] c3 ret
>>>>>>>>>>>>>>>> Number of Instructions Executed(1317) == 20 Pages
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> For this particular stack trace I notice that the
>>>>>>>>>>>>>>> function symbol at the top of it is Pm not P which
>>>>>>>>>>>>>>> suggests to me one of two things:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I already had a P so I renamed it to Pm so it would not
>>>>>>>>>>>>>> disturb my existing code. When I changed all the Pm
>>>>>>>>>>>>>> references to your name I forgot one.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then I suggest you check the output of compilation/linking
>>>>>>>>>>>>> is actually initializing static variables correctly. Are
>>>>>>>>>>>>> you even using a linker or are you just executing an
>>>>>>>>>>>>> object file? Static data normally goes into a separate
>>>>>>>>>>>>> data segment during the linking process.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> I haven't used static data in such a long time that I
>>>>>>>>>>>> forgot the compiler does not allocate any space for static
>>>>>>>>>>>> variables unless they have been initialized to a non-zero
>>>>>>>>>>>> value.
>>>>>>>>>>>>
>>>>>>>>>>>> void Pm(u32 x)
>>>>>>>>>>>> {
>>>>>>>>>>>> static int count = 0x777;
>>>>>>>>>>>> if (count++ > 0x777) goto exit;
>>>>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>> exit:
>>>>>>>>>>>> return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> _Pm()
>>>>>>>>>>>> [00000a1a](01) 55 push ebp
>>>>>>>>>>>> [00000a1b](02) 8bec mov ebp,esp
>>>>>>>>>>>> [00000a1d](03) 83ec08 sub esp,+08
>>>>>>>>>>>> [00000a20](05) a107030000 mov eax,[00000307]
>>>>>>>>>>>> [00000a25](03) 8945fc mov [ebp-04],eax
>>>>>>>>>>>> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
>>>>>>>>>>>> [00000a2e](03) 83c101 add ecx,+01
>>>>>>>>>>>> [00000a31](06) 890d07030000 mov [00000307],ecx
>>>>>>>>>>>> [00000a37](07) 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>>>>>>> [00000a3e](02) 7e02 jng 00000a42
>>>>>>>>>>>> [00000a40](02) eb1b jmp 00000a5d
>>>>>>>>>>>> [00000a42](03) 8b5508 mov edx,[ebp+08]
>>>>>>>>>>>> [00000a45](01) 52 push edx
>>>>>>>>>>>> [00000a46](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> [00000a49](01) 50 push eax
>>>>>>>>>>>> [00000a4a](05) e8ebfdffff call 0000083a // call H
>>>>>>>>>>>> [00000a4f](03) 83c408 add esp,+08
>>>>>>>>>>>> [00000a52](03) 8945f8 mov [ebp-08],eax
>>>>>>>>>>>> [00000a55](04) 837df800 cmp dword [ebp-08],+00
>>>>>>>>>>>> [00000a59](02) 7402 jz 00000a5d
>>>>>>>>>>>> [00000a5b](02) ebfe jmp 00000a5b
>>>>>>>>>>>> [00000a5d](02) 8be5 mov esp,ebp
>>>>>>>>>>>> [00000a5f](01) 5d pop ebp
>>>>>>>>>>>> [00000a60](01) c3 ret
>>>>>>>>>>>> Size in bytes:(0071) [00000a60]
>>>>>>>>>>>>
>>>>>>>>>>>> _main()
>>>>>>>>>>>> [00000a6a](01) 55 push ebp
>>>>>>>>>>>> [00000a6b](02) 8bec mov ebp,esp
>>>>>>>>>>>> [00000a6d](05) 681a0a0000 push 00000a1a // push
>>>>>>>>>>>> address of P [00000a72](05) 681a0a0000 push 00000a1a
>>>>>>>>>>>> // push address of P [00000a77](05) e8befdffff call
>>>>>>>>>>>> 0000083a // call H [00000a7c](03) 83c408 add
>>>>>>>>>>>> esp,+08 [00000a7f](01) 50 push eax
>>>>>>>>>>>> [00000a80](05) 680b030000 push 0000030b
>>>>>>>>>>>> [00000a85](05) e8d0f8ffff call 0000035a
>>>>>>>>>>>> [00000a8a](03) 83c408 add esp,+08
>>>>>>>>>>>> [00000a8d](02) 33c0 xor eax,eax
>>>>>>>>>>>> [00000a8f](01) 5d pop ebp
>>>>>>>>>>>> [00000a90](01) c3 ret
>>>>>>>>>>>> Size in bytes:(0039) [00000a90]
>>>>>>>>>>>>
>>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>>> address address data code language
>>>>>>>>>>>> ======== ======== ======== =========
>>>>>>>>>>>> ============= ...[00000a6a][0010137b][00000000] 55
>>>>>>>>>>>> push ebp ...[00000a6b][0010137b][00000000] 8bec
>>>>>>>>>>>> mov ebp,esp ...[00000a6d][00101377][00000a1a]
>>>>>>>>>>>> 681a0a0000 push 00000a1a
>>>>>>>>>>>> ...[00000a72][00101373][00000a1a] 681a0a0000 push 00000a1a
>>>>>>>>>>>> ...[00000a77][0010136f][00000a7c] e8befdffff call 0000083a
>>>>>>>>>>>> New slave_stack at:201427
>>>>>>>>>>>>
>>>>>>>>>>>> Begin Local Halt Decider Simulation Execution Trace
>>>>>>>>>>>> Stored at:21142f ...[00000a1a][0021141b][0021141f] 55
>>>>>>>>>>>> push ebp ...[00000a1b][0021141b][0021141f] 8bec
>>>>>>>>>>>> mov ebp,esp ...[00000a1d][00211413][90909090] 83ec08
>>>>>>>>>>>> sub esp,+08 ...[00000a20][00211413][90909090] a107030000
>>>>>>>>>>>> mov eax,[00000307] ...[00000a25][00211413][90909090]
>>>>>>>>>>>> 8945fc mov [ebp-04],eax ...[00000a28][00211413][90909090]
>>>>>>>>>>>> 8b0d07030000 mov ecx,[00000307]
>>>>>>>>>>>> ...[00000a2e][00211413][90909090] 83c101 add ecx,+01
>>>>>>>>>>>> ...[00000a31][00211413][90909090] 890d07030000 mov
>>>>>>>>>>>> [00000307],ecx ...[00000a37][00211413][90909090]
>>>>>>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>>>>>>> ...[00000a3e][00211413][90909090] 7e02 jng
>>>>>>>>>>>> 00000a42 ...[00000a42][00211413][90909090] 8b5508
>>>>>>>>>>>> mov edx,[ebp+08] ...[00000a45][0021140f][00000a1a] 52 push
>>>>>>>>>>>> edx // push address of P
>>>>>>>>>>>> ...[00000a46][0021140f][00000a1a] 8b4508 mov
>>>>>>>>>>>> eax,[ebp+08] ...[00000a49][0021140b][00000a1a] 50 push eax
>>>>>>>>>>>> // push address of P ...[00000a4a][00211407][00000a4f]
>>>>>>>>>>>> e8ebfdffff call 0000083a // call H New slave_stack
>>>>>>>>>>>> at:24be4f ...[00000a1a][0025be43][0025be47] 55
>>>>>>>>>>>> push ebp ...[00000a1b][0025be43][0025be47] 8bec
>>>>>>>>>>>> mov ebp,esp ...[00000a1d][0025be3b][90909090] 83ec08
>>>>>>>>>>>> sub esp,+08 ...[00000a20][0025be3b][90909090] a107030000
>>>>>>>>>>>> mov eax,[00000307] ...[00000a25][0025be3b][90909090]
>>>>>>>>>>>> 8945fc mov [ebp-04],eax ...[00000a28][0025be3b][90909090]
>>>>>>>>>>>> 8b0d07030000 mov ecx,[00000307]
>>>>>>>>>>>> ...[00000a2e][0025be3b][90909090] 83c101 add ecx,+01
>>>>>>>>>>>> ...[00000a31][0025be3b][90909090] 890d07030000 mov
>>>>>>>>>>>> [00000307],ecx ...[00000a37][0025be3b][90909090]
>>>>>>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
>>>>>>>>>>>> ...[00000a3e][0025be3b][90909090] 7e02 jng
>>>>>>>>>>>> 00000a42 ...[00000a40][0025be3b][90909090] eb1b
>>>>>>>>>>>> jmp 00000a5d // jmp to exit
>>>>>>>>>>>> ...[00000a5d][0025be43][0025be47] 8be5 mov
>>>>>>>>>>>> esp,ebp ...[00000a5f][0025be47][00000904] 5d
>>>>>>>>>>>> pop ebp ...[00000a60][0025be4b][00000a1a] c3
>>>>>>>>>>>> ret ...[00000a7c][0010137b][00000000] 83c408 add
>>>>>>>>>>>> esp,+08 ...[00000a7f][00101377][00000001] 50
>>>>>>>>>>>> push eax ...[00000a80][00101373][0000030b] 680b030000
>>>>>>>>>>>> push 0000030b ---[00000a85][00101373][0000030b] e8d0f8ffff
>>>>>>>>>>>> call 0000035a Input_Halts = 1
>>>>>>>>>>>> ...[00000a8a][0010137b][00000000] 83c408 add
>>>>>>>>>>>> esp,+08 ...[00000a8d][0010137b][00000000] 33c0
>>>>>>>>>>>> xor eax,eax ...[00000a8f][0010137f][00100000] 5d
>>>>>>>>>>>> pop ebp ...[00000a90][00101383][00000004] c3
>>>>>>>>>>>> ret Number of Instructions Executed(27278)
>>>>>>>>>>>
>>>>>>>>>>> Still seems wrong: post increment of the static variable
>>>>>>>>>>> should ensure that it does NOT goto exit but instead should
>>>>>>>>>>> call H which should presumably cause your "infinite
>>>>>>>>>>> recursion detected" bollocks to manifest.
>>>>>>>>>>
>>>>>>>>>> OK, I've looked at your assembly trace and it is recursing
>>>>>>>>>> into Pm from H and then halting but I am not sure what you
>>>>>>>>>> are trying to prove? Again [Strachey 1965] and associated
>>>>>>>>>> proofs are not recursive in nature.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> (1) H cannot correctly determine the halt status of the HP
>>>>>>>>> counter-examples unless H is a simulating halt decider.
>>>>>>>>>
>>>>>>>>> (2) The claim of the halting problem proofs is that no H in
>>>>>>>>> the universe can possibly correctly determine the halt status
>>>>>>>>> of its corresponding pathological input.
>>>>>>>>>
>>>>>>>>> (3) H(P,P) does correctly determine that its correponding
>>>>>>>>> pathological input would never halt.
>>>>>>>>>
>>>>>>>>> (4) It is ridiculously stupid of you to say that [Strachey
>>>>>>>>> 1965] does not specify infinitely recursive simulation when
>>>>>>>>> it is an easily verified fact that when Strachey T <is> a
>>>>>>>>> simulating halt decider that Strachey P <does> specify
>>>>>>>>> infinitely recursive simulation.
>>>>>>>>>
>>>>>>>>> It does not say this directly in [Strachey 1965] only because
>>>>>>>>> no one ever previously bothered to fully examine the effect
>>>>>>>>> of a simulating halt decider on the HP's pathological inputs.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I see I have to repeat myself yet again: a simulating halt
>>>>>>>> decider needn't be recursive in nature and I have sketched a
>>>>>>>> design of such a halt decider:
>>>>>>>>
>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>>>>>
>>>>>>>> You are incorrect to claim an equivalence between pathological
>>>>>>>> input and non-halting.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> 19 When the simulator detects the call to H in P it forks the
>>>>>>> simulation 20 into a non-halting branch (returning 0 to P) and a
>>>>>>> halting branch 21 (returning 1 to P)
>>>>>>>
>>>>>>> Software engineers at the low end of technical competence may
>>>>>>> not fully comprehend the common knowledge that:
>>>>>>>
>>>>>>> Whenever a function is called in what is essentially infinite
>>>>>>> recursion this function cannot possibly correctly return any
>>>>>>> value to its caller. You don't seem to understand that.
>>>>>>
>>>>>> Why are you so fucking obtuse? My forking simulating decider IS
>>>>>> NOT RECURSIVE.
>>>>>
>>>>> It is directly disobeying the actual behavior specified by the
>>>>> actual input by returning a value to a function that called it in
>>>>> infinite recursion.
>>>>>
>>>>>
>>>>
>>>> Even if we did accept that your pathological self-reference
>>>> detector is valid it is only a copycat of my idea and it provides
>>>> a weaker result. It answers: I don't know and mine answers:
>>>> non-halting.
>>>
>>> I could trivially change my decider to return a decision of
>>> non-halting instead of signaling an exception if I believed such a
>>> mapping was correct, but I don't, so I won't.
>>>
>>>>
>>>> Because you did not even copycat my criteria correctly your H gets
>>>> the wrong answer on this input.
>>>>
>>>> int add(int N)
>>>> {
>>>> return N + 3;
>>>> }
>>>>
>>>> void Pc(ptr x)
>>>> {
>>>> H(add, (ptr)7);
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(Pc,Pc));
>>>> }
>>>
>>> My decider would correctly answer that Pc halts: passing a different
>>> input to H would be equivalent to the call to H from main(), i.e. it
>>> would be a function call rather than a fork detection: forks only
>>> happen if H is called with the same input more than once.
>>>
>>> /Flibble
>>>
>>
>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>
>> You did not bother to copycat my criteria: "with the same input"
>> therefore your specification fails the above test.
>
> The only thing my decider and your decider have in common is that they
> are both simulating halt deciders.
>
>>
>> When simulating halt decider H(P,P) simulates its input we can see
>> that: (1) Function H() is called from P().
>> (2) With the same arguments to H().
>> (3) With no instructions in P preceding its invocation of H(P,P).
>>
>> As already shown before you also did not bother to copycat my
>> criteria (3) which provides another escape route from non-termination.
>>
>> When you add these crriteria I insist on a reference to my copyright
>> notice for these criteria.
>>
>> *Halting problem proofs refuted on the basis of software engineering*
>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>
> No. You cannot copyright the idea of a simulating halt decider; you only
> have a copyright for your broken simulating halt decider.
>
> /Flibble
>
*I have a copyright on these words and every precise paraphrase*
When simulating halt decider H(P,P) simulates its input we can see that:
(1) Function H() is called from P().
(2) With the same arguments to H().
(3) With no instructions in P preceding its invocation of H(P,P).
https://en.wikipedia.org/wiki/Paraphrasing_of_copyrighted_material
You are expressing using (1)
"When the simulator detects the call to H in P"
https://github.com/i42output/halting-problem/blob/main/README.txt
have referred to (2) after the fact when I pointed out that it was
missing from your spec
On 7/15/2022 1:41 PM, Mr Flibble wrote:
> ... if H is called with the same input more than once.
and have not bothered to correct the (false positive) error of your
specification by failing to include (3).
You may use the above three criteria in your spec only if you post my
copyright notice: Copyright 2022 PL Olcott
After you fully copycat my criteria your pathological reference detector
might be valid. You may not copycat this criteria without my copyright
notice.
*Halting problem proofs refuted on the basis of software engineering*
https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc.corp> |
|---|---|
| Date | 2022-07-15 20:33 +0100 |
| Subject | Re: Halting problem proofs refuted on the basis of software engineering [ establishing my authorship and asserting my copyrights ] |
| Message-ID | <20220715203358.00004649@reddwarf.jmc.corp> |
| In reply to | #85275 |
On Fri, 15 Jul 2022 14:28:03 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 7/15/2022 2:11 PM, Mr Flibble wrote:
> > On Fri, 15 Jul 2022 14:04:22 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 7/15/2022 1:41 PM, Mr Flibble wrote:
> >>> On Fri, 15 Jul 2022 13:31:50 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 7/15/2022 1:17 PM, olcott wrote:
> >>>>> On 7/15/2022 1:04 PM, Mr Flibble wrote:
> >>>>>> On Fri, 15 Jul 2022 12:57:53 -0500
> >>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>
> >>>>>>> On 7/15/2022 12:46 PM, Mr Flibble wrote:
> >>>>>>>> On Fri, 15 Jul 2022 12:39:31 -0500
> >>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>> On 7/15/2022 12:28 PM, Mr Flibble wrote:
> >>>>>>>>>> On Fri, 15 Jul 2022 18:08:22 +0100
> >>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
> >>>>>>>>>>> On Fri, 15 Jul 2022 12:00:59 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Fri, 15 Jul 2022 10:58:14 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
> >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
> >>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
> >>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
> >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
> >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
> >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
> >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> This is an explanation of a key new
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> insight into the halting problem
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> provided in the language of software
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering. Technical computer science
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> terms are explained using software
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering terms. No knowledge of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem is required.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> It is based on fully operational software
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> executed in the x86utm operating system.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> The x86utm operating system (based on an
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> excellent open source x86 emulator) was
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> created to study the details of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem proof counter-examples
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> at the much higher level of abstraction
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> of C/x86.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> x); if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P, P)); }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input we can see that: (1)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Function H() is called from P(). (2) With
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> the same arguments to H(). (3) With no
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions in P preceding its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of H(P,P).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> The above shows that the simulated P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Because H can see the same (1)(2)(3)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> that we see H aborts its simulation of P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> and rejects P as non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> In computability
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> theory, the halting problem is the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> problem of determining, from a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> description of an arbitrary computer
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> program and an input, whether the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> program will finish running, or continue
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> to run forever. Alan Turing proved in
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> 1936 that a general algorithm to solve
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem for all possible
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> program- input pairs cannot exist.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> For any program H that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> might determine if programs halt, a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> "pathological" program P, called with
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> some input, can pass its own source and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> its input to H and then specifically do
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> the opposite of what H predicts P will
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> do. No H can exist that handles this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> case.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> relationship to each other as described
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> above. Because H(P,P) does handle this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> case the above halting problem
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> undecidable input template has been
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> refuted.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *When this halt deciding principle
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> understood to be correct* A halt decider
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> must compute the mapping from its inputs
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> to an accept or reject state on the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of the actual behavior that is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> actually specified by these inputs.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> implements that principle* Every
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider that correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input until it correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> predicts that this simulated input would
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> never terminate normally, correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> rejects this input as non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *H is a Pure function*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of software engineering*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion
> >>>>>>>>>>>>>>>>>>>>>>>>>>> which I suppose is progress.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> I have shown that H/P does implement the
> >>>>>>>>>>>>>>>>>>>>>>>>>> HP's "impossible input" template.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting
> >>>>>>>>>>>>>>>>>>>>>>>>>> problem proofs that rely on this template.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Equating pathological input with non-halting
> >>>>>>>>>>>>>>>>>>>>>>>>> is erroneous: you are only doing that
> >>>>>>>>>>>>>>>>>>>>>>>>> because your broken solution treats it as
> >>>>>>>>>>>>>>>>>>>>>>>>> "infinite recursion". There is no recursion
> >>>>>>>>>>>>>>>>>>>>>>>>> in [Strachey 1965] and the HP proofs based
> >>>>>>>>>>>>>>>>>>>>>>>>> on it.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> There is no recursion in any of the
> >>>>>>>>>>>>>>>>>>>>>>>> conventional proofs only because no one ever
> >>>>>>>>>>>>>>>>>>>>>>>> previously bothered to fully examine how a
> >>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider would address these
> >>>>>>>>>>>>>>>>>>>>>>>> otherwise "impossible" inputs.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> I have shown that a simulating halt decider
> >>>>>>>>>>>>>>>>>>>>>>> needn't be recursive in nature:
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> You sure do make it easy to review your work.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> "When the simulator detects the
> >>>>>>>>>>>>>>>>>>>>>> call to H in P it forks the simulation into a
> >>>>>>>>>>>>>>>>>>>>>> non-halting branch"
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> There is an infinite set of cases where this
> >>>>>>>>>>>>>>>>>>>>>> overly simplistic criteria gets the wrong
> >>>>>>>>>>>>>>>>>>>>>> answer.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> That is neither an honest review or any kind of
> >>>>>>>>>>>>>>>>>>>>> rebuttal: I have told you before: assertions
> >>>>>>>>>>>>>>>>>>>>> made without evidence can be dismissed without
> >>>>>>>>>>>>>>>>>>>>> evidence.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> If you claim there are an infinite number of
> >>>>>>>>>>>>>>>>>>>>> cases where it gets the wrong answer then it
> >>>>>>>>>>>>>>>>>>>>> shouldn't be too hard for to provide ONE case
> >>>>>>>>>>>>>>>>>>>>> backing up your claim.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>> Sure:
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> static int count = 3;
> >>>>>>>>>>>>>>>>>>>> count--;
> >>>>>>>>>>>>>>>>>>>> if (!count) goto exit;
> >>>>>>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>> exit:
> >>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>> Nope; you seem to have forgotten that my decider
> >>>>>>>>>>>>>>>>>>> is not recursive in nature: my decider will
> >>>>>>>>>>>>>>>>>>> correctly determine that that input is
> >>>>>>>>>>>>>>>>>>> pathological so will signal an exception.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> The above terminates normally so your decider gets
> >>>>>>>>>>>>>>>>>> the wrong answer.
> >>>>>>>>>>>>>>>>> It is a pathological input so neither halts nor
> >>>>>>>>>>>>>>>>> doesn't halt: pathological input is INVALID so the
> >>>>>>>>>>>>>>>>> correct "answer" is to signal an exception.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> So you don't know how static variables work?
> >>>>>>>>>>>>>>>> I am not surprised.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> static int count = 0;
> >>>>>>>>>>>>>>>> if (count++ >= 2) goto exit;
> >>>>>>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>> exit:
> >>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P,P));
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> _Pm()
> >>>>>>>>>>>>>>>> [0000141e](01) 55 push ebp
> >>>>>>>>>>>>>>>> [0000141f](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>> [00001421](03) 83ec08 sub esp,+08
> >>>>>>>>>>>>>>>> [00001424](05) a100000000 mov eax,[00000000]
> >>>>>>>>>>>>>>>> [00001429](03) 8945fc mov [ebp-04],eax
> >>>>>>>>>>>>>>>> [0000142c](06) 8b0d00000000 mov ecx,[00000000]
> >>>>>>>>>>>>>>>> [00001432](03) 83c101 add ecx,+01
> >>>>>>>>>>>>>>>> [00001435](06) 890d00000000 mov [00000000],ecx
> >>>>>>>>>>>>>>>> [0000143b](04) 837dfc02 cmp dword [ebp-04],+02
> >>>>>>>>>>>>>>>> [0000143f](02) 7c02 jl 00001443
> >>>>>>>>>>>>>>>> [00001441](02) eb1b jmp 0000145e
> >>>>>>>>>>>>>>>> [00001443](03) 8b5508 mov edx,[ebp+08]
> >>>>>>>>>>>>>>>> [00001446](01) 52 push edx
> >>>>>>>>>>>>>>>> [00001447](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>> [0000144a](01) 50 push eax
> >>>>>>>>>>>>>>>> [0000144b](05) e8defcffff call 0000112e
> >>>>>>>>>>>>>>>> [00001450](03) 83c408 add esp,+08
> >>>>>>>>>>>>>>>> [00001453](03) 8945f8 mov [ebp-08],eax
> >>>>>>>>>>>>>>>> [00001456](04) 837df800 cmp dword [ebp-08],+00
> >>>>>>>>>>>>>>>> [0000145a](02) 7402 jz 0000145e
> >>>>>>>>>>>>>>>> [0000145c](02) ebfe jmp 0000145c
> >>>>>>>>>>>>>>>> [0000145e](02) 8be5 mov esp,ebp
> >>>>>>>>>>>>>>>> [00001460](01) 5d pop ebp
> >>>>>>>>>>>>>>>> [00001461](01) c3 ret
> >>>>>>>>>>>>>>>> Size in bytes:(0068) [00001461]
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> _main()
> >>>>>>>>>>>>>>>> [0000146e](01) 55 push ebp
> >>>>>>>>>>>>>>>> [0000146f](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>> [00001471](05) 681e140000 push 0000141e
> >>>>>>>>>>>>>>>> [00001476](05) 681e140000 push 0000141e
> >>>>>>>>>>>>>>>> [0000147b](05) e8aefcffff call 0000112e
> >>>>>>>>>>>>>>>> [00001480](03) 83c408 add esp,+08
> >>>>>>>>>>>>>>>> [00001483](01) 50 push eax
> >>>>>>>>>>>>>>>> [00001484](05) 685f050000 push 0000055f
> >>>>>>>>>>>>>>>> [00001489](05) e820f1ffff call 000005ae
> >>>>>>>>>>>>>>>> [0000148e](03) 83c408 add esp,+08
> >>>>>>>>>>>>>>>> [00001491](02) 33c0 xor eax,eax
> >>>>>>>>>>>>>>>> [00001493](01) 5d pop ebp
> >>>>>>>>>>>>>>>> [00001494](01) c3 ret
> >>>>>>>>>>>>>>>> Size in bytes:(0039) [00001494]
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> machine stack stack machine
> >>>>>>>>>>>>>>>> assembly address address data code
> >>>>>>>>>>>>>>>> language ======== ======== ======== =========
> >>>>>>>>>>>>>>>> ============= [0000146e][00102462][00000000] 55
> >>>>>>>>>>>>>>>> push ebp [0000146f][00102462][00000000] 8bec
> >>>>>>>>>>>>>>>> mov ebp,esp [00001471][0010245e][0000141e] 681e140000
> >>>>>>>>>>>>>>>> push 0000141e [00001476][0010245a][0000141e]
> >>>>>>>>>>>>>>>> 681e140000 push 0000141e
> >>>>>>>>>>>>>>>> [0000147b][00102456][00001480] e8aefcffff call
> >>>>>>>>>>>>>>>> 0000112e
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> H: Begin Simulation Execution Trace Stored
> >>>>>>>>>>>>>>>> at:11250e Address_of_H:112e
> >>>>>>>>>>>>>>>> [0000141e][001124fa][001124fe] 55 push ebp
> >>>>>>>>>>>>>>>> [0000141f][001124fa][001124fe] 8bec mov
> >>>>>>>>>>>>>>>> ebp,esp [00001421][001124f2][90909090] 83ec08
> >>>>>>>>>>>>>>>> sub esp,+08 [00001424][001124f2][90909090]
> >>>>>>>>>>>>>>>> a100000000 mov eax,[00000000]
> >>>>>>>>>>>>>>>> [00001429][001124f2][90909090] 8945fc mov
> >>>>>>>>>>>>>>>> [ebp-04],eax [0000142c][001124f2][90909090]
> >>>>>>>>>>>>>>>> 8b0d00000000 mov ecx,[00000000]
> >>>>>>>>>>>>>>>> [00001432][001124f2][90909090] 83c101 add
> >>>>>>>>>>>>>>>> ecx,+01 [00001435][001124f2][90909090] 890d00000000
> >>>>>>>>>>>>>>>> mov [00000000],ecx [0000143b][001124f2][90909090]
> >>>>>>>>>>>>>>>> 837dfc02 cmp dword [ebp-04],+02
> >>>>>>>>>>>>>>>> [0000143f][001124f2][90909090] 7c02 jl 00001443
> >>>>>>>>>>>>>>>> [00001441][001124f2][90909090] eb1b jmp 0000145e
> >>>>>>>>>>>>>>>> [0000145e][001124fa][001124fe] 8be5 mov esp,ebp
> >>>>>>>>>>>>>>>> [00001460][001124fe][00001217] 5d pop ebp
> >>>>>>>>>>>>>>>> [00001461][00112502][0000141e] c3 ret H:
> >>>>>>>>>>>>>>>> End Simulation Input Terminated Normally
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> [00001480][00102462][00000000] 83c408 add
> >>>>>>>>>>>>>>>> esp,+08 [00001483][0010245e][00000001] 50
> >>>>>>>>>>>>>>>> push eax [00001484][0010245a][0000055f] 685f050000
> >>>>>>>>>>>>>>>> push 0000055f [00001489][0010245a][0000055f]
> >>>>>>>>>>>>>>>> e820f1ffff call 000005ae Input_Halts = 1
> >>>>>>>>>>>>>>>> [0000148e][00102462][00000000] 83c408 add
> >>>>>>>>>>>>>>>> esp,+08 [00001491][00102462][00000000] 33c0
> >>>>>>>>>>>>>>>> xor eax,eax [00001493][00102466][00000018] 5d
> >>>>>>>>>>>>>>>> pop ebp [00001494][0010246a][00000000] c3
> >>>>>>>>>>>>>>>> ret Number of Instructions Executed(1317) == 20
> >>>>>>>>>>>>>>>> Pages
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> For this particular stack trace I notice that the
> >>>>>>>>>>>>>>> function symbol at the top of it is Pm not P which
> >>>>>>>>>>>>>>> suggests to me one of two things:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I already had a P so I renamed it to Pm so it would not
> >>>>>>>>>>>>>> disturb my existing code. When I changed all the Pm
> >>>>>>>>>>>>>> references to your name I forgot one.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Then I suggest you check the output of
> >>>>>>>>>>>>> compilation/linking is actually initializing static
> >>>>>>>>>>>>> variables correctly. Are you even using a linker or
> >>>>>>>>>>>>> are you just executing an object file? Static data
> >>>>>>>>>>>>> normally goes into a separate data segment during the
> >>>>>>>>>>>>> linking process.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>
> >>>>>>>>>>>> I haven't used static data in such a long time that I
> >>>>>>>>>>>> forgot the compiler does not allocate any space for
> >>>>>>>>>>>> static variables unless they have been initialized to a
> >>>>>>>>>>>> non-zero value.
> >>>>>>>>>>>>
> >>>>>>>>>>>> void Pm(u32 x)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> static int count = 0x777;
> >>>>>>>>>>>> if (count++ > 0x777) goto exit;
> >>>>>>>>>>>> int Halt_Status = H(x, x);
> >>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>> exit:
> >>>>>>>>>>>> return;
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> int main()
> >>>>>>>>>>>> {
> >>>>>>>>>>>> Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> _Pm()
> >>>>>>>>>>>> [00000a1a](01) 55 push ebp
> >>>>>>>>>>>> [00000a1b](02) 8bec mov ebp,esp
> >>>>>>>>>>>> [00000a1d](03) 83ec08 sub esp,+08
> >>>>>>>>>>>> [00000a20](05) a107030000 mov eax,[00000307]
> >>>>>>>>>>>> [00000a25](03) 8945fc mov [ebp-04],eax
> >>>>>>>>>>>> [00000a28](06) 8b0d07030000 mov ecx,[00000307]
> >>>>>>>>>>>> [00000a2e](03) 83c101 add ecx,+01
> >>>>>>>>>>>> [00000a31](06) 890d07030000 mov [00000307],ecx
> >>>>>>>>>>>> [00000a37](07) 817dfc77070000 cmp dword
> >>>>>>>>>>>> [ebp-04],00000777 [00000a3e](02) 7e02 jng
> >>>>>>>>>>>> 00000a42 [00000a40](02) eb1b jmp 00000a5d
> >>>>>>>>>>>> [00000a42](03) 8b5508 mov edx,[ebp+08]
> >>>>>>>>>>>> [00000a45](01) 52 push edx
> >>>>>>>>>>>> [00000a46](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>> [00000a49](01) 50 push eax
> >>>>>>>>>>>> [00000a4a](05) e8ebfdffff call 0000083a // call H
> >>>>>>>>>>>> [00000a4f](03) 83c408 add esp,+08
> >>>>>>>>>>>> [00000a52](03) 8945f8 mov [ebp-08],eax
> >>>>>>>>>>>> [00000a55](04) 837df800 cmp dword [ebp-08],+00
> >>>>>>>>>>>> [00000a59](02) 7402 jz 00000a5d
> >>>>>>>>>>>> [00000a5b](02) ebfe jmp 00000a5b
> >>>>>>>>>>>> [00000a5d](02) 8be5 mov esp,ebp
> >>>>>>>>>>>> [00000a5f](01) 5d pop ebp
> >>>>>>>>>>>> [00000a60](01) c3 ret
> >>>>>>>>>>>> Size in bytes:(0071) [00000a60]
> >>>>>>>>>>>>
> >>>>>>>>>>>> _main()
> >>>>>>>>>>>> [00000a6a](01) 55 push ebp
> >>>>>>>>>>>> [00000a6b](02) 8bec mov ebp,esp
> >>>>>>>>>>>> [00000a6d](05) 681a0a0000 push 00000a1a // push
> >>>>>>>>>>>> address of P [00000a72](05) 681a0a0000 push
> >>>>>>>>>>>> 00000a1a // push address of P [00000a77](05) e8befdffff
> >>>>>>>>>>>> call 0000083a // call H [00000a7c](03) 83c408
> >>>>>>>>>>>> add esp,+08 [00000a7f](01) 50 push eax
> >>>>>>>>>>>> [00000a80](05) 680b030000 push 0000030b
> >>>>>>>>>>>> [00000a85](05) e8d0f8ffff call 0000035a
> >>>>>>>>>>>> [00000a8a](03) 83c408 add esp,+08
> >>>>>>>>>>>> [00000a8d](02) 33c0 xor eax,eax
> >>>>>>>>>>>> [00000a8f](01) 5d pop ebp
> >>>>>>>>>>>> [00000a90](01) c3 ret
> >>>>>>>>>>>> Size in bytes:(0039) [00000a90]
> >>>>>>>>>>>>
> >>>>>>>>>>>> machine stack stack machine assembly
> >>>>>>>>>>>> address address data code language
> >>>>>>>>>>>> ======== ======== ======== =========
> >>>>>>>>>>>> ============= ...[00000a6a][0010137b][00000000] 55
> >>>>>>>>>>>> push ebp ...[00000a6b][0010137b][00000000] 8bec
> >>>>>>>>>>>> mov ebp,esp ...[00000a6d][00101377][00000a1a]
> >>>>>>>>>>>> 681a0a0000 push 00000a1a
> >>>>>>>>>>>> ...[00000a72][00101373][00000a1a] 681a0a0000 push
> >>>>>>>>>>>> 00000a1a ...[00000a77][0010136f][00000a7c] e8befdffff
> >>>>>>>>>>>> call 0000083a New slave_stack at:201427
> >>>>>>>>>>>>
> >>>>>>>>>>>> Begin Local Halt Decider Simulation Execution Trace
> >>>>>>>>>>>> Stored at:21142f ...[00000a1a][0021141b][0021141f] 55
> >>>>>>>>>>>> push ebp ...[00000a1b][0021141b][0021141f] 8bec
> >>>>>>>>>>>> mov ebp,esp ...[00000a1d][00211413][90909090] 83ec08
> >>>>>>>>>>>> sub esp,+08 ...[00000a20][00211413][90909090]
> >>>>>>>>>>>> a107030000 mov eax,[00000307]
> >>>>>>>>>>>> ...[00000a25][00211413][90909090] 8945fc mov
> >>>>>>>>>>>> [ebp-04],eax ...[00000a28][00211413][90909090]
> >>>>>>>>>>>> 8b0d07030000 mov ecx,[00000307]
> >>>>>>>>>>>> ...[00000a2e][00211413][90909090] 83c101 add ecx,+01
> >>>>>>>>>>>> ...[00000a31][00211413][90909090] 890d07030000 mov
> >>>>>>>>>>>> [00000307],ecx ...[00000a37][00211413][90909090]
> >>>>>>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>>>>>>>>> ...[00000a3e][00211413][90909090] 7e02 jng
> >>>>>>>>>>>> 00000a42 ...[00000a42][00211413][90909090] 8b5508 mov
> >>>>>>>>>>>> edx,[ebp+08] ...[00000a45][0021140f][00000a1a] 52 push
> >>>>>>>>>>>> edx // push address of P
> >>>>>>>>>>>> ...[00000a46][0021140f][00000a1a] 8b4508 mov
> >>>>>>>>>>>> eax,[ebp+08] ...[00000a49][0021140b][00000a1a] 50 push
> >>>>>>>>>>>> eax // push address of P
> >>>>>>>>>>>> ...[00000a4a][00211407][00000a4f] e8ebfdffff call
> >>>>>>>>>>>> 0000083a // call H New slave_stack at:24be4f
> >>>>>>>>>>>> ...[00000a1a][0025be43][0025be47] 55 push ebp
> >>>>>>>>>>>> ...[00000a1b][0025be43][0025be47] 8bec mov ebp,esp
> >>>>>>>>>>>> ...[00000a1d][0025be3b][90909090] 83ec08 sub esp,+08
> >>>>>>>>>>>> ...[00000a20][0025be3b][90909090] a107030000 mov
> >>>>>>>>>>>> eax,[00000307] ...[00000a25][0025be3b][90909090] 8945fc
> >>>>>>>>>>>> mov [ebp-04],eax ...[00000a28][0025be3b][90909090]
> >>>>>>>>>>>> 8b0d07030000 mov ecx,[00000307]
> >>>>>>>>>>>> ...[00000a2e][0025be3b][90909090] 83c101 add ecx,+01
> >>>>>>>>>>>> ...[00000a31][0025be3b][90909090] 890d07030000 mov
> >>>>>>>>>>>> [00000307],ecx ...[00000a37][0025be3b][90909090]
> >>>>>>>>>>>> 817dfc77070000 cmp dword [ebp-04],00000777
> >>>>>>>>>>>> ...[00000a3e][0025be3b][90909090] 7e02 jng
> >>>>>>>>>>>> 00000a42 ...[00000a40][0025be3b][90909090] eb1b jmp
> >>>>>>>>>>>> 00000a5d // jmp to exit
> >>>>>>>>>>>> ...[00000a5d][0025be43][0025be47] 8be5 mov
> >>>>>>>>>>>> esp,ebp ...[00000a5f][0025be47][00000904] 5d pop ebp
> >>>>>>>>>>>> ...[00000a60][0025be4b][00000a1a] c3 ret
> >>>>>>>>>>>> ...[00000a7c][0010137b][00000000] 83c408 add
> >>>>>>>>>>>> esp,+08 ...[00000a7f][00101377][00000001] 50 push eax
> >>>>>>>>>>>> ...[00000a80][00101373][0000030b] 680b030000 push
> >>>>>>>>>>>> 0000030b ---[00000a85][00101373][0000030b] e8d0f8ffff
> >>>>>>>>>>>> call 0000035a Input_Halts = 1
> >>>>>>>>>>>> ...[00000a8a][0010137b][00000000] 83c408 add
> >>>>>>>>>>>> esp,+08 ...[00000a8d][0010137b][00000000] 33c0 xor
> >>>>>>>>>>>> eax,eax ...[00000a8f][0010137f][00100000] 5d pop ebp
> >>>>>>>>>>>> ...[00000a90][00101383][00000004] c3 ret Number of
> >>>>>>>>>>>> Instructions Executed(27278)
> >>>>>>>>>>>
> >>>>>>>>>>> Still seems wrong: post increment of the static variable
> >>>>>>>>>>> should ensure that it does NOT goto exit but instead
> >>>>>>>>>>> should call H which should presumably cause your "infinite
> >>>>>>>>>>> recursion detected" bollocks to manifest.
> >>>>>>>>>>
> >>>>>>>>>> OK, I've looked at your assembly trace and it is recursing
> >>>>>>>>>> into Pm from H and then halting but I am not sure what you
> >>>>>>>>>> are trying to prove? Again [Strachey 1965] and associated
> >>>>>>>>>> proofs are not recursive in nature.
> >>>>>>>>>>
> >>>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>> (1) H cannot correctly determine the halt status of the HP
> >>>>>>>>> counter-examples unless H is a simulating halt decider.
> >>>>>>>>>
> >>>>>>>>> (2) The claim of the halting problem proofs is that no H in
> >>>>>>>>> the universe can possibly correctly determine the halt
> >>>>>>>>> status of its corresponding pathological input.
> >>>>>>>>>
> >>>>>>>>> (3) H(P,P) does correctly determine that its correponding
> >>>>>>>>> pathological input would never halt.
> >>>>>>>>>
> >>>>>>>>> (4) It is ridiculously stupid of you to say that [Strachey
> >>>>>>>>> 1965] does not specify infinitely recursive simulation when
> >>>>>>>>> it is an easily verified fact that when Strachey T <is> a
> >>>>>>>>> simulating halt decider that Strachey P <does> specify
> >>>>>>>>> infinitely recursive simulation.
> >>>>>>>>>
> >>>>>>>>> It does not say this directly in [Strachey 1965] only
> >>>>>>>>> because no one ever previously bothered to fully examine
> >>>>>>>>> the effect of a simulating halt decider on the HP's
> >>>>>>>>> pathological inputs.
> >>>>>>>>
> >>>>>>>> I see I have to repeat myself yet again: a simulating halt
> >>>>>>>> decider needn't be recursive in nature and I have sketched a
> >>>>>>>> design of such a halt decider:
> >>>>>>>>
> >>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>>>>>>
> >>>>>>>> You are incorrect to claim an equivalence between
> >>>>>>>> pathological input and non-halting.
> >>>>>>>>
> >>>>>>>> /Flibble
> >>>>>>>>
> >>>>>>>
> >>>>>>> 19 When the simulator detects the call to H in P it forks the
> >>>>>>> simulation 20 into a non-halting branch (returning 0 to P)
> >>>>>>> and a halting branch 21 (returning 1 to P)
> >>>>>>>
> >>>>>>> Software engineers at the low end of technical competence may
> >>>>>>> not fully comprehend the common knowledge that:
> >>>>>>>
> >>>>>>> Whenever a function is called in what is essentially infinite
> >>>>>>> recursion this function cannot possibly correctly return any
> >>>>>>> value to its caller. You don't seem to understand that.
> >>>>>>
> >>>>>> Why are you so fucking obtuse? My forking simulating decider IS
> >>>>>> NOT RECURSIVE.
> >>>>>
> >>>>> It is directly disobeying the actual behavior specified by the
> >>>>> actual input by returning a value to a function that called it
> >>>>> in infinite recursion.
> >>>>>
> >>>>>
> >>>>
> >>>> Even if we did accept that your pathological self-reference
> >>>> detector is valid it is only a copycat of my idea and it provides
> >>>> a weaker result. It answers: I don't know and mine answers:
> >>>> non-halting.
> >>>
> >>> I could trivially change my decider to return a decision of
> >>> non-halting instead of signaling an exception if I believed such a
> >>> mapping was correct, but I don't, so I won't.
> >>>
> >>>>
> >>>> Because you did not even copycat my criteria correctly your H
> >>>> gets the wrong answer on this input.
> >>>>
> >>>> int add(int N)
> >>>> {
> >>>> return N + 3;
> >>>> }
> >>>>
> >>>> void Pc(ptr x)
> >>>> {
> >>>> H(add, (ptr)7);
> >>>> return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H(Pc,Pc));
> >>>> }
> >>>
> >>> My decider would correctly answer that Pc halts: passing a
> >>> different input to H would be equivalent to the call to H from
> >>> main(), i.e. it would be a function call rather than a fork
> >>> detection: forks only happen if H is called with the same input
> >>> more than once.
> >>>
> >>> /Flibble
> >>>
> >>
> >> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>
> >> You did not bother to copycat my criteria: "with the same input"
> >> therefore your specification fails the above test.
> >
> > The only thing my decider and your decider have in common is that
> > they are both simulating halt deciders.
> >
> >>
> >> When simulating halt decider H(P,P) simulates its input we can see
> >> that: (1) Function H() is called from P().
> >> (2) With the same arguments to H().
> >> (3) With no instructions in P preceding its invocation of H(P,P).
> >>
> >> As already shown before you also did not bother to copycat my
> >> criteria (3) which provides another escape route from
> >> non-termination.
> >>
> >> When you add these crriteria I insist on a reference to my
> >> copyright notice for these criteria.
> >>
> >> *Halting problem proofs refuted on the basis of software
> >> engineering*
> >> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
> >>
> >
> > No. You cannot copyright the idea of a simulating halt decider; you
> > only have a copyright for your broken simulating halt decider.
> >
> > /Flibble
> >
>
> *I have a copyright on these words and every precise paraphrase*
>
> When simulating halt decider H(P,P) simulates its input we can see
> that: (1) Function H() is called from P().
> (2) With the same arguments to H().
> (3) With no instructions in P preceding its invocation of H(P,P).
>
> https://en.wikipedia.org/wiki/Paraphrasing_of_copyrighted_material
>
> You are expressing using (1)
> "When the simulator detects the call to H in P"
> https://github.com/i42output/halting-problem/blob/main/README.txt
>
> have referred to (2) after the fact when I pointed out that it was
> missing from your spec
>
> On 7/15/2022 1:41 PM, Mr Flibble wrote:
> > ... if H is called with the same input more than once.
>
> and have not bothered to correct the (false positive) error of your
> specification by failing to include (3).
>
> You may use the above three criteria in your spec only if you post my
> copyright notice: Copyright 2022 PL Olcott
>
> After you fully copycat my criteria your pathological reference
> detector might be valid. You may not copycat this criteria without my
> copyright notice.
>
> *Halting problem proofs refuted on the basis of software engineering*
> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
You cannot copyright the idea of a simulating halt decider and I have
not copied your words: your approach and my approach are quite
different; my approach works whilst your approach fails to decide the
following correctly:
void Px(void (*x)())
{
(void) H(x, x);
return;
}
Px always halts and my approach returns a correct decision of halting
whilst your approach returns an incorrect decision of non-halting
proving that our approaches are fundamentally different.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2022-07-15 19:32 -0400 |
| Subject | Re: Halting problem proofs refuted on the basis of software engineering [ establishing my authorship and asserting my copyrights ] |
| Message-ID | <zOmAK.59871$%e2.10898@fx40.iad> |
| In reply to | #85275 |
On 7/15/22 3:28 PM, olcott wrote: > > *I have a copyright on these words and every precise paraphrase* IMPOSSIBLE, you can only copyright what you write. You can possible show that a paraphrase violates you artistic expression of your statement, but you can't actually copyright an "idea" > > When simulating halt decider H(P,P) simulates its input we can see that: > (1) Function H() is called from P(). > (2) With the same arguments to H(). > (3) With no instructions in P preceding its invocation of H(P,P). > And since (3) is INCORRECT (as far as actual halting, and the way you use it) you whole proof is show to be incorrect. The ACTUAL rule similar to that includes the code in H that P calls. > https://en.wikipedia.org/wiki/Paraphrasing_of_copyrighted_material So, you didn't read what it said? > United States copyright law protects original expressions but not facts, methods, discoveries, or other ideas being expressed, a doctrine known as the idea–expression distinction. Despite making this distinction, verbatim copying is not always required for copyright infringement, as paraphrasing is also prohibited in certain circumstances. so, unless you are actually ADMITTING that you statement isn't a "Fact" or a "Discovery", you can't actully claim copyright on what you have said. Which, I suppose IS what you are doing, (Admitting it that is). > > You are expressing using (1) > "When the simulator detects the call to H in P" > https://github.com/i42output/halting-problem/blob/main/README.txt > > have referred to (2) after the fact when I pointed out that it was > missing from your spec > > On 7/15/2022 1:41 PM, Mr Flibble wrote: > > ... if H is called with the same input more than once. > > and have not bothered to correct the (false positive) error of your > specification by failing to include (3). > > You may use the above three criteria in your spec only if you post my > copyright notice: Copyright 2022 PL Olcott > > After you fully copycat my criteria your pathological reference detector > might be valid. You may not copycat this criteria without my copyright > notice. > > *Halting problem proofs refuted on the basis of software engineering*
[toc] | [prev] | [next] | [standalone]
| From | Skep Dick <skepdick22@gmail.com> |
|---|---|
| Date | 2022-07-15 12:20 -0700 |
| Message-ID | <d8011969-f074-434b-ade1-dc040c42dcfen@googlegroups.com> |
| In reply to | #85268 |
On Friday, 15 July 2022 at 21:04:43 UTC+2, olcott wrote: > Thoughts? I am probably missing something obvious. Yeah. You are missing the most obvious things of all. If H can execute P in a sandbox, then P can execute H in a sandbox. Function H **executing** function P in isolated runtime is not the same thing as function H **calling** function P within the same runtime. But, of course you know this. You are just going to conveniently ignore it (again) for your usual contrarian reasons. It's really boresone that the only way you know how to learn is through conflict and exploiting Cunningham's law.
[toc] | [prev] | [next] | [standalone]
Page 2 of 9 — ← Prev page 1 [2] 3 4 5 6 7 8 9 Next page →
Back to top | Article view | comp.lang.c++
csiph-web