Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #105649 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2024-05-28 11:16 -0500 |
| Last post | 2024-06-03 13:36 +0300 |
| Articles | 20 on this page of 361 — 14 participants |
Back to article view | Back to comp.theory
D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-28 11:16 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-28 22:04 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-28 21:23 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-28 23:38 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-28 22:49 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Mikko <mikko.levanto@iki.fi> - 2024-05-29 12:14 +0300
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-29 08:24 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-29 19:47 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-29 19:01 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-29 20:09 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-29 19:21 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-29 20:47 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-29 19:53 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-29 21:02 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-29 20:12 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-29 21:25 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-29 20:55 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-29 22:25 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-29 21:36 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-29 22:55 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-29 22:48 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets joes <noreply@example.com> - 2024-05-30 09:11 +0000
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-30 08:11 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets immibis <news@immibis.com> - 2024-05-30 19:58 +0200
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-30 21:37 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets immibis <news@immibis.com> - 2024-05-30 12:11 +0200
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-30 07:33 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Mikko <mikko.levanto@iki.fi> - 2024-05-31 11:51 +0300
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets immibis <news@immibis.com> - 2024-05-31 11:15 +0200
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Mikko <mikko.levanto@iki.fi> - 2024-05-31 16:12 +0300
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-30 07:32 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-29 07:31 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-29 08:49 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Alan Mackenzie <acm@muc.de> - 2024-05-29 15:40 +0000
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-29 11:17 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-05-29 18:08 +0100
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-29 12:32 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-29 19:47 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-29 13:08 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-29 19:47 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-29 19:47 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Ben Bacarisse <ben@bsb.me.uk> - 2024-05-29 19:14 +0100
Two dozen people were simply wrong olcott <polcott333@gmail.com> - 2024-05-29 13:31 -0500
Re: Two dozen people were simply wrong Alan Mackenzie <acm@muc.de> - 2024-05-29 20:17 +0000
Re: Two dozen people were simply wrong olcott <polcott333@gmail.com> - 2024-05-29 15:25 -0500
Re: Two dozen people were simply wrong Python <python@invalid.org> - 2024-05-29 22:54 +0200
Re: Two dozen people were simply wrong olcott <polcott333@gmail.com> - 2024-05-29 16:14 -0500
Re: Two dozen people were simply wrong (including Olcott) Richard Damon <richard@damon-family.org> - 2024-05-29 19:47 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-29 18:57 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Richard Damon <richard@damon-family.org> - 2024-05-29 20:09 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-29 19:17 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Richard Damon <richard@damon-family.org> - 2024-05-29 20:48 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-29 19:59 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Richard Damon <richard@damon-family.org> - 2024-05-29 21:07 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-29 20:15 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Richard Damon <richard@damon-family.org> - 2024-05-29 21:24 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-29 20:37 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Richard Damon <richard@damon-family.org> - 2024-05-29 22:24 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-29 20:48 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Richard Damon <richard@damon-family.org> - 2024-05-29 22:27 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-29 21:32 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Richard Damon <richard@damon-family.org> - 2024-05-29 22:55 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-29 22:58 -0500
Re: Olcott was simply wrong --- Try to prove otherwise Richard Damon <richard@damon-family.org> - 2024-05-30 07:30 -0400
Re: Olcott was simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-30 09:04 -0500
Re: Olcott was simply wrong --- Try to prove otherwise Richard Damon <richard@damon-family.org> - 2024-05-30 21:37 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise joes <noreply@example.com> - 2024-05-30 09:08 +0000
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-30 08:21 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Mikko <mikko.levanto@iki.fi> - 2024-05-31 11:08 +0300
Re: Two dozen people were simply wrong --- Try to prove otherwise --- Mike Terry olcott <polcott333@gmail.com> - 2024-05-31 10:04 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Mikko <mikko.levanto@iki.fi> - 2024-05-30 10:40 +0300
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-30 08:31 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Richard Damon <richard@damon-family.org> - 2024-05-30 21:37 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-30 20:54 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Richard Damon <richard@damon-family.org> - 2024-05-30 22:15 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-30 21:32 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Richard Damon <richard@damon-family.org> - 2024-05-30 22:51 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-30 21:58 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Richard Damon <richard@damon-family.org> - 2024-05-30 23:15 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-30 22:27 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Richard Damon <richard@damon-family.org> - 2024-05-31 07:16 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-05-31 09:10 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-05-31 17:36 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-05-31 17:08 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-05-31 18:46 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-05-31 17:54 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-05-31 19:33 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-05-31 18:57 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-05-31 20:39 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-05-31 20:10 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-05-31 21:35 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-05-31 21:08 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-05-31 22:25 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-05-31 21:40 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 07:22 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 10:30 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 11:56 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 11:13 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-01 18:19 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 11:24 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-01 20:40 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 13:44 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-01 21:04 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 15:11 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 10:56 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-02 09:37 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 20:02 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-02 13:13 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-02 14:20 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down joes <noreply@example.com> - 2024-06-02 09:18 +0000
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-02 09:54 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 12:27 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 11:38 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 13:22 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 12:27 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 13:33 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 12:44 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 13:56 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 13:07 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 14:21 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 13:31 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 14:43 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 13:46 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down immibis <news@immibis.com> - 2024-06-01 20:58 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 15:03 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 15:23 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 16:35 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-01 20:54 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 14:51 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 16:29 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 15:37 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 17:13 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 16:24 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 18:30 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 17:40 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 19:02 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 18:12 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 19:27 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 22:33 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-02 07:51 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-02 09:19 -0500
Re: Olcott is simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-02 13:22 -0400
Re: Olcott is simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-02 12:59 -0500
Re: Olcott is simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-02 14:13 -0400
DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD olcott <polcott333@gmail.com> - 2024-06-02 13:29 -0500
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD Richard Damon <richard@damon-family.org> - 2024-06-02 15:05 -0400
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD olcott <polcott333@gmail.com> - 2024-06-02 14:13 -0500
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD Richard Damon <Richard@Damon-Family.org> - 2024-06-02 15:22 -0400
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD olcott <polcott333@gmail.com> - 2024-06-02 14:34 -0500
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD Richard Damon <richard@damon-family.org> - 2024-06-02 16:11 -0400
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD olcott <polcott333@gmail.com> - 2024-06-02 15:21 -0500
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD Richard Damon <richard@damon-family.org> - 2024-06-02 16:32 -0400
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD immibis <news@immibis.com> - 2024-06-03 02:14 +0200
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD olcott <polcott333@gmail.com> - 2024-06-02 15:50 -0500
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD Richard Damon <richard@damon-family.org> - 2024-06-02 16:58 -0400
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD olcott <polcott333@gmail.com> - 2024-06-02 16:25 -0500
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD Richard Damon <richard@damon-family.org> - 2024-06-02 17:43 -0400
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD olcott <polcott333@gmail.com> - 2024-06-02 17:05 -0500
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD Richard Damon <richard@damon-family.org> - 2024-06-02 18:20 -0400
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD olcott <polcott333@gmail.com> - 2024-06-02 17:44 -0500
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD Richard Damon <richard@damon-family.org> - 2024-06-02 19:45 -0400
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD olcott <polcott333@gmail.com> - 2024-06-02 20:45 -0500
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD Richard Damon <richard@damon-family.org> - 2024-06-02 22:24 -0400
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD olcott <polcott333@gmail.com> - 2024-06-02 21:54 -0500
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD Richard Damon <richard@damon-family.org> - 2024-06-02 23:13 -0400
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD olcott <polcott333@gmail.com> - 2024-06-02 22:20 -0500
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-03 10:10 +0200
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD olcott <polcott333@gmail.com> - 2024-06-03 07:46 -0500
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-03 21:49 +0200
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD Richard Damon <richard@damon-family.org> - 2024-06-03 20:56 -0400
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD Richard Damon <richard@damon-family.org> - 2024-06-03 07:14 -0400
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD olcott <polcott333@gmail.com> - 2024-06-03 07:42 -0500
Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-03 21:51 +0200
Re: Olcott is simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 20:34 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 11:19 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 11:13 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 11:03 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-02 09:41 -0500
Re: Olcott is simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-02 13:22 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 20:13 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-02 13:32 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 20:49 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-02 13:53 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 20:59 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-02 15:07 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down immibis <news@immibis.com> - 2024-06-01 20:55 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down immibis <news@immibis.com> - 2024-06-01 20:53 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down joes <noreply@example.com> - 2024-06-01 20:26 +0000
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 15:32 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Mikko <mikko.levanto@iki.fi> - 2024-06-02 11:29 +0300
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-02 09:08 -0500
Re: Olcott is simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-02 13:22 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Mikko <mikko.levanto@iki.fi> - 2024-06-03 12:44 +0300
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-03 08:13 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Mikko <mikko.levanto@iki.fi> - 2024-06-03 17:35 +0300
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-03 13:19 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-03 21:51 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-03 20:56 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down immibis <news@immibis.com> - 2024-06-01 14:49 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-01 11:01 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Wasell <wasell@example.com> - 2024-06-01 10:36 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 09:00 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 11:46 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 10:58 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 12:08 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical olcott <polcott333@gmail.com> - 2024-06-01 11:18 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical Richard Damon <richard@damon-family.org> - 2024-06-01 12:33 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical olcott <polcott333@gmail.com> - 2024-06-01 11:46 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical Richard Damon <richard@damon-family.org> - 2024-06-01 16:29 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical olcott <polcott333@gmail.com> - 2024-06-01 15:35 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical Richard Damon <richard@damon-family.org> - 2024-06-01 17:15 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical olcott <polcott333@gmail.com> - 2024-06-01 16:27 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical Richard Damon <richard@damon-family.org> - 2024-06-01 18:30 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical olcott <polcott333@gmail.com> - 2024-06-01 17:37 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical Richard Damon <richard@damon-family.org> - 2024-06-01 19:02 -0400
Re: Two dozen people were simply wrong --- joes <noreply@example.com> - 2024-06-02 09:36 +0000
Re: Two dozen people were simply wrong --- olcott <polcott333@gmail.com> - 2024-06-02 09:58 -0500
Re: Olcott is simply wrong --- Richard Damon <richard@damon-family.org> - 2024-06-02 13:22 -0400
Re: Two dozen people were simply wrong --- "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 20:16 +0200
Re: Two dozen people were simply wrong --- olcott <polcott333@gmail.com> - 2024-06-02 13:37 -0500
Re: Two dozen people were simply wrong --- "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 20:51 +0200
Re: Two dozen people were simply wrong --- olcott <polcott333@gmail.com> - 2024-06-02 13:57 -0500
Re: Two dozen people were simply wrong --- "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 21:01 +0200
Re: Two dozen people were simply wrong --- olcott <polcott333@gmail.com> - 2024-06-02 14:10 -0500
Re: Two dozen people were simply wrong --- Richard Damon <richard@damon-family.org> - 2024-06-02 15:18 -0400
Re: Two dozen people were simply wrong --- "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-03 09:37 +0200
Re: Two dozen people were simply wrong --- olcott <polcott333@gmail.com> - 2024-06-03 07:24 -0500
Re: Two dozen people were simply wrong --- "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-03 21:53 +0200
Re: Two dozen people were simply wrong --- Richard Damon <richard@damon-family.org> - 2024-06-02 15:08 -0400
Re: Two dozen people were simply wrong --- olcott <polcott333@gmail.com> - 2024-06-02 10:02 -0500
Re: Two dozen people were simply wrong --- joes <noreply@example.com> - 2024-06-02 17:55 +0000
Re: Two dozen people were simply wrong --- olcott <polcott333@gmail.com> - 2024-06-02 13:08 -0500
Re: Two dozen people were simply wrong --- Richard Damon <richard@damon-family.org> - 2024-06-02 14:18 -0400
Re: Two dozen people were simply wrong --- "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 20:36 +0200
Re: Two dozen people were simply wrong --- olcott <polcott333@gmail.com> - 2024-06-02 13:42 -0500
Re: Two dozen people were simply wrong --- "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 20:53 +0200
Re: Two dozen people were simply wrong --- olcott <polcott333@gmail.com> - 2024-06-02 13:58 -0500
Re: Two dozen people were simply wrong --- "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-03 09:40 +0200
Re: Two dozen people were simply wrong --- Alan Mackenzie <acm@muc.de> - 2024-06-02 21:02 +0000
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 11:24 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical olcott <polcott333@gmail.com> - 2024-06-02 09:47 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 20:24 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical olcott <polcott333@gmail.com> - 2024-06-02 13:39 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 20:55 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical olcott <polcott333@gmail.com> - 2024-06-02 14:01 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-03 09:50 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical Richard Damon <richard@damon-family.org> - 2024-06-02 14:59 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical immibis <news@immibis.com> - 2024-06-02 21:19 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down --- canonical immibis <news@immibis.com> - 2024-06-01 20:54 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down immibis <news@immibis.com> - 2024-06-01 20:49 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-01 10:57 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 10:17 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-01 17:32 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 10:51 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 12:02 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-01 18:06 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 11:22 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 12:34 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down immibis <news@immibis.com> - 2024-06-01 20:54 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down joes <noreply@example.com> - 2024-06-01 19:12 +0000
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down immibis <news@immibis.com> - 2024-06-01 20:52 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down joes <noreply@example.com> - 2024-06-01 19:04 +0000
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 15:01 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down immibis <news@immibis.com> - 2024-06-01 23:35 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down Richard Damon <richard@damon-family.org> - 2024-06-01 11:49 -0400
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down joes <noreply@example.com> - 2024-06-01 18:59 +0000
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down joes <noreply@example.com> - 2024-06-01 18:41 +0000
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down olcott <polcott333@gmail.com> - 2024-06-01 13:45 -0500
Re: Two dozen people were simply right --- Try to prove otherwise --- pinned down joes <noreply@example.com> - 2024-06-02 09:46 +0000
Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down immibis <news@immibis.com> - 2024-06-01 14:48 +0200
Re: Two dozen people were simply wrong --- Try to prove otherwise Mikko <mikko.levanto@iki.fi> - 2024-05-31 11:30 +0300
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-31 10:13 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Mikko <mikko.levanto@iki.fi> - 2024-06-03 13:03 +0300
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-06-03 08:16 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Mikko <mikko.levanto@iki.fi> - 2024-06-03 17:49 +0300
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-06-03 13:20 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Mikko <mikko.levanto@iki.fi> - 2024-06-04 11:40 +0300
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-06-04 12:46 -0500
Re: Two dozen people were simply wrong --- Try to prove otherwise Mikko <mikko.levanto@iki.fi> - 2024-05-31 11:22 +0300
Re: Two dozen people were simply wrong --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-31 10:07 -0500
Re: H is an incorrect x86 emulator immibis <news@immibis.com> - 2024-05-30 12:24 +0200
Re: Two dozen people were simply wrong immibis <news@immibis.com> - 2024-05-30 12:04 +0200
Re: Two dozen people were simply wrong Mikko <mikko.levanto@iki.fi> - 2024-06-01 11:23 +0300
Re: Two dozen people were simply wrong -- Only basis for rebuttal in the last 3 years olcott <polcott333@gmail.com> - 2024-06-01 10:09 -0500
Re: Two dozen people were simply wrong -- Only basis for rebuttal in the last 3 years "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-01 17:18 +0200
Re: Two dozen people were simply wrong -- Only basis for rebuttal in the last 3 years olcott <polcott333@gmail.com> - 2024-06-01 10:44 -0500
Re: Two dozen people were simply wrong -- Only basis for rebuttal in the last 3 years "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-01 17:58 +0200
Re: Two dozen people were simply wrong -- Only basis for rebuttal in the last 3 years immibis <news@immibis.com> - 2024-06-01 20:51 +0200
Re: Two dozen people were simply wrong -- Only basis for rebuttal in the last 3 years joes <noreply@example.com> - 2024-06-01 19:02 +0000
Re: Two dozen people were simply wrong -- Only basis for rebuttal in the last 3 years olcott <polcott333@gmail.com> - 2024-06-01 14:58 -0500
Re: Two dozen people were simply wrong -- Only basis for rebuttal in the last 3 years Richard Damon <richard@damon-family.org> - 2024-06-01 16:28 -0400
Re: Two dozen people were simply wrong -- Only basis for rebuttal in the last 3 years immibis <news@immibis.com> - 2024-06-01 23:36 +0200
Re: Two dozen people were simply wrong -- Only basis for rebuttal in the last 3 years "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 11:28 +0200
Re: Two dozen people were simply wrong -- Only basis for rebuttal in the last 3 years immibis <news@immibis.com> - 2024-06-02 12:56 +0200
Re: Two dozen people were simply wrong -- Only basis for rebuttal in the last 3 years Mikko <mikko.levanto@iki.fi> - 2024-06-02 11:08 +0300
Re: Deciders are ONLY accountable for their actual inputs --- olcott <polcott333@gmail.com> - 2024-06-02 08:56 -0500
Re: Deciders are ONLY accountable for their actual inputs --- "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 20:39 +0200
Re: Deciders are ONLY accountable for their actual inputs --- olcott <polcott333@gmail.com> - 2024-06-02 13:46 -0500
Re: Deciders are ONLY accountable for their actual inputs --- "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 20:57 +0200
Re: Deciders are ONLY accountable for their actual inputs --- olcott <polcott333@gmail.com> - 2024-06-02 14:03 -0500
Re: Deciders are ONLY accountable for their actual inputs --- Richard Damon <richard@damon-family.org> - 2024-06-02 15:16 -0400
Re: Deciders are ONLY accountable for their actual inputs --- immibis <news@immibis.com> - 2024-06-02 21:20 +0200
Re: Deciders are ONLY accountable for their actual inputs --- immibis <news@immibis.com> - 2024-06-02 21:24 +0200
Re: Deciders are ONLY accountable for their actual inputs --- Richard Damon <richard@damon-family.org> - 2024-06-02 15:01 -0400
Re: Deciders are ONLY accountable for their actual inputs --- Mikko <mikko.levanto@iki.fi> - 2024-06-03 13:13 +0300
Re: Deciders are ONLY accountable for their actual inputs --- olcott <polcott333@gmail.com> - 2024-06-03 08:17 -0500
Re: Deciders are ONLY accountable for their actual inputs --- Mikko <mikko.levanto@iki.fi> - 2024-06-03 17:39 +0300
Re: Deciders are ONLY accountable for their actual inputs --- "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-03 21:55 +0200
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-05-29 19:47 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders olcott <polcott333@gmail.com> - 2024-05-30 09:43 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-05-30 15:59 +0100
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders olcott <polcott333@gmail.com> - 2024-05-30 10:21 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-05-30 17:13 +0100
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders olcott <polcott333@gmail.com> - 2024-05-30 11:55 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2024-05-30 21:51 +0100
Re: D correctly simulated by H cannot possibly halt --- Try to prove otherwise olcott <polcott333@gmail.com> - 2024-05-30 16:22 -0500
Re: D correctly simulated by H cannot possibly halt --- Try to prove otherwise immibis <news@immibis.com> - 2024-05-30 23:50 +0200
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- Mike Terry olcott <polcott333@gmail.com> - 2024-05-31 09:46 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders Richard Damon <richard@damon-family.org> - 2024-05-30 21:37 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-30 17:20 +0200
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders olcott <polcott333@gmail.com> - 2024-05-30 10:30 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-30 17:58 +0200
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders olcott <polcott333@gmail.com> - 2024-05-30 12:00 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-30 20:50 +0200
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders olcott <polcott333@gmail.com> - 2024-05-30 14:01 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-30 21:32 +0200
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders olcott <polcott333@gmail.com> - 2024-05-30 15:15 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-30 22:59 +0200
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders olcott <polcott333@gmail.com> - 2024-05-30 16:27 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders immibis <news@immibis.com> - 2024-05-30 23:51 +0200
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders André G. Isaak <agisaak@gm.invalid> - 2024-05-30 21:10 -0600
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders olcott <polcott333@gmail.com> - 2024-05-30 22:33 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders Richard Damon <richard@damon-family.org> - 2024-05-31 07:16 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders Jeff Barnett <jbb@notatt.com> - 2024-05-30 21:48 -0600
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders André G. Isaak <agisaak@gm.invalid> - 2024-05-30 21:52 -0600
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders olcott <polcott333@gmail.com> - 2024-05-30 23:06 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders immibis <news@immibis.com> - 2024-05-31 10:41 +0200
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders Richard Damon <richard@damon-family.org> - 2024-05-31 07:16 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders André G. Isaak <agisaak@gm.invalid> - 2024-05-30 21:14 -0600
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders olcott <polcott333@gmail.com> - 2024-05-30 22:36 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-05-31 10:02 +0200
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders olcott <polcott333@gmail.com> - 2024-05-31 09:33 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders Richard Damon <richard@damon-family.org> - 2024-05-31 07:23 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders joes <noreply@example.com> - 2024-06-01 18:07 +0000
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders olcott <polcott333@gmail.com> - 2024-06-01 13:11 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders Richard Damon <richard@damon-family.org> - 2024-06-01 14:23 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders Richard Damon <richard@damon-family.org> - 2024-05-30 21:37 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Mikko <mikko.levanto@iki.fi> - 2024-05-31 16:10 +0300
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-05-31 10:44 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Mikko <mikko.levanto@iki.fi> - 2024-06-01 11:20 +0300
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-06-01 09:52 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-06-01 11:08 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets joes <noreply@example.com> - 2024-06-01 18:56 +0000
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-06-01 14:55 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Richard Damon <richard@damon-family.org> - 2024-06-01 16:29 -0400
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets immibis <news@immibis.com> - 2024-06-01 23:36 +0200
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets joes <noreply@example.com> - 2024-06-02 09:24 +0000
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-06-02 09:55 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Mikko <mikko.levanto@iki.fi> - 2024-06-02 11:24 +0300
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets olcott <polcott333@gmail.com> - 2024-06-02 09:04 -0500
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets Mikko <mikko.levanto@iki.fi> - 2024-06-03 13:36 +0300
Page 8 of 19 — ← Prev page 1 … 6 7 [8] 9 10 … 19 Next page →
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-02 09:19 -0500 |
| Subject | Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down |
| Message-ID | <v3hv26$3bkv5$10@dont-email.me> |
| In reply to | #106004 |
On 6/2/2024 6:51 AM, Richard Damon wrote:
> On 6/1/24 11:33 PM, olcott wrote:
>> On 6/1/2024 6:27 PM, Richard Damon wrote:
>>> On 6/1/24 7:12 PM, olcott wrote:
>>>> On 6/1/2024 6:02 PM, Richard Damon wrote:
>>>>> On 6/1/24 6:40 PM, olcott wrote:
>>>>>>
>>>>>> Show me where I said anything in the above spec about an aborted
>>>>>> simulation.
>>>>>
>>>>> So, why did HH stop simulating after some n steps?
>>>>>
>>>>> Did it reach a final state in the simulation? if not, it ABORTED
>>>>> its simulation.
>>>>>
>>>>>>
>>>>>> When every possible which way DD correctly simulated by HH never
>>>>>> reaches
>>>>>> past its own simulated line 03 then
>>>>>
>>>>> And a simulation either goes until it reaches a final state of the
>>>>> machine it is simulating, or it aborted its simulation.
>>>>>
>>>>
>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>> 00 int HH(ptr p, ptr i);
>>>> 01 int DD(ptr p)
>>>> 02 {
>>>> 03 int Halt_Status = HH(p, p);
>>>> 04 if (Halt_Status)
>>>> 05 HERE: goto HERE;
>>>> 06 return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 int main()
>>>> 10 {
>>>> 11 HH(DD,DD);
>>>> 12 return 0;
>>>> 13 }
>>>>
>>>> When every DD correctly simulated by any HH cannot possibly reach
>>>> past its own simulated line 03 in 1 to ∞ steps of correct simulation
>>>> of DD by HH then we have exhaustively examined every possible HH/DD
>>>> pair and each element has of this infinite set has the same property.
>>>
>>> So?
>>>
>>> It doesn't matter how many aborted simulaiton you do of a given input
>>> (and each HH simulated a DIFFERENT input since it simulated the
>>> INSTANCE of the template with a different HH)
>>>
>>
>> In other words one cannot prove that every five pound rock weighs
>> more than every three pound rock, one must weigh them one-at-a-time?
>
> Nope. But you need to show that each rock IS a five pound rock.
>
> IF you weigh one rock, and find it is 5 pounds, doesn't mean that
> anothoer rock rock that looks about the same is also 5 pouds,
>
> You do seem to like you Herring in Red sauce, don't you.
>
> The comparison here is that you have only "weighed" a very few of your
> DDs, only those built on an HH that NEVER aborts have been determined to
> not halt. The others are just haven't-yet-halted-after-n-steps, but we
> actually DO know that they WILL Halt after more.
>
>>
>>> The ONLY simulation that actually showed that ITS input was
>>> no-halting was the HH that never aborted, and it didn't answer.
>>>
>>> Every other HH has a DIFFERENT INPUT and would be LYING to say it had
>>> that other input.
>>>
>>
>> In other words (because each rock is different) one cannot prove that
>> every five pound rock weighs more than every three pound rock, one
>> must weigh them one-at-a-time?
> Nope, unless of course you still need to weight them to show they ARE 5
> pound rocks.
>
>>
>> Every HH/DD pair of the infinite of every possible HH/DD pair
>> DD correctly simulated by HH NEVER HALTS.
>
> That isn't even your original claim you were asking about.
>
> Your claim wasn't about "Halting" because that is easily disproven, but
> that there correct PARTIAL simulation done by H never reaches the
> statement after the call.
>
> You are just showing your true colors, that you just don't understand
> what you are talkinag about and get your lies confused.
>
>>
>>>>
>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>
>>> Nope. Aborted simulation don't prove anything.
>>>
>>
>> When for each element of the infinite set of every HH/DD pair DD
>> correctly simulated by HH cannot get past its own simulated line 03
>> then we know that none of the DD inputs to each HH(DD,DD) ever halts.
>
>
> Nope. Try to actually PROVE that.
>
Semantic tautologies are self-evident truth that prove themselves.
It is a fact that every five pound rock weights more than any
three pound rock. No need to weigh any rocks.
typedef int (*ptr)(); // ptr is pointer to int function in C
00 int HH(ptr p, ptr i);
01 int DD(ptr p)
02 {
03 int Halt_Status = HH(p, p);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 int main()
10 {
11 HH(DD,DD);
12 return 0;
13 }
Likewise we correctly deduce that for every HH/DD pair of the
infinite set of all HH/DD pairs that match the above template
every DD correctly simulated by HH never reaches past its own
simulated line 03, thus never halts.
*WHEN WE LOOK AS THE X86 MACHINE CODE OF DD THIS IS UNEQUIVOCAL*
DD correctly emulated by HH with an x86 emulator cannot possibly
reach past its own machine instruction [00001c2e] in any finite (or
infinite) number of steps of correct emulation.
_DD()
[00001c22] 55 push ebp
[00001c23] 8bec mov ebp,esp
[00001c25] 51 push ecx
[00001c26] 8b4508 mov eax,[ebp+08]
[00001c29] 50 push eax ; push DD 1c22
[00001c2a] 8b4d08 mov ecx,[ebp+08]
[00001c2d] 51 push ecx ; push DD 1c22
[00001c2e] e80ff7ffff call 00001342 ; call HH
[00001c33] 83c408 add esp,+08
[00001c36] 8945fc mov [ebp-04],eax
[00001c39] 837dfc00 cmp dword [ebp-04],+00
[00001c3d] 7402 jz 00001c41
[00001c3f] ebfe jmp 00001c3f
[00001c41] 8b45fc mov eax,[ebp-04]
[00001c44] 8be5 mov esp,ebp
[00001c46] 5d pop ebp
[00001c47] c3 ret
Size in bytes:(0038) [00001c47]
--
Copyright 2024 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 | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-02 13:22 -0400 |
| Subject | Re: Olcott is simply wrong --- Try to prove otherwise --- pinned down |
| Message-ID | <v3i9o8$2qu72$1@i2pn2.org> |
| In reply to | #106014 |
On 6/2/24 10:19 AM, olcott wrote:
> On 6/2/2024 6:51 AM, Richard Damon wrote:
>> On 6/1/24 11:33 PM, olcott wrote:
>>> On 6/1/2024 6:27 PM, Richard Damon wrote:
>>>> On 6/1/24 7:12 PM, olcott wrote:
>>>>> On 6/1/2024 6:02 PM, Richard Damon wrote:
>>>>>> On 6/1/24 6:40 PM, olcott wrote:
>>>>>>>
>>>>>>> Show me where I said anything in the above spec about an aborted
>>>>>>> simulation.
>>>>>>
>>>>>> So, why did HH stop simulating after some n steps?
>>>>>>
>>>>>> Did it reach a final state in the simulation? if not, it ABORTED
>>>>>> its simulation.
>>>>>>
>>>>>>>
>>>>>>> When every possible which way DD correctly simulated by HH never
>>>>>>> reaches
>>>>>>> past its own simulated line 03 then
>>>>>>
>>>>>> And a simulation either goes until it reaches a final state of the
>>>>>> machine it is simulating, or it aborted its simulation.
>>>>>>
>>>>>
>>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>>> 00 int HH(ptr p, ptr i);
>>>>> 01 int DD(ptr p)
>>>>> 02 {
>>>>> 03 int Halt_Status = HH(p, p);
>>>>> 04 if (Halt_Status)
>>>>> 05 HERE: goto HERE;
>>>>> 06 return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 int main()
>>>>> 10 {
>>>>> 11 HH(DD,DD);
>>>>> 12 return 0;
>>>>> 13 }
>>>>>
>>>>> When every DD correctly simulated by any HH cannot possibly reach
>>>>> past its own simulated line 03 in 1 to ∞ steps of correct simulation
>>>>> of DD by HH then we have exhaustively examined every possible HH/DD
>>>>> pair and each element has of this infinite set has the same property.
>>>>
>>>> So?
>>>>
>>>> It doesn't matter how many aborted simulaiton you do of a given
>>>> input (and each HH simulated a DIFFERENT input since it simulated
>>>> the INSTANCE of the template with a different HH)
>>>>
>>>
>>> In other words one cannot prove that every five pound rock weighs
>>> more than every three pound rock, one must weigh them one-at-a-time?
>>
>> Nope. But you need to show that each rock IS a five pound rock.
>>
>> IF you weigh one rock, and find it is 5 pounds, doesn't mean that
>> anothoer rock rock that looks about the same is also 5 pouds,
>>
>> You do seem to like you Herring in Red sauce, don't you.
>>
>> The comparison here is that you have only "weighed" a very few of your
>> DDs, only those built on an HH that NEVER aborts have been determined
>> to not halt. The others are just haven't-yet-halted-after-n-steps, but
>> we actually DO know that they WILL Halt after more.
>>
>>>
>>>> The ONLY simulation that actually showed that ITS input was
>>>> no-halting was the HH that never aborted, and it didn't answer.
>>>>
>>>> Every other HH has a DIFFERENT INPUT and would be LYING to say it
>>>> had that other input.
>>>>
>>>
>>> In other words (because each rock is different) one cannot prove that
>>> every five pound rock weighs more than every three pound rock, one
>>> must weigh them one-at-a-time?
>> Nope, unless of course you still need to weight them to show they ARE
>> 5 pound rocks.
>>
>>>
>>> Every HH/DD pair of the infinite of every possible HH/DD pair
>>> DD correctly simulated by HH NEVER HALTS.
>>
>> That isn't even your original claim you were asking about.
>>
>> Your claim wasn't about "Halting" because that is easily disproven,
>> but that there correct PARTIAL simulation done by H never reaches the
>> statement after the call.
>>
>> You are just showing your true colors, that you just don't understand
>> what you are talkinag about and get your lies confused.
>>
>>>
>>>>>
>>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>>
>>>> Nope. Aborted simulation don't prove anything.
>>>>
>>>
>>> When for each element of the infinite set of every HH/DD pair DD
>>> correctly simulated by HH cannot get past its own simulated line 03
>>> then we know that none of the DD inputs to each HH(DD,DD) ever halts.
>>
>>
>> Nope. Try to actually PROVE that.
>>
>
> Semantic tautologies are self-evident truth that prove themselves.
> It is a fact that every five pound rock weights more than any
> three pound rock. No need to weigh any rocks.
Right, so you don't need to weigh a five pound rock to know it is five
bpounds.
>
> typedef int (*ptr)(); // ptr is pointer to int function in C
> 00 int HH(ptr p, ptr i);
> 01 int DD(ptr p)
> 02 {
> 03 int Halt_Status = HH(p, p);
> 04 if (Halt_Status)
> 05 HERE: goto HERE;
> 06 return Halt_Status;
> 07 }
> 08
> 09 int main()
> 10 {
> 11 HH(DD,DD);
> 12 return 0;
> 13 }
>
> Likewise we correctly deduce that for every HH/DD pair of the
> infinite set of all HH/DD pairs that match the above template
> every DD correctly simulated by HH never reaches past its own
> simulated line 03, thus never halts.
Maybe the SIMULATION never reaches past it, but that doesn't mean the
input (or the simulation) doesn't halt.
If H aborts its simulation, then the "simulation" reached its final
state, that of being aborted. Yes, the machine simulated wasn't
simulated to a final state, but the simulation did end.
And since H aborted its simulation, there is no evidence that the
machine simulated will never reach a final state, and in fact, we can
show that
So, your "Self-Evident Truth" is proved to be incorrect, just like so
many of your "self-evident truths" because
>
> *WHEN WE LOOK AS THE X86 MACHINE CODE OF DD THIS IS UNEQUIVOCAL*
> DD correctly emulated by HH with an x86 emulator cannot possibly
> reach past its own machine instruction [00001c2e] in any finite (or
> infinite) number of steps of correct emulation.
Wrong.
With my non-pure HH, we can easily construct an example which does
correctly simulate the x86 instructions given to it to the end
And, with a pure HH, we can positively PROVE that while HH may not be
able to do its own "correct simulation" to that point, if this HH is
programed to ever abort this simulation and return 0, we CAN prove that
an ACTUAL COMPLETE CORRECT SIMULATION of this input (by a different
program that actually does the complete simulation) will reach the final
state, and thus the behavior specified by the input is Halting.
Thus, NO HH can be "correct" to actually say its input is non-halting,
as the act of doing so make itself wrong.
>
> _DD()
> [00001c22] 55 push ebp
> [00001c23] 8bec mov ebp,esp
> [00001c25] 51 push ecx
> [00001c26] 8b4508 mov eax,[ebp+08]
> [00001c29] 50 push eax ; push DD 1c22
> [00001c2a] 8b4d08 mov ecx,[ebp+08]
> [00001c2d] 51 push ecx ; push DD 1c22
> [00001c2e] e80ff7ffff call 00001342 ; call HH
> [00001c33] 83c408 add esp,+08
> [00001c36] 8945fc mov [ebp-04],eax
> [00001c39] 837dfc00 cmp dword [ebp-04],+00
> [00001c3d] 7402 jz 00001c41
> [00001c3f] ebfe jmp 00001c3f
> [00001c41] 8b45fc mov eax,[ebp-04]
> [00001c44] 8be5 mov esp,ebp
> [00001c46] 5d pop ebp
> [00001c47] c3 ret
> Size in bytes:(0038) [00001c47]
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-02 12:59 -0500 |
| Subject | Re: Olcott is simply wrong --- Try to prove otherwise --- pinned down |
| Message-ID | <v3ibt9$3f571$1@dont-email.me> |
| In reply to | #106023 |
On 6/2/2024 12:22 PM, Richard Damon wrote:
> On 6/2/24 10:19 AM, olcott wrote:
>> On 6/2/2024 6:51 AM, Richard Damon wrote:
>>> On 6/1/24 11:33 PM, olcott wrote:
>>>> On 6/1/2024 6:27 PM, Richard Damon wrote:
>>>>> On 6/1/24 7:12 PM, olcott wrote:
>>>>>> On 6/1/2024 6:02 PM, Richard Damon wrote:
>>>>>>> On 6/1/24 6:40 PM, olcott wrote:
>>>>>>>>
>>>>>>>> Show me where I said anything in the above spec about an aborted
>>>>>>>> simulation.
>>>>>>>
>>>>>>> So, why did HH stop simulating after some n steps?
>>>>>>>
>>>>>>> Did it reach a final state in the simulation? if not, it ABORTED
>>>>>>> its simulation.
>>>>>>>
>>>>>>>>
>>>>>>>> When every possible which way DD correctly simulated by HH never
>>>>>>>> reaches
>>>>>>>> past its own simulated line 03 then
>>>>>>>
>>>>>>> And a simulation either goes until it reaches a final state of
>>>>>>> the machine it is simulating, or it aborted its simulation.
>>>>>>>
>>>>>>
>>>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>>>> 00 int HH(ptr p, ptr i);
>>>>>> 01 int DD(ptr p)
>>>>>> 02 {
>>>>>> 03 int Halt_Status = HH(p, p);
>>>>>> 04 if (Halt_Status)
>>>>>> 05 HERE: goto HERE;
>>>>>> 06 return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 int main()
>>>>>> 10 {
>>>>>> 11 HH(DD,DD);
>>>>>> 12 return 0;
>>>>>> 13 }
>>>>>>
>>>>>> When every DD correctly simulated by any HH cannot possibly reach
>>>>>> past its own simulated line 03 in 1 to ∞ steps of correct simulation
>>>>>> of DD by HH then we have exhaustively examined every possible HH/DD
>>>>>> pair and each element has of this infinite set has the same property.
>>>>>
>>>>> So?
>>>>>
>>>>> It doesn't matter how many aborted simulaiton you do of a given
>>>>> input (and each HH simulated a DIFFERENT input since it simulated
>>>>> the INSTANCE of the template with a different HH)
>>>>>
>>>>
>>>> In other words one cannot prove that every five pound rock weighs
>>>> more than every three pound rock, one must weigh them one-at-a-time?
>>>
>>> Nope. But you need to show that each rock IS a five pound rock.
>>>
>>> IF you weigh one rock, and find it is 5 pounds, doesn't mean that
>>> anothoer rock rock that looks about the same is also 5 pouds,
>>>
>>> You do seem to like you Herring in Red sauce, don't you.
>>>
>>> The comparison here is that you have only "weighed" a very few of
>>> your DDs, only those built on an HH that NEVER aborts have been
>>> determined to not halt. The others are just
>>> haven't-yet-halted-after-n-steps, but we actually DO know that they
>>> WILL Halt after more.
>>>
>>>>
>>>>> The ONLY simulation that actually showed that ITS input was
>>>>> no-halting was the HH that never aborted, and it didn't answer.
>>>>>
>>>>> Every other HH has a DIFFERENT INPUT and would be LYING to say it
>>>>> had that other input.
>>>>>
>>>>
>>>> In other words (because each rock is different) one cannot prove
>>>> that every five pound rock weighs more than every three pound rock,
>>>> one must weigh them one-at-a-time?
>>> Nope, unless of course you still need to weight them to show they ARE
>>> 5 pound rocks.
>>>
>>>>
>>>> Every HH/DD pair of the infinite of every possible HH/DD pair
>>>> DD correctly simulated by HH NEVER HALTS.
>>>
>>> That isn't even your original claim you were asking about.
>>>
>>> Your claim wasn't about "Halting" because that is easily disproven,
>>> but that there correct PARTIAL simulation done by H never reaches the
>>> statement after the call.
>>>
>>> You are just showing your true colors, that you just don't understand
>>> what you are talkinag about and get your lies confused.
>>>
>>>>
>>>>>>
>>>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>>>
>>>>> Nope. Aborted simulation don't prove anything.
>>>>>
>>>>
>>>> When for each element of the infinite set of every HH/DD pair DD
>>>> correctly simulated by HH cannot get past its own simulated line 03
>>>> then we know that none of the DD inputs to each HH(DD,DD) ever halts.
>>>
>>>
>>> Nope. Try to actually PROVE that.
>>>
>>
>> Semantic tautologies are self-evident truth that prove themselves.
>> It is a fact that every five pound rock weights more than any
>> three pound rock. No need to weigh any rocks.
>
> Right, so you don't need to weigh a five pound rock to know it is five
> bpounds.
>
>>
>> typedef int (*ptr)(); // ptr is pointer to int function in C
>> 00 int HH(ptr p, ptr i);
>> 01 int DD(ptr p)
>> 02 {
>> 03 int Halt_Status = HH(p, p);
>> 04 if (Halt_Status)
>> 05 HERE: goto HERE;
>> 06 return Halt_Status;
>> 07 }
>> 08
>> 09 int main()
>> 10 {
>> 11 HH(DD,DD);
>> 12 return 0;
>> 13 }
>>
>> Likewise we correctly deduce that for every HH/DD pair of the
>> infinite set of all HH/DD pairs that match the above template
>> every DD correctly simulated by HH never reaches past its own
>> simulated line 03, thus never halts.
>
When for every freaking HH/DD pair that matches the above template
DD correctly simulated by HH cannot possibly ever reaches past its
own simulated line 03 then
we know with complete logical certainty that not a damn one of
these DD instance halts. halts, NOT A DAMN ONE OF THEM EVER HALTS.
NOT A DAMN ONE OF THEM EVER HALTS.
NOT A DAMN ONE OF THEM EVER HALTS.
NOT A DAMN ONE OF THEM EVER HALTS.
NOT A DAMN ONE OF THEM EVER HALTS.
How many morons do you think will believe your damn nonsense?
How many morons do you think will believe your damn nonsense?
How many morons do you think will believe your damn nonsense?
We do not have to freaking weigh every damn rock to know that
every rock weighing more than five pounds weighs more than
three pounds likewise for all HH/DD pairs.
--
Copyright 2024 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 | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-02 14:13 -0400 |
| Subject | Re: Olcott is simply wrong --- Try to prove otherwise --- pinned down |
| Message-ID | <v3icnq$2qu71$1@i2pn2.org> |
| In reply to | #106033 |
On 6/2/24 1:59 PM, olcott wrote:
> On 6/2/2024 12:22 PM, Richard Damon wrote:
>> On 6/2/24 10:19 AM, olcott wrote:
>>> On 6/2/2024 6:51 AM, Richard Damon wrote:
>>>> On 6/1/24 11:33 PM, olcott wrote:
>>>>> On 6/1/2024 6:27 PM, Richard Damon wrote:
>>>>>> On 6/1/24 7:12 PM, olcott wrote:
>>>>>>> On 6/1/2024 6:02 PM, Richard Damon wrote:
>>>>>>>> On 6/1/24 6:40 PM, olcott wrote:
>>>>>>>>>
>>>>>>>>> Show me where I said anything in the above spec about an
>>>>>>>>> aborted simulation.
>>>>>>>>
>>>>>>>> So, why did HH stop simulating after some n steps?
>>>>>>>>
>>>>>>>> Did it reach a final state in the simulation? if not, it ABORTED
>>>>>>>> its simulation.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> When every possible which way DD correctly simulated by HH
>>>>>>>>> never reaches
>>>>>>>>> past its own simulated line 03 then
>>>>>>>>
>>>>>>>> And a simulation either goes until it reaches a final state of
>>>>>>>> the machine it is simulating, or it aborted its simulation.
>>>>>>>>
>>>>>>>
>>>>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>>>>> 00 int HH(ptr p, ptr i);
>>>>>>> 01 int DD(ptr p)
>>>>>>> 02 {
>>>>>>> 03 int Halt_Status = HH(p, p);
>>>>>>> 04 if (Halt_Status)
>>>>>>> 05 HERE: goto HERE;
>>>>>>> 06 return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 int main()
>>>>>>> 10 {
>>>>>>> 11 HH(DD,DD);
>>>>>>> 12 return 0;
>>>>>>> 13 }
>>>>>>>
>>>>>>> When every DD correctly simulated by any HH cannot possibly reach
>>>>>>> past its own simulated line 03 in 1 to ∞ steps of correct simulation
>>>>>>> of DD by HH then we have exhaustively examined every possible HH/DD
>>>>>>> pair and each element has of this infinite set has the same
>>>>>>> property.
>>>>>>
>>>>>> So?
>>>>>>
>>>>>> It doesn't matter how many aborted simulaiton you do of a given
>>>>>> input (and each HH simulated a DIFFERENT input since it simulated
>>>>>> the INSTANCE of the template with a different HH)
>>>>>>
>>>>>
>>>>> In other words one cannot prove that every five pound rock weighs
>>>>> more than every three pound rock, one must weigh them one-at-a-time?
>>>>
>>>> Nope. But you need to show that each rock IS a five pound rock.
>>>>
>>>> IF you weigh one rock, and find it is 5 pounds, doesn't mean that
>>>> anothoer rock rock that looks about the same is also 5 pouds,
>>>>
>>>> You do seem to like you Herring in Red sauce, don't you.
>>>>
>>>> The comparison here is that you have only "weighed" a very few of
>>>> your DDs, only those built on an HH that NEVER aborts have been
>>>> determined to not halt. The others are just
>>>> haven't-yet-halted-after-n-steps, but we actually DO know that they
>>>> WILL Halt after more.
>>>>
>>>>>
>>>>>> The ONLY simulation that actually showed that ITS input was
>>>>>> no-halting was the HH that never aborted, and it didn't answer.
>>>>>>
>>>>>> Every other HH has a DIFFERENT INPUT and would be LYING to say it
>>>>>> had that other input.
>>>>>>
>>>>>
>>>>> In other words (because each rock is different) one cannot prove
>>>>> that every five pound rock weighs more than every three pound rock,
>>>>> one must weigh them one-at-a-time?
>>>> Nope, unless of course you still need to weight them to show they
>>>> ARE 5 pound rocks.
>>>>
>>>>>
>>>>> Every HH/DD pair of the infinite of every possible HH/DD pair
>>>>> DD correctly simulated by HH NEVER HALTS.
>>>>
>>>> That isn't even your original claim you were asking about.
>>>>
>>>> Your claim wasn't about "Halting" because that is easily disproven,
>>>> but that there correct PARTIAL simulation done by H never reaches
>>>> the statement after the call.
>>>>
>>>> You are just showing your true colors, that you just don't
>>>> understand what you are talkinag about and get your lies confused.
>>>>
>>>>>
>>>>>>>
>>>>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>>>>
>>>>>> Nope. Aborted simulation don't prove anything.
>>>>>>
>>>>>
>>>>> When for each element of the infinite set of every HH/DD pair DD
>>>>> correctly simulated by HH cannot get past its own simulated line 03
>>>>> then we know that none of the DD inputs to each HH(DD,DD) ever halts.
>>>>
>>>>
>>>> Nope. Try to actually PROVE that.
>>>>
>>>
>>> Semantic tautologies are self-evident truth that prove themselves.
>>> It is a fact that every five pound rock weights more than any
>>> three pound rock. No need to weigh any rocks.
>>
>> Right, so you don't need to weigh a five pound rock to know it is five
>> bpounds.
>>
>>>
>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>> 00 int HH(ptr p, ptr i);
>>> 01 int DD(ptr p)
>>> 02 {
>>> 03 int Halt_Status = HH(p, p);
>>> 04 if (Halt_Status)
>>> 05 HERE: goto HERE;
>>> 06 return Halt_Status;
>>> 07 }
>>> 08
>>> 09 int main()
>>> 10 {
>>> 11 HH(DD,DD);
>>> 12 return 0;
>>> 13 }
>>>
>>> Likewise we correctly deduce that for every HH/DD pair of the
>>> infinite set of all HH/DD pairs that match the above template
>>> every DD correctly simulated by HH never reaches past its own
>>> simulated line 03, thus never halts.
>>
>
> When for every freaking HH/DD pair that matches the above template
> DD correctly simulated by HH cannot possibly ever reaches past its
> own simulated line 03 then
>
> we know with complete logical certainty that not a damn one of
> these DD instance halts. halts, NOT A DAMN ONE OF THEM EVER HALTS.
Nope, and you are just proving you are totally out of touch with reality.
EVERY DD built on an HH that returns 0 for HH(DD,DD) will Halt.
Remember, HALTING is a property of the ACTUAL MACHINE, and not
necessarily shown by partial simulations.
So, since it has been shown (and you even agreed at one point) that
DD(DD) will Halt (your agreement was for D(D) ), that IS the fact, and
you currect denial is just proof of your total ignorance of what you are
talking about.
>
> NOT A DAMN ONE OF THEM EVER HALTS.
> NOT A DAMN ONE OF THEM EVER HALTS.
> NOT A DAMN ONE OF THEM EVER HALTS.
> NOT A DAMN ONE OF THEM EVER HALTS.
Since they do, we know who is the DAMN LIAR, headed for the lake of FIRE.
>
> How many morons do you think will believe your damn nonsense?
> How many morons do you think will believe your damn nonsense?
> How many morons do you think will believe your damn nonsense?
Not you it seems, and that seems to be one of the few morons here.
Smart people understand the truth.
You seem to be confusing the "fantasy" world of your partial simulaition
for the REALITY of direct execution, which is revealed by ACTUAL
COMPLETE AND CORRECT SIMULATION.
>
> We do not have to freaking weigh every damn rock to know that
> every rock weighing more than five pounds weighs more than
> three pounds likewise for all HH/DD pairs.
>
Right, you only need to weight them to show that the rock IS more than 5
pounds.
And we don't need to fully simulate by your method any DD that is based
on an HH(DD,DD) that returns 0, as by simple inspection we can see that
it will halt.
Please explain how any DD(DD) can NOT halt if we know that HH(DD,DD)
will always return 0.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-02 13:29 -0500 |
| Subject | DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3idlk$3f571$2@dont-email.me> |
| In reply to | #106037 |
On 6/2/2024 1:13 PM, Richard Damon wrote:
> On 6/2/24 1:59 PM, olcott wrote:
>> On 6/2/2024 12:22 PM, Richard Damon wrote:
>>> On 6/2/24 10:19 AM, olcott wrote:
>>>>
>>>> Semantic tautologies are self-evident truth that prove themselves.
>>>> It is a fact that every five pound rock weights more than any
>>>> three pound rock. No need to weigh any rocks.
>>>
>>> Right, so you don't need to weigh a five pound rock to know it is
>>> five bpounds.
>>>
>>>>
>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>> 00 int HH(ptr p, ptr i);
>>>> 01 int DD(ptr p)
>>>> 02 {
>>>> 03 int Halt_Status = HH(p, p);
>>>> 04 if (Halt_Status)
>>>> 05 HERE: goto HERE;
>>>> 06 return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 int main()
>>>> 10 {
>>>> 11 HH(DD,DD);
>>>> 12 return 0;
>>>> 13 }
>>>>
>>>> Likewise we correctly deduce that for every HH/DD pair of the
>>>> infinite set of all HH/DD pairs that match the above template
>>>> every DD correctly simulated by HH never reaches past its own
>>>> simulated line 03, thus never halts.
>>>
>>
>> When for every freaking HH/DD pair that matches the above template
>> DD correctly simulated by HH cannot possibly ever reaches past its
>> own simulated line 03 then
>>
>> we know with complete logical certainty that not a damn one of
>> these DD instance halts. halts, NOT A DAMN ONE OF THEM EVER HALTS.
>
> Nope, and you are just proving you are totally out of touch with reality.
>
> EVERY DD built on an HH that returns 0 for HH(DD,DD) will Halt.
>
I am going to give up on you because you continue to try
to get away with the straw-mam deception CHANGE-THE-SUBJECT
fake rebuttal.
This is the only post that I will reply to and unless you
either accept that DD correctly simulated by HH will never
halt for the infinite set of HH/DD pairs specified below
or correctly refute the paragraph relating to the x86 code
of DD shown below *I will simply not respond to your posts*
(a) Accept the DD/HH that DD never halts
(b) Correctly refute the x86 DD
*EVERYTHING ELSE WILL GET NO RESPONSE FROM ME*
typedef int (*ptr)(); // ptr is pointer to int function in C
00 int HH(ptr p, ptr i);
01 int DD(ptr p)
02 {
03 int Halt_Status = HH(p, p);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 int main()
10 {
11 HH(DD,DD);
12 return 0;
13 }
DD correctly emulated by HH with an x86 emulator cannot possibly
reach past its own machine instruction [00001c2e] in any finite
(or infinite) number of steps of correct emulation.
_DD()
[00001c22] 55 push ebp
[00001c23] 8bec mov ebp,esp
[00001c25] 51 push ecx
[00001c26] 8b4508 mov eax,[ebp+08]
[00001c29] 50 push eax ; push DD 1c22
[00001c2a] 8b4d08 mov ecx,[ebp+08]
[00001c2d] 51 push ecx ; push DD 1c22
[00001c2e] e80ff7ffff call 00001342 ; call HH
[00001c33] 83c408 add esp,+08
[00001c36] 8945fc mov [ebp-04],eax
[00001c39] 837dfc00 cmp dword [ebp-04],+00
[00001c3d] 7402 jz 00001c41
[00001c3f] ebfe jmp 00001c3f
[00001c41] 8b45fc mov eax,[ebp-04]
[00001c44] 8be5 mov esp,ebp
[00001c46] 5d pop ebp
[00001c47] c3 ret
Size in bytes:(0038) [00001c47]
--
Copyright 2024 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 | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-02 15:05 -0400 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3ifpp$2qu72$11@i2pn2.org> |
| In reply to | #106044 |
On 6/2/24 2:29 PM, olcott wrote:
> On 6/2/2024 1:13 PM, Richard Damon wrote:
>> On 6/2/24 1:59 PM, olcott wrote:
>>> On 6/2/2024 12:22 PM, Richard Damon wrote:
>>>> On 6/2/24 10:19 AM, olcott wrote:
>>>>>
>>>>> Semantic tautologies are self-evident truth that prove themselves.
>>>>> It is a fact that every five pound rock weights more than any
>>>>> three pound rock. No need to weigh any rocks.
>>>>
>>>> Right, so you don't need to weigh a five pound rock to know it is
>>>> five bpounds.
>>>>
>>>>>
>>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>>> 00 int HH(ptr p, ptr i);
>>>>> 01 int DD(ptr p)
>>>>> 02 {
>>>>> 03 int Halt_Status = HH(p, p);
>>>>> 04 if (Halt_Status)
>>>>> 05 HERE: goto HERE;
>>>>> 06 return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 int main()
>>>>> 10 {
>>>>> 11 HH(DD,DD);
>>>>> 12 return 0;
>>>>> 13 }
>>>>>
>>>>> Likewise we correctly deduce that for every HH/DD pair of the
>>>>> infinite set of all HH/DD pairs that match the above template
>>>>> every DD correctly simulated by HH never reaches past its own
>>>>> simulated line 03, thus never halts.
>>>>
>>>
>>> When for every freaking HH/DD pair that matches the above template
>>> DD correctly simulated by HH cannot possibly ever reaches past its
>>> own simulated line 03 then
>>>
>>> we know with complete logical certainty that not a damn one of
>>> these DD instance halts. halts, NOT A DAMN ONE OF THEM EVER HALTS.
>>
>> Nope, and you are just proving you are totally out of touch with reality.
>>
>> EVERY DD built on an HH that returns 0 for HH(DD,DD) will Halt.
>>
>
> I am going to give up on you because you continue to try
> to get away with the straw-mam deception CHANGE-THE-SUBJECT
> fake rebuttal.
Nope. I am not "Changing the subject" but showing that your subject is
incorrect or irrelevent.
>
> This is the only post that I will reply to and unless you
> either accept that DD correctly simulated by HH will never
> halt for the infinite set of HH/DD pairs specified below
> or correctly refute the paragraph relating to the x86 code
> of DD shown below *I will simply not respond to your posts*
Which I won't do until you say why it matters.
>
> (a) Accept the DD/HH that DD never halts
> (b) Correctly refute the x86 DD
> *EVERYTHING ELSE WILL GET NO RESPONSE FROM ME*
And thus a whole list of posts refuting everything that you say that you
will just be forced to leave out there or convict yourself of LYING.
>
> typedef int (*ptr)(); // ptr is pointer to int function in C
> 00 int HH(ptr p, ptr i);
> 01 int DD(ptr p)
> 02 {
> 03 int Halt_Status = HH(p, p);
> 04 if (Halt_Status)
> 05 HERE: goto HERE;
> 06 return Halt_Status;
> 07 }
> 08
> 09 int main()
> 10 {
> 11 HH(DD,DD);
> 12 return 0;
> 13 }
>
>
> DD correctly emulated by HH with an x86 emulator cannot possibly
> reach past its own machine instruction [00001c2e] in any finite
> (or infinite) number of steps of correct emulation.
But any such finite simulation doesn't prove that the machie being
simulated is non-halting.
All you are proving is that the DDs that are provable to be non-halting
are built to refute HHs that never answer about them.
>
> _DD()
> [00001c22] 55 push ebp
> [00001c23] 8bec mov ebp,esp
> [00001c25] 51 push ecx
> [00001c26] 8b4508 mov eax,[ebp+08]
> [00001c29] 50 push eax ; push DD 1c22
> [00001c2a] 8b4d08 mov ecx,[ebp+08]
> [00001c2d] 51 push ecx ; push DD 1c22
> [00001c2e] e80ff7ffff call 00001342 ; call HH
> [00001c33] 83c408 add esp,+08
> [00001c36] 8945fc mov [ebp-04],eax
> [00001c39] 837dfc00 cmp dword [ebp-04],+00
> [00001c3d] 7402 jz 00001c41
> [00001c3f] ebfe jmp 00001c3f
> [00001c41] 8b45fc mov eax,[ebp-04]
> [00001c44] 8be5 mov esp,ebp
> [00001c46] 5d pop ebp
> [00001c47] c3 ret
> Size in bytes:(0038) [00001c47]
>
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-02 14:13 -0500 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3ig8p$3f571$14@dont-email.me> |
| In reply to | #106069 |
On 6/2/2024 2:05 PM, Richard Damon wrote:
> On 6/2/24 2:29 PM, olcott wrote:
>> On 6/2/2024 1:13 PM, Richard Damon wrote:
>>> On 6/2/24 1:59 PM, olcott wrote:
>>>> On 6/2/2024 12:22 PM, Richard Damon wrote:
>>>>> On 6/2/24 10:19 AM, olcott wrote:
>>>>>>
>>>>>> Semantic tautologies are self-evident truth that prove themselves.
>>>>>> It is a fact that every five pound rock weights more than any
>>>>>> three pound rock. No need to weigh any rocks.
>>>>>
>>>>> Right, so you don't need to weigh a five pound rock to know it is
>>>>> five bpounds.
>>>>>
>>>>>>
>>>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>>>> 00 int HH(ptr p, ptr i);
>>>>>> 01 int DD(ptr p)
>>>>>> 02 {
>>>>>> 03 int Halt_Status = HH(p, p);
>>>>>> 04 if (Halt_Status)
>>>>>> 05 HERE: goto HERE;
>>>>>> 06 return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 int main()
>>>>>> 10 {
>>>>>> 11 HH(DD,DD);
>>>>>> 12 return 0;
>>>>>> 13 }
>>>>>>
>>>>>> Likewise we correctly deduce that for every HH/DD pair of the
>>>>>> infinite set of all HH/DD pairs that match the above template
>>>>>> every DD correctly simulated by HH never reaches past its own
>>>>>> simulated line 03, thus never halts.
>>>>>
>>>>
>>>> When for every freaking HH/DD pair that matches the above template
>>>> DD correctly simulated by HH cannot possibly ever reaches past its
>>>> own simulated line 03 then
>>>>
>>>> we know with complete logical certainty that not a damn one of
>>>> these DD instance halts. halts, NOT A DAMN ONE OF THEM EVER HALTS.
>>>
>>> Nope, and you are just proving you are totally out of touch with
>>> reality.
>>>
>>> EVERY DD built on an HH that returns 0 for HH(DD,DD) will Halt.
>>>
>>
>> I am going to give up on you because you continue to try
>> to get away with the straw-mam deception CHANGE-THE-SUBJECT
>> fake rebuttal.
>
> Nope. I am not "Changing the subject" but showing that your subject is
> incorrect or irrelevent.
>
>>
>> This is the only post that I will reply to and unless you
>> either accept that DD correctly simulated by HH will never
>> halt for the infinite set of HH/DD pairs specified below
>> or correctly refute the paragraph relating to the x86 code
>> of DD shown below *I will simply not respond to your posts*
>
> Which I won't do until you say why it matters.
>
>>
>> (a) Accept the DD/HH that DD never halts
>> (b) Correctly refute the x86 DD
>> *EVERYTHING ELSE WILL GET NO RESPONSE FROM ME*
>
> And thus a whole list of posts refuting everything that you say that you
> will just be forced to leave out there or convict yourself of LYING.
>
>>
>> typedef int (*ptr)(); // ptr is pointer to int function in C
>> 00 int HH(ptr p, ptr i);
>> 01 int DD(ptr p)
>> 02 {
>> 03 int Halt_Status = HH(p, p);
>> 04 if (Halt_Status)
>> 05 HERE: goto HERE;
>> 06 return Halt_Status;
>> 07 }
>> 08
>> 09 int main()
>> 10 {
>> 11 HH(DD,DD);
>> 12 return 0;
>> 13 }
>>
>>
>> DD correctly emulated by HH with an x86 emulator cannot possibly
>> reach past its own machine instruction [00001c2e] in any finite
>> (or infinite) number of steps of correct emulation.
>
> But any such finite simulation
DD correctly emulated by HH with an x86 emulator cannot possibly
reach past its own machine instruction [00001c2e] in any finite
(or infinite) number of steps of correct emulation.
(or infinite) number of steps of correct emulation.
(or infinite) number of steps of correct emulation.
(or infinite) number of steps of correct emulation.
(or infinite) number of steps of correct emulation.
> doesn't prove that the machie being
> simulated is non-halting.
>
> All you are proving is that the DDs that are provable to be non-halting
> are built to refute HHs that never answer about them.
>
>>
>> _DD()
>> [00001c22] 55 push ebp
>> [00001c23] 8bec mov ebp,esp
>> [00001c25] 51 push ecx
>> [00001c26] 8b4508 mov eax,[ebp+08]
>> [00001c29] 50 push eax ; push DD 1c22
>> [00001c2a] 8b4d08 mov ecx,[ebp+08]
>> [00001c2d] 51 push ecx ; push DD 1c22
>> [00001c2e] e80ff7ffff call 00001342 ; call HH
>> [00001c33] 83c408 add esp,+08
>> [00001c36] 8945fc mov [ebp-04],eax
>> [00001c39] 837dfc00 cmp dword [ebp-04],+00
>> [00001c3d] 7402 jz 00001c41
>> [00001c3f] ebfe jmp 00001c3f
>> [00001c41] 8b45fc mov eax,[ebp-04]
>> [00001c44] 8be5 mov esp,ebp
>> [00001c46] 5d pop ebp
>> [00001c47] c3 ret
>> Size in bytes:(0038) [00001c47]
>>
>>
>>
>
--
Copyright 2024 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 | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2024-06-02 15:22 -0400 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <WD37O.6414$Cs55.45@fx33.iad> |
| In reply to | #106073 |
On 6/2/24 3:13 PM, olcott wrote:
> On 6/2/2024 2:05 PM, Richard Damon wrote:
>> On 6/2/24 2:29 PM, olcott wrote:
>>> On 6/2/2024 1:13 PM, Richard Damon wrote:
>>>> On 6/2/24 1:59 PM, olcott wrote:
>>>>> On 6/2/2024 12:22 PM, Richard Damon wrote:
>>>>>> On 6/2/24 10:19 AM, olcott wrote:
>>>>>>>
>>>>>>> Semantic tautologies are self-evident truth that prove themselves.
>>>>>>> It is a fact that every five pound rock weights more than any
>>>>>>> three pound rock. No need to weigh any rocks.
>>>>>>
>>>>>> Right, so you don't need to weigh a five pound rock to know it is
>>>>>> five bpounds.
>>>>>>
>>>>>>>
>>>>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>>>>> 00 int HH(ptr p, ptr i);
>>>>>>> 01 int DD(ptr p)
>>>>>>> 02 {
>>>>>>> 03 int Halt_Status = HH(p, p);
>>>>>>> 04 if (Halt_Status)
>>>>>>> 05 HERE: goto HERE;
>>>>>>> 06 return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 int main()
>>>>>>> 10 {
>>>>>>> 11 HH(DD,DD);
>>>>>>> 12 return 0;
>>>>>>> 13 }
>>>>>>>
>>>>>>> Likewise we correctly deduce that for every HH/DD pair of the
>>>>>>> infinite set of all HH/DD pairs that match the above template
>>>>>>> every DD correctly simulated by HH never reaches past its own
>>>>>>> simulated line 03, thus never halts.
>>>>>>
>>>>>
>>>>> When for every freaking HH/DD pair that matches the above template
>>>>> DD correctly simulated by HH cannot possibly ever reaches past its
>>>>> own simulated line 03 then
>>>>>
>>>>> we know with complete logical certainty that not a damn one of
>>>>> these DD instance halts. halts, NOT A DAMN ONE OF THEM EVER HALTS.
>>>>
>>>> Nope, and you are just proving you are totally out of touch with
>>>> reality.
>>>>
>>>> EVERY DD built on an HH that returns 0 for HH(DD,DD) will Halt.
>>>>
>>>
>>> I am going to give up on you because you continue to try
>>> to get away with the straw-mam deception CHANGE-THE-SUBJECT
>>> fake rebuttal.
>>
>> Nope. I am not "Changing the subject" but showing that your subject is
>> incorrect or irrelevent.
>>
>>>
>>> This is the only post that I will reply to and unless you
>>> either accept that DD correctly simulated by HH will never
>>> halt for the infinite set of HH/DD pairs specified below
>>> or correctly refute the paragraph relating to the x86 code
>>> of DD shown below *I will simply not respond to your posts*
>>
>> Which I won't do until you say why it matters.
>>
>>>
>>> (a) Accept the DD/HH that DD never halts
>>> (b) Correctly refute the x86 DD
>>> *EVERYTHING ELSE WILL GET NO RESPONSE FROM ME*
>>
>> And thus a whole list of posts refuting everything that you say that
>> you will just be forced to leave out there or convict yourself of LYING.
>>
>>>
>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>> 00 int HH(ptr p, ptr i);
>>> 01 int DD(ptr p)
>>> 02 {
>>> 03 int Halt_Status = HH(p, p);
>>> 04 if (Halt_Status)
>>> 05 HERE: goto HERE;
>>> 06 return Halt_Status;
>>> 07 }
>>> 08
>>> 09 int main()
>>> 10 {
>>> 11 HH(DD,DD);
>>> 12 return 0;
>>> 13 }
>>>
>>>
>>> DD correctly emulated by HH with an x86 emulator cannot possibly
>>> reach past its own machine instruction [00001c2e] in any finite
>>> (or infinite) number of steps of correct emulation.
>>
>> But any such finite simulation
>
> DD correctly emulated by HH with an x86 emulator cannot possibly
> reach past its own machine instruction [00001c2e] in any finite
> (or infinite) number of steps of correct emulation.
>
> (or infinite) number of steps of correct emulation.
> (or infinite) number of steps of correct emulation.
> (or infinite) number of steps of correct emulation.
> (or infinite) number of steps of correct emulation.
But you only show the "or infinite number of steps" for DDs built on an
HH that never aborts.
EVERY version of DD is a different input.
And every version of DD built on an HH that does abort and returns 0
will Halt.
it seems you have forgotten the details of what a program is, and I
guess you logic insists that a cat is the same as a 10 story office
building since different things can be the same thing.
>
>> doesn't prove that the machie being simulated is non-halting.
>>
>> All you are proving is that the DDs that are provable to be
>> non-halting are built to refute HHs that never answer about them.
>>
>>>
>>> _DD()
>>> [00001c22] 55 push ebp
>>> [00001c23] 8bec mov ebp,esp
>>> [00001c25] 51 push ecx
>>> [00001c26] 8b4508 mov eax,[ebp+08]
>>> [00001c29] 50 push eax ; push DD 1c22
>>> [00001c2a] 8b4d08 mov ecx,[ebp+08]
>>> [00001c2d] 51 push ecx ; push DD 1c22
>>> [00001c2e] e80ff7ffff call 00001342 ; call HH
>>> [00001c33] 83c408 add esp,+08
>>> [00001c36] 8945fc mov [ebp-04],eax
>>> [00001c39] 837dfc00 cmp dword [ebp-04],+00
>>> [00001c3d] 7402 jz 00001c41
>>> [00001c3f] ebfe jmp 00001c3f
>>> [00001c41] 8b45fc mov eax,[ebp-04]
>>> [00001c44] 8be5 mov esp,ebp
>>> [00001c46] 5d pop ebp
>>> [00001c47] c3 ret
>>> Size in bytes:(0038) [00001c47]
>>>
>>>
>>>
>>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-02 14:34 -0500 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3ihgp$3g2kl$1@dont-email.me> |
| In reply to | #106078 |
On 6/2/2024 2:22 PM, Richard Damon wrote:
> On 6/2/24 3:13 PM, olcott wrote:
>> On 6/2/2024 2:05 PM, Richard Damon wrote:
>>> On 6/2/24 2:29 PM, olcott wrote:
>>>> On 6/2/2024 1:13 PM, Richard Damon wrote:
>>>>> On 6/2/24 1:59 PM, olcott wrote:
>>>>>> On 6/2/2024 12:22 PM, Richard Damon wrote:
>>>>>>> On 6/2/24 10:19 AM, olcott wrote:
>>>>>>>>
>>>>>>>> Semantic tautologies are self-evident truth that prove themselves.
>>>>>>>> It is a fact that every five pound rock weights more than any
>>>>>>>> three pound rock. No need to weigh any rocks.
>>>>>>>
>>>>>>> Right, so you don't need to weigh a five pound rock to know it is
>>>>>>> five bpounds.
>>>>>>>
>>>>>>>>
>>>>>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>>>>>> 00 int HH(ptr p, ptr i);
>>>>>>>> 01 int DD(ptr p)
>>>>>>>> 02 {
>>>>>>>> 03 int Halt_Status = HH(p, p);
>>>>>>>> 04 if (Halt_Status)
>>>>>>>> 05 HERE: goto HERE;
>>>>>>>> 06 return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 int main()
>>>>>>>> 10 {
>>>>>>>> 11 HH(DD,DD);
>>>>>>>> 12 return 0;
>>>>>>>> 13 }
>>>>>>>>
>>>>>>>> Likewise we correctly deduce that for every HH/DD pair of the
>>>>>>>> infinite set of all HH/DD pairs that match the above template
>>>>>>>> every DD correctly simulated by HH never reaches past its own
>>>>>>>> simulated line 03, thus never halts.
>>>>>>>
>>>>>>
>>>>>> When for every freaking HH/DD pair that matches the above template
>>>>>> DD correctly simulated by HH cannot possibly ever reaches past its
>>>>>> own simulated line 03 then
>>>>>>
>>>>>> we know with complete logical certainty that not a damn one of
>>>>>> these DD instance halts. halts, NOT A DAMN ONE OF THEM EVER HALTS.
>>>>>
>>>>> Nope, and you are just proving you are totally out of touch with
>>>>> reality.
>>>>>
>>>>> EVERY DD built on an HH that returns 0 for HH(DD,DD) will Halt.
>>>>>
>>>>
>>>> I am going to give up on you because you continue to try
>>>> to get away with the straw-mam deception CHANGE-THE-SUBJECT
>>>> fake rebuttal.
>>>
>>> Nope. I am not "Changing the subject" but showing that your subject
>>> is incorrect or irrelevent.
>>>
>>>>
>>>> This is the only post that I will reply to and unless you
>>>> either accept that DD correctly simulated by HH will never
>>>> halt for the infinite set of HH/DD pairs specified below
>>>> or correctly refute the paragraph relating to the x86 code
>>>> of DD shown below *I will simply not respond to your posts*
>>>
>>> Which I won't do until you say why it matters.
>>>
>>>>
>>>> (a) Accept the DD/HH that DD never halts
>>>> (b) Correctly refute the x86 DD
>>>> *EVERYTHING ELSE WILL GET NO RESPONSE FROM ME*
>>>
>>> And thus a whole list of posts refuting everything that you say that
>>> you will just be forced to leave out there or convict yourself of LYING.
>>>
>>>>
>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>> 00 int HH(ptr p, ptr i);
>>>> 01 int DD(ptr p)
>>>> 02 {
>>>> 03 int Halt_Status = HH(p, p);
>>>> 04 if (Halt_Status)
>>>> 05 HERE: goto HERE;
>>>> 06 return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 int main()
>>>> 10 {
>>>> 11 HH(DD,DD);
>>>> 12 return 0;
>>>> 13 }
>>>>
>>>>
>>>> DD correctly emulated by HH with an x86 emulator cannot possibly
>>>> reach past its own machine instruction [00001c2e] in any finite
>>>> (or infinite) number of steps of correct emulation.
>>>
>>> But any such finite simulation
>>
>> DD correctly emulated by HH with an x86 emulator cannot possibly
>> reach past its own machine instruction [00001c2e] in any finite
>> (or infinite) number of steps of correct emulation.
>>
>> (or infinite) number of steps of correct emulation.
>> (or infinite) number of steps of correct emulation.
>> (or infinite) number of steps of correct emulation.
>> (or infinite) number of steps of correct emulation.
>
> But you only show the "or infinite number of steps" for DDs built on an
> HH that never aborts.
>
Maybe you are having a bad day. You are already forgetting how
you just chastised me last night for not equating finite number
of steps with an aborted simulation.
DD correctly emulated by HH with an x86 emulator cannot possibly
reach past its own machine instruction [00001c2e]
in any finite
in any finite
in any finite
in any finite
in any finite
(or infinite) number of steps of correct emulation.
(or infinite) number of steps of correct emulation.
(or infinite) number of steps of correct emulation.
(or infinite) number of steps of correct emulation.
> EVERY version of DD is a different input.
>
Just the same way that every rock that weighs more than five pounds is
a different rock, YET THEY ALL WEIGH MORE THAN FIVE POUNDS.
> And every version of DD built on an HH that does abort and returns 0
> will Halt.
>
I am not using that screwy language it seems dishonest of you
to paraphrase my words that way.
Every DD correctly simulated by DD DOES NOT HALT. I really want
to move on to the much bigger issue of why the behavior of the
directly executed DD(DD) DOES NOT MATTER.
We certainly can't move on to bigger issues when you prove
that you cannot handle the trivial ones.
> it seems you have forgotten the details of what a program is, and I
> guess you logic insists that a cat is the same as a 10 story office
> building since different things can be the same thing.
>
>>
>>> doesn't prove that the machie being simulated is non-halting.
>>>
>>> All you are proving is that the DDs that are provable to be
>>> non-halting are built to refute HHs that never answer about them.
>>>
>>>>
>>>> _DD()
>>>> [00001c22] 55 push ebp
>>>> [00001c23] 8bec mov ebp,esp
>>>> [00001c25] 51 push ecx
>>>> [00001c26] 8b4508 mov eax,[ebp+08]
>>>> [00001c29] 50 push eax ; push DD 1c22
>>>> [00001c2a] 8b4d08 mov ecx,[ebp+08]
>>>> [00001c2d] 51 push ecx ; push DD 1c22
>>>> [00001c2e] e80ff7ffff call 00001342 ; call HH
>>>> [00001c33] 83c408 add esp,+08
>>>> [00001c36] 8945fc mov [ebp-04],eax
>>>> [00001c39] 837dfc00 cmp dword [ebp-04],+00
>>>> [00001c3d] 7402 jz 00001c41
>>>> [00001c3f] ebfe jmp 00001c3f
>>>> [00001c41] 8b45fc mov eax,[ebp-04]
>>>> [00001c44] 8be5 mov esp,ebp
>>>> [00001c46] 5d pop ebp
>>>> [00001c47] c3 ret
>>>> Size in bytes:(0038) [00001c47]
>>>>
>>>>
>>>>
>>>
>>
>
--
Copyright 2024 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 | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-02 16:11 -0400 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3ijkv$2qu72$14@i2pn2.org> |
| In reply to | #106081 |
On 6/2/24 3:34 PM, olcott wrote:
> On 6/2/2024 2:22 PM, Richard Damon wrote:
>> On 6/2/24 3:13 PM, olcott wrote:
>>> On 6/2/2024 2:05 PM, Richard Damon wrote:
>>>> On 6/2/24 2:29 PM, olcott wrote:
>>>>> On 6/2/2024 1:13 PM, Richard Damon wrote:
>>>>>> On 6/2/24 1:59 PM, olcott wrote:
>>>>>>> On 6/2/2024 12:22 PM, Richard Damon wrote:
>>>>>>>> On 6/2/24 10:19 AM, olcott wrote:
>>>>>>>>>
>>>>>>>>> Semantic tautologies are self-evident truth that prove themselves.
>>>>>>>>> It is a fact that every five pound rock weights more than any
>>>>>>>>> three pound rock. No need to weigh any rocks.
>>>>>>>>
>>>>>>>> Right, so you don't need to weigh a five pound rock to know it
>>>>>>>> is five bpounds.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>>>>>>> 00 int HH(ptr p, ptr i);
>>>>>>>>> 01 int DD(ptr p)
>>>>>>>>> 02 {
>>>>>>>>> 03 int Halt_Status = HH(p, p);
>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>> 06 return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 int main()
>>>>>>>>> 10 {
>>>>>>>>> 11 HH(DD,DD);
>>>>>>>>> 12 return 0;
>>>>>>>>> 13 }
>>>>>>>>>
>>>>>>>>> Likewise we correctly deduce that for every HH/DD pair of the
>>>>>>>>> infinite set of all HH/DD pairs that match the above template
>>>>>>>>> every DD correctly simulated by HH never reaches past its own
>>>>>>>>> simulated line 03, thus never halts.
>>>>>>>>
>>>>>>>
>>>>>>> When for every freaking HH/DD pair that matches the above template
>>>>>>> DD correctly simulated by HH cannot possibly ever reaches past its
>>>>>>> own simulated line 03 then
>>>>>>>
>>>>>>> we know with complete logical certainty that not a damn one of
>>>>>>> these DD instance halts. halts, NOT A DAMN ONE OF THEM EVER HALTS.
>>>>>>
>>>>>> Nope, and you are just proving you are totally out of touch with
>>>>>> reality.
>>>>>>
>>>>>> EVERY DD built on an HH that returns 0 for HH(DD,DD) will Halt.
>>>>>>
>>>>>
>>>>> I am going to give up on you because you continue to try
>>>>> to get away with the straw-mam deception CHANGE-THE-SUBJECT
>>>>> fake rebuttal.
>>>>
>>>> Nope. I am not "Changing the subject" but showing that your subject
>>>> is incorrect or irrelevent.
>>>>
>>>>>
>>>>> This is the only post that I will reply to and unless you
>>>>> either accept that DD correctly simulated by HH will never
>>>>> halt for the infinite set of HH/DD pairs specified below
>>>>> or correctly refute the paragraph relating to the x86 code
>>>>> of DD shown below *I will simply not respond to your posts*
>>>>
>>>> Which I won't do until you say why it matters.
>>>>
>>>>>
>>>>> (a) Accept the DD/HH that DD never halts
>>>>> (b) Correctly refute the x86 DD
>>>>> *EVERYTHING ELSE WILL GET NO RESPONSE FROM ME*
>>>>
>>>> And thus a whole list of posts refuting everything that you say that
>>>> you will just be forced to leave out there or convict yourself of
>>>> LYING.
>>>>
>>>>>
>>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>>> 00 int HH(ptr p, ptr i);
>>>>> 01 int DD(ptr p)
>>>>> 02 {
>>>>> 03 int Halt_Status = HH(p, p);
>>>>> 04 if (Halt_Status)
>>>>> 05 HERE: goto HERE;
>>>>> 06 return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 int main()
>>>>> 10 {
>>>>> 11 HH(DD,DD);
>>>>> 12 return 0;
>>>>> 13 }
>>>>>
>>>>>
>>>>> DD correctly emulated by HH with an x86 emulator cannot possibly
>>>>> reach past its own machine instruction [00001c2e] in any finite
>>>>> (or infinite) number of steps of correct emulation.
>>>>
>>>> But any such finite simulation
>>>
>>> DD correctly emulated by HH with an x86 emulator cannot possibly
>>> reach past its own machine instruction [00001c2e] in any finite
>>> (or infinite) number of steps of correct emulation.
>>>
>>> (or infinite) number of steps of correct emulation.
>>> (or infinite) number of steps of correct emulation.
>>> (or infinite) number of steps of correct emulation.
>>> (or infinite) number of steps of correct emulation.
>>
>> But you only show the "or infinite number of steps" for DDs built on
>> an HH that never aborts.
>>
>
> Maybe you are having a bad day. You are already forgetting how
> you just chastised me last night for not equating finite number
> of steps with an aborted simulation.
So, what is your confusion.
The only DDs that you have simulated for an infinte number of steps are
those DDs built on an HH that NEVER ABORTS its simulation.
>
> DD correctly emulated by HH with an x86 emulator cannot possibly
> reach past its own machine instruction [00001c2e]
>
> in any finite
> in any finite
> in any finite
> in any finite
> in any finite
> (or infinite) number of steps of correct emulation.
> (or infinite) number of steps of correct emulation.
> (or infinite) number of steps of correct emulation.
> (or infinite) number of steps of correct emulation.
AND WHO CARES ABOUT NOT BEING ABLED TO BE SIMULATED PAST THE CALL
INSTRUCTION
**YOU** are the one changing the subject, as before you were talking
about DD not halting, NOT it not to be able to be simulated by HH past
the call instruction.
>
>> EVERY version of DD is a different input.
>>
>
> Just the same way that every rock that weighs more than five pounds is
> a different rock, YET THEY ALL WEIGH MORE THAN FIVE POUNDS.
Yep. Because that IS a property of them.
But the simulation of one DD doesn't tell you anything about the
simulation of another.
That is like saying that since one 5 pound rock was pink, all of them are.
Halting is NOT the same property as not being able to be simulated by HH
past a certain point. So you seem to have rocks in your head.
>
>> And every version of DD built on an HH that does abort and returns 0
>> will Halt.
>>
>
> I am not using that screwy language it seems dishonest of you
> to paraphrase my words that way.
So, do you disagree that every HH that simulates its DD for only a
finite number of steps doesn't abort?
>
> Every DD correctly simulated by DD DOES NOT HALT. I really want
> to move on to the much bigger issue of why the behavior of the
> directly executed DD(DD) DOES NOT MATTER.
WRONG. (I presume you mean HH)
If the HH simulates for only a finite number of steps, and then aborts
its simulation, then the DD built from that HH, the DD(DD) will halt.
The only other case is the HH that does simulate an infinite number of
steps, and those HH never answer.
Note, this is again you switching the topoc back to not-halting instead
of your diversion to not-simulated-by-HH-past-the-call-instruction.
These are DIFFERENT properties, and you try to LIE by assuming they are
the same.
>
> We certainly can't move on to bigger issues when you prove
> that you cannot handle the trivial ones.
So, which of the two cases are you talking about.
The ones where HH answers, and you LIE that the DD built on them does
not halt, as it does.
or, are the only HHs in existance ones that NEVER abort there
simulation, and thus never answer?
ONE HH can not be a bit of both.
>
>> it seems you have forgotten the details of what a program is, and I
>> guess you logic insists that a cat is the same as a 10 story office
>> building since different things can be the same thing.
>>
>>>
>>>> doesn't prove that the machie being simulated is non-halting.
>>>>
>>>> All you are proving is that the DDs that are provable to be
>>>> non-halting are built to refute HHs that never answer about them.
>>>>
>>>>>
>>>>> _DD()
>>>>> [00001c22] 55 push ebp
>>>>> [00001c23] 8bec mov ebp,esp
>>>>> [00001c25] 51 push ecx
>>>>> [00001c26] 8b4508 mov eax,[ebp+08]
>>>>> [00001c29] 50 push eax ; push DD 1c22
>>>>> [00001c2a] 8b4d08 mov ecx,[ebp+08]
>>>>> [00001c2d] 51 push ecx ; push DD 1c22
>>>>> [00001c2e] e80ff7ffff call 00001342 ; call HH
>>>>> [00001c33] 83c408 add esp,+08
>>>>> [00001c36] 8945fc mov [ebp-04],eax
>>>>> [00001c39] 837dfc00 cmp dword [ebp-04],+00
>>>>> [00001c3d] 7402 jz 00001c41
>>>>> [00001c3f] ebfe jmp 00001c3f
>>>>> [00001c41] 8b45fc mov eax,[ebp-04]
>>>>> [00001c44] 8be5 mov esp,ebp
>>>>> [00001c46] 5d pop ebp
>>>>> [00001c47] c3 ret
>>>>> Size in bytes:(0038) [00001c47]
>>>>>
>>>>>
>>>>>
>>>>
>>>
>>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-02 15:21 -0500 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3ik8r$3gjvi$1@dont-email.me> |
| In reply to | #106082 |
On 6/2/2024 3:11 PM, Richard Damon wrote:
> On 6/2/24 3:34 PM, olcott wrote:
>> On 6/2/2024 2:22 PM, Richard Damon wrote:
>>> On 6/2/24 3:13 PM, olcott wrote:
>>>> On 6/2/2024 2:05 PM, Richard Damon wrote:
>>>>> On 6/2/24 2:29 PM, olcott wrote:
>>>>>> On 6/2/2024 1:13 PM, Richard Damon wrote:
>>>>>>> On 6/2/24 1:59 PM, olcott wrote:
>>>>>>>> On 6/2/2024 12:22 PM, Richard Damon wrote:
>>>>>>>>> On 6/2/24 10:19 AM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>> Semantic tautologies are self-evident truth that prove
>>>>>>>>>> themselves.
>>>>>>>>>> It is a fact that every five pound rock weights more than any
>>>>>>>>>> three pound rock. No need to weigh any rocks.
>>>>>>>>>
>>>>>>>>> Right, so you don't need to weigh a five pound rock to know it
>>>>>>>>> is five bpounds.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>>>>>>>> 00 int HH(ptr p, ptr i);
>>>>>>>>>> 01 int DD(ptr p)
>>>>>>>>>> 02 {
>>>>>>>>>> 03 int Halt_Status = HH(p, p);
>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>> 07 }
>>>>>>>>>> 08
>>>>>>>>>> 09 int main()
>>>>>>>>>> 10 {
>>>>>>>>>> 11 HH(DD,DD);
>>>>>>>>>> 12 return 0;
>>>>>>>>>> 13 }
>>>>>>>>>>
>>>>>>>>>> Likewise we correctly deduce that for every HH/DD pair of the
>>>>>>>>>> infinite set of all HH/DD pairs that match the above template
>>>>>>>>>> every DD correctly simulated by HH never reaches past its own
>>>>>>>>>> simulated line 03, thus never halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> When for every freaking HH/DD pair that matches the above template
>>>>>>>> DD correctly simulated by HH cannot possibly ever reaches past its
>>>>>>>> own simulated line 03 then
>>>>>>>>
>>>>>>>> we know with complete logical certainty that not a damn one of
>>>>>>>> these DD instance halts. halts, NOT A DAMN ONE OF THEM EVER HALTS.
>>>>>>>
>>>>>>> Nope, and you are just proving you are totally out of touch with
>>>>>>> reality.
>>>>>>>
>>>>>>> EVERY DD built on an HH that returns 0 for HH(DD,DD) will Halt.
>>>>>>>
>>>>>>
>>>>>> I am going to give up on you because you continue to try
>>>>>> to get away with the straw-mam deception CHANGE-THE-SUBJECT
>>>>>> fake rebuttal.
>>>>>
>>>>> Nope. I am not "Changing the subject" but showing that your subject
>>>>> is incorrect or irrelevent.
>>>>>
>>>>>>
>>>>>> This is the only post that I will reply to and unless you
>>>>>> either accept that DD correctly simulated by HH will never
>>>>>> halt for the infinite set of HH/DD pairs specified below
>>>>>> or correctly refute the paragraph relating to the x86 code
>>>>>> of DD shown below *I will simply not respond to your posts*
>>>>>
>>>>> Which I won't do until you say why it matters.
>>>>>
>>>>>>
>>>>>> (a) Accept the DD/HH that DD never halts
>>>>>> (b) Correctly refute the x86 DD
>>>>>> *EVERYTHING ELSE WILL GET NO RESPONSE FROM ME*
>>>>>
>>>>> And thus a whole list of posts refuting everything that you say
>>>>> that you will just be forced to leave out there or convict yourself
>>>>> of LYING.
>>>>>
>>>>>>
>>>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>>>> 00 int HH(ptr p, ptr i);
>>>>>> 01 int DD(ptr p)
>>>>>> 02 {
>>>>>> 03 int Halt_Status = HH(p, p);
>>>>>> 04 if (Halt_Status)
>>>>>> 05 HERE: goto HERE;
>>>>>> 06 return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 int main()
>>>>>> 10 {
>>>>>> 11 HH(DD,DD);
>>>>>> 12 return 0;
>>>>>> 13 }
>>>>>>
>>>>>>
>>>>>> DD correctly emulated by HH with an x86 emulator cannot possibly
>>>>>> reach past its own machine instruction [00001c2e] in any finite
>>>>>> (or infinite) number of steps of correct emulation.
>>>>>
>>>>> But any such finite simulation
>>>>
>>>> DD correctly emulated by HH with an x86 emulator cannot possibly
>>>> reach past its own machine instruction [00001c2e] in any finite
>>>> (or infinite) number of steps of correct emulation.
>>>>
>>>> (or infinite) number of steps of correct emulation.
>>>> (or infinite) number of steps of correct emulation.
>>>> (or infinite) number of steps of correct emulation.
>>>> (or infinite) number of steps of correct emulation.
>>>
>>> But you only show the "or infinite number of steps" for DDs built on
>>> an HH that never aborts.
>>>
>>
>> Maybe you are having a bad day. You are already forgetting how
>> you just chastised me last night for not equating finite number
>> of steps with an aborted simulation.
>
> So, what is your confusion.
>
> The only DDs that you have simulated for an infinte number of steps are
> those DDs built on an HH that NEVER ABORTS its simulation.
>
Just like every rock that weighs more than five pounds weighs
more that three pounds
When every DD correctly simulated by every HH that can possibly
exist DOESN'T HALT THEN NONE OF THEM HALT.
--
Copyright 2024 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 | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-02 16:32 -0400 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3iks6$2qu71$7@i2pn2.org> |
| In reply to | #106083 |
On 6/2/24 4:21 PM, olcott wrote:
> On 6/2/2024 3:11 PM, Richard Damon wrote:
>> On 6/2/24 3:34 PM, olcott wrote:
>>> On 6/2/2024 2:22 PM, Richard Damon wrote:
>>>> On 6/2/24 3:13 PM, olcott wrote:
>>>>> On 6/2/2024 2:05 PM, Richard Damon wrote:
>
>>>>>> On 6/2/24 2:29 PM, olcott wrote:
>>>>>>> On 6/2/2024 1:13 PM, Richard Damon wrote:
>>>>>>>> On 6/2/24 1:59 PM, olcott wrote:
>>>>>>>>> On 6/2/2024 12:22 PM, Richard Damon wrote:
>>>>>>>>>> On 6/2/24 10:19 AM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>> Semantic tautologies are self-evident truth that prove
>>>>>>>>>>> themselves.
>>>>>>>>>>> It is a fact that every five pound rock weights more than any
>>>>>>>>>>> three pound rock. No need to weigh any rocks.
>>>>>>>>>>
>>>>>>>>>> Right, so you don't need to weigh a five pound rock to know it
>>>>>>>>>> is five bpounds.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>>>>>>>>> 00 int HH(ptr p, ptr i);
>>>>>>>>>>> 01 int DD(ptr p)
>>>>>>>>>>> 02 {
>>>>>>>>>>> 03 int Halt_Status = HH(p, p);
>>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>>> 07 }
>>>>>>>>>>> 08
>>>>>>>>>>> 09 int main()
>>>>>>>>>>> 10 {
>>>>>>>>>>> 11 HH(DD,DD);
>>>>>>>>>>> 12 return 0;
>>>>>>>>>>> 13 }
>>>>>>>>>>>
>>>>>>>>>>> Likewise we correctly deduce that for every HH/DD pair of the
>>>>>>>>>>> infinite set of all HH/DD pairs that match the above template
>>>>>>>>>>> every DD correctly simulated by HH never reaches past its own
>>>>>>>>>>> simulated line 03, thus never halts.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> When for every freaking HH/DD pair that matches the above template
>>>>>>>>> DD correctly simulated by HH cannot possibly ever reaches past its
>>>>>>>>> own simulated line 03 then
>>>>>>>>>
>>>>>>>>> we know with complete logical certainty that not a damn one of
>>>>>>>>> these DD instance halts. halts, NOT A DAMN ONE OF THEM EVER HALTS.
>>>>>>>>
>>>>>>>> Nope, and you are just proving you are totally out of touch with
>>>>>>>> reality.
>>>>>>>>
>>>>>>>> EVERY DD built on an HH that returns 0 for HH(DD,DD) will Halt.
>>>>>>>>
>>>>>>>
>>>>>>> I am going to give up on you because you continue to try
>>>>>>> to get away with the straw-mam deception CHANGE-THE-SUBJECT
>>>>>>> fake rebuttal.
>>>>>>
>>>>>> Nope. I am not "Changing the subject" but showing that your
>>>>>> subject is incorrect or irrelevent.
>>>>>>
>>>>>>>
>>>>>>> This is the only post that I will reply to and unless you
>>>>>>> either accept that DD correctly simulated by HH will never
>>>>>>> halt for the infinite set of HH/DD pairs specified below
>>>>>>> or correctly refute the paragraph relating to the x86 code
>>>>>>> of DD shown below *I will simply not respond to your posts*
>>>>>>
>>>>>> Which I won't do until you say why it matters.
>>>>>>
>>>>>>>
>>>>>>> (a) Accept the DD/HH that DD never halts
>>>>>>> (b) Correctly refute the x86 DD
>>>>>>> *EVERYTHING ELSE WILL GET NO RESPONSE FROM ME*
>>>>>>
>>>>>> And thus a whole list of posts refuting everything that you say
>>>>>> that you will just be forced to leave out there or convict
>>>>>> yourself of LYING.
>>>>>>
>>>>>>>
>>>>>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>>>>>> 00 int HH(ptr p, ptr i);
>>>>>>> 01 int DD(ptr p)
>>>>>>> 02 {
>>>>>>> 03 int Halt_Status = HH(p, p);
>>>>>>> 04 if (Halt_Status)
>>>>>>> 05 HERE: goto HERE;
>>>>>>> 06 return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 int main()
>>>>>>> 10 {
>>>>>>> 11 HH(DD,DD);
>>>>>>> 12 return 0;
>>>>>>> 13 }
>>>>>>>
>>>>>>>
>>>>>>> DD correctly emulated by HH with an x86 emulator cannot possibly
>>>>>>> reach past its own machine instruction [00001c2e] in any finite
>>>>>>> (or infinite) number of steps of correct emulation.
>>>>>>
>>>>>> But any such finite simulation
>>>>>
>>>>> DD correctly emulated by HH with an x86 emulator cannot possibly
>>>>> reach past its own machine instruction [00001c2e] in any finite
>>>>> (or infinite) number of steps of correct emulation.
>>>>>
>>>>> (or infinite) number of steps of correct emulation.
>>>>> (or infinite) number of steps of correct emulation.
>>>>> (or infinite) number of steps of correct emulation.
>>>>> (or infinite) number of steps of correct emulation.
>>>>
>>>> But you only show the "or infinite number of steps" for DDs built on
>>>> an HH that never aborts.
>>>>
>>>
>>> Maybe you are having a bad day. You are already forgetting how
>>> you just chastised me last night for not equating finite number
>>> of steps with an aborted simulation.
>>
>> So, what is your confusion.
>>
>> The only DDs that you have simulated for an infinte number of steps
>> are those DDs built on an HH that NEVER ABORTS its simulation.
>>
>
> Just like every rock that weighs more than five pounds weighs
> more that three pounds
>
> When every DD correctly simulated by every HH that can possibly
> exist DOESN'T HALT THEN NONE OF THEM HALT.
>
WRONG, and shows that you are a LIAR.
Every DD is NOT simulated by *EVERY* HH, but each HH only simulates ONE DD.
Thus, your arguement is just based on your pathological LIES that you
always tell.
EVERY DD based on an HH that aborts its simulation of HH(DD,DD) and
returns 0 will Halt.
EVERY HH that doesn not abort its simulation of HH(DD,DD) will not
answer, as it gets stuck in an infinite simulation loop.
Thus *NO* HH correctly answers about its DD halting.
And you have just shown that you have WASTED your last 20 years by
brainwashing yourself into believing your lies and not bothering to
actual learn anything about the topic you talk about.
You are nothing but a DAMNED ingnorant pathological lying idiot, that
has a reckless disregard for what is true, but who belives his own lies
despite the evidence that you just refuse to look at.
You are worse than the election deniers that you claim you want to
educate to have them see the truth.
You just show why that is such a tough job, because you BLINDELY believe
what you want, and ignore all the evidence, because you have lost
contract with reality.
[toc] | [prev] | [next] | [standalone]
| From | immibis <news@immibis.com> |
|---|---|
| Date | 2024-06-03 02:14 +0200 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3j1t4$3gm10$1@dont-email.me> |
| In reply to | #106083 |
On 2/06/24 22:21, olcott wrote: > Just like every rock that weighs more than five pounds weighs > more that three pounds > > When every DD correctly simulated by every HH that can possibly > exist DOESN'T HALT THEN NONE OF THEM HALT. > Just like every rock that weighs more than five pounds weighs more than three pounds. Every non-ending simulation is a simulation of a non-ending execution.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-02 15:50 -0500 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3ilva$3gr4e$1@dont-email.me> |
| In reply to | #106082 |
*We can see that the following DD cannot possibly halt*
*when correctly simulated by every HH that can possibly exist*
typedef int (*ptr)(); // ptr is pointer to int function in C
00 int HH(ptr p, ptr i);
01 int DD(ptr p)
02 {
03 int Halt_Status = HH(p, p);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
_DD()
[00001c22] 55 push ebp
[00001c23] 8bec mov ebp,esp
[00001c25] 51 push ecx
[00001c26] 8b4508 mov eax,[ebp+08]
[00001c29] 50 push eax ; push DD 1c22
[00001c2a] 8b4d08 mov ecx,[ebp+08]
[00001c2d] 51 push ecx ; push DD 1c22
[00001c2e] e80ff7ffff call 00001342 ; call HH
[00001c33] 83c408 add esp,+08
[00001c36] 8945fc mov [ebp-04],eax
[00001c39] 837dfc00 cmp dword [ebp-04],+00
[00001c3d] 7402 jz 00001c41
[00001c3f] ebfe jmp 00001c3f
[00001c41] 8b45fc mov eax,[ebp-04]
[00001c44] 8be5 mov esp,ebp
[00001c46] 5d pop ebp
[00001c47] c3 ret
Size in bytes:(0038) [00001c47]
--
Copyright 2024 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 | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-02 16:58 -0400 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3imd7$2qu72$15@i2pn2.org> |
| In reply to | #106085 |
On 6/2/24 4:50 PM, olcott wrote:
> *We can see that the following DD cannot possibly halt*
Unless the HH(DD,DD) aborts its simulation and returns 0, then DD(DD)
will ALWAYS halt when directly called, which is the definition of "Halting".
Not your LIE that it pertains to partial simulations.
> *when correctly simulated by every HH that can possibly exist*
Except for EVERY HH that aborts its simulation and returns 0
So, I guess you are saying that NONE of your HH can EVER stop their
simulation and return 0, so ALL your HH fail to be deciders by not
returning any answer.
That, or you are just admitting to being the pathological liar that you
have shown yourself to be.
>
> typedef int (*ptr)(); // ptr is pointer to int function in C
> 00 int HH(ptr p, ptr i);
> 01 int DD(ptr p)
> 02 {
> 03 int Halt_Status = HH(p, p);
> 04 if (Halt_Status)
> 05 HERE: goto HERE;
> 06 return Halt_Status;
> 07 }
>
> _DD()
> [00001c22] 55 push ebp
> [00001c23] 8bec mov ebp,esp
> [00001c25] 51 push ecx
> [00001c26] 8b4508 mov eax,[ebp+08]
> [00001c29] 50 push eax ; push DD 1c22
> [00001c2a] 8b4d08 mov ecx,[ebp+08]
> [00001c2d] 51 push ecx ; push DD 1c22
> [00001c2e] e80ff7ffff call 00001342 ; call HH
> [00001c33] 83c408 add esp,+08
> [00001c36] 8945fc mov [ebp-04],eax
> [00001c39] 837dfc00 cmp dword [ebp-04],+00
> [00001c3d] 7402 jz 00001c41
> [00001c3f] ebfe jmp 00001c3f
> [00001c41] 8b45fc mov eax,[ebp-04]
> [00001c44] 8be5 mov esp,ebp
> [00001c46] 5d pop ebp
> [00001c47] c3 ret
> Size in bytes:(0038) [00001c47]
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-02 16:25 -0500 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3io0j$3h1t8$1@dont-email.me> |
| In reply to | #106086 |
On 6/2/2024 3:58 PM, Richard Damon wrote:
> On 6/2/24 4:50 PM, olcott wrote:
>> *We can see that the following DD cannot possibly halt*
>
> Unless the HH(DD,DD) aborts its simulation and returns 0, then DD(DD)
> will ALWAYS halt when directly called, which is the definition of
> "Halting".
>
> Not your LIE that it pertains to partial simulations.
>
>> *when correctly simulated by every HH that can possibly exist*
>
> Except for EVERY HH that aborts its simulation and returns 0
>
This may be an ADD thing.
For every HH that aborts its simulation and returns 0
DD correctly simulated by this HH *DID NOT HALT AND NEVER WILL HALT*
Its either ADD thing in which case you salvation is not in any danger
or it is not a ADD thing.
> So, I guess you are saying that NONE of your HH can EVER stop their
> simulation and return 0, so ALL your HH fail to be deciders by not
> returning any answer.
>
> That, or you are just admitting to being the pathological liar that you
> have shown yourself to be.
>
When DD simulated by every HH that can possibly exist does not
halt this DOES PROVE THAT EACH DD SIMULATED BY HH DOES NOT HALT.
Of All rocks weighing more that five pounds each rock weighs more
than five pounds.
>>
>> typedef int (*ptr)(); // ptr is pointer to int function in C
>> 00 int HH(ptr p, ptr i);
>> 01 int DD(ptr p)
>> 02 {
>> 03 int Halt_Status = HH(p, p);
>> 04 if (Halt_Status)
>> 05 HERE: goto HERE;
>> 06 return Halt_Status;
>> 07 }
>>
>> _DD()
>> [00001c22] 55 push ebp
>> [00001c23] 8bec mov ebp,esp
>> [00001c25] 51 push ecx
>> [00001c26] 8b4508 mov eax,[ebp+08]
>> [00001c29] 50 push eax ; push DD 1c22
>> [00001c2a] 8b4d08 mov ecx,[ebp+08]
>> [00001c2d] 51 push ecx ; push DD 1c22
>> [00001c2e] e80ff7ffff call 00001342 ; call HH
>> [00001c33] 83c408 add esp,+08
>> [00001c36] 8945fc mov [ebp-04],eax
>> [00001c39] 837dfc00 cmp dword [ebp-04],+00
>> [00001c3d] 7402 jz 00001c41
>> [00001c3f] ebfe jmp 00001c3f
>> [00001c41] 8b45fc mov eax,[ebp-04]
>> [00001c44] 8be5 mov esp,ebp
>> [00001c46] 5d pop ebp
>> [00001c47] c3 ret
>> Size in bytes:(0038) [00001c47]
>>
>>
>
--
Copyright 2024 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 | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-02 17:43 -0400 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3ip1a$2qu71$8@i2pn2.org> |
| In reply to | #106088 |
On 6/2/24 5:25 PM, olcott wrote:
> On 6/2/2024 3:58 PM, Richard Damon wrote:
>> On 6/2/24 4:50 PM, olcott wrote:
>>> *We can see that the following DD cannot possibly halt*
>>
>> Unless the HH(DD,DD) aborts its simulation and returns 0, then DD(DD)
>> will ALWAYS halt when directly called, which is the definition of
>> "Halting".
>>
>> Not your LIE that it pertains to partial simulations.
>>
>>> *when correctly simulated by every HH that can possibly exist*
>>
>> Except for EVERY HH that aborts its simulation and returns 0
>>
>
> This may be an ADD thing.
> For every HH that aborts its simulation and returns 0
> DD correctly simulated by this HH *DID NOT HALT AND NEVER WILL HALT*
Except you mental problems are getting in YOUR way.
You said that "DD Can not halt" NOT "the simulation by H of DD can not Halt"
Those are DIFFERENT statements.
DD WILL Halt.
Your claim, that I will neither confirm or deny (until you can show why
I should), is that the simulation by H can never reach the statement
after the call instruction.
That is NOT a definition of "Halting", and any claim that is it is just
a LIE.
>
> Its either ADD thing in which case you salvation is not in any danger
> or it is not a ADD thing.
Nope, it is YORU STUPIDITY.
I might suggest you talk to your oncologist, as your arguements seem to
have decayed in the last year.
DD(DD) Halts if HH(DD,DD) returns 0. PROVEN FACT.
You can run it yourself to see.
>
>> So, I guess you are saying that NONE of your HH can EVER stop their
>> simulation and return 0, so ALL your HH fail to be deciders by not
>> returning any answer.
>>
>> That, or you are just admitting to being the pathological liar that
>> you have shown yourself to be.
>>
>
> When DD simulated by every HH that can possibly exist does not
> halt this DOES PROVE THAT EACH DD SIMULATED BY HH DOES NOT HALT.
If it is true that every HH that can possible exist can not simulate its
ONE DD (not every on every, as you haven't shown that) to a final state,
that doesn't even technically show the simulation doesn't halt, unless
you are going to stipulate an abnormal definition for a "simulation
halting" to mean "simulate the input to a halting state".
In general, an operation (like you conditional simulation) is considered
to have "halted' when the operation, by its own decision, has finished
the work it is going to do. That is what you simulation did, so HH's
simulation DID Halt, it just didn't simulate DD to a final state, so
that doesn't prove that the DD that it was simulating would Halt, but it
also doesn't prove that it doesn't
>
> Of All rocks weighing more that five pounds each rock weighs more
> than five pounds.
But you have to first show that they ARE rocks of more than 5 poinds.
You have claimed that HH's partial simulation of DD will never reach a
final state. That is NOT the same as showing that DD will never halt.
The fact that we have PROVEN that EVERY DD(DD) will halt if HH(DD,DD)
returns 0, means you claim is just a reckless disregard for the truth,
showing that you are an ignorant pathological liar.
>
>>>
>>> typedef int (*ptr)(); // ptr is pointer to int function in C
>>> 00 int HH(ptr p, ptr i);
>>> 01 int DD(ptr p)
>>> 02 {
>>> 03 int Halt_Status = HH(p, p);
>>> 04 if (Halt_Status)
>>> 05 HERE: goto HERE;
>>> 06 return Halt_Status;
>>> 07 }
>>>
>>> _DD()
>>> [00001c22] 55 push ebp
>>> [00001c23] 8bec mov ebp,esp
>>> [00001c25] 51 push ecx
>>> [00001c26] 8b4508 mov eax,[ebp+08]
>>> [00001c29] 50 push eax ; push DD 1c22
>>> [00001c2a] 8b4d08 mov ecx,[ebp+08]
>>> [00001c2d] 51 push ecx ; push DD 1c22
>>> [00001c2e] e80ff7ffff call 00001342 ; call HH
>>> [00001c33] 83c408 add esp,+08
>>> [00001c36] 8945fc mov [ebp-04],eax
>>> [00001c39] 837dfc00 cmp dword [ebp-04],+00
>>> [00001c3d] 7402 jz 00001c41
>>> [00001c3f] ebfe jmp 00001c3f
>>> [00001c41] 8b45fc mov eax,[ebp-04]
>>> [00001c44] 8be5 mov esp,ebp
>>> [00001c46] 5d pop ebp
>>> [00001c47] c3 ret
>>> Size in bytes:(0038) [00001c47]
>>>
>>>
>>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-02 17:05 -0500 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3iqae$3hetk$1@dont-email.me> |
| In reply to | #106089 |
On 6/2/2024 4:43 PM, Richard Damon wrote:
> On 6/2/24 5:25 PM, olcott wrote:
>> On 6/2/2024 3:58 PM, Richard Damon wrote:
>>> On 6/2/24 4:50 PM, olcott wrote:
>>>> *We can see that the following DD cannot possibly halt*
>>>
>>> Unless the HH(DD,DD) aborts its simulation and returns 0, then DD(DD)
>>> will ALWAYS halt when directly called, which is the definition of
>>> "Halting".
>>>
>>> Not your LIE that it pertains to partial simulations.
>>>
>>>> *when correctly simulated by every HH that can possibly exist*
>>>
>>> Except for EVERY HH that aborts its simulation and returns 0
>>>
>>
>> This may be an ADD thing.
>> For every HH that aborts its simulation and returns 0
>> DD correctly simulated by this HH *DID NOT HALT AND NEVER WILL HALT*
>
> Except you mental problems are getting in YOUR way.
>
> You said that "DD Can not halt" NOT "the simulation by H of DD can not
> Halt"
>
*I said neither of those things so it may be an ADD problem*
> Those are DIFFERENT statements.
>
> DD WILL Halt.
>
> Your claim, that I will neither confirm or deny (until you can show why
> I should), is that the simulation by H can never reach the statement
> after the call instruction.
>
*Still not quite what I said*
> That is NOT a definition of "Halting", and any claim that is it is just
> a LIE.
>
>>
>> Its either ADD thing in which case you salvation is not in any danger
>> or it is not a ADD thing.
>
> Nope, it is YORU STUPIDITY.
>
> I might suggest you talk to your oncologist, as your arguements seem to
> have decayed in the last year.
>
> DD(DD) Halts if HH(DD,DD) returns 0. PROVEN FACT.
>
> You can run it yourself to see.
>
>>
>>> So, I guess you are saying that NONE of your HH can EVER stop their
>>> simulation and return 0, so ALL your HH fail to be deciders by not
>>> returning any answer.
>>>
>>> That, or you are just admitting to being the pathological liar that
>>> you have shown yourself to be.
>>>
>>
>> When DD simulated by every HH that can possibly exist does not
>> halt this DOES PROVE THAT EACH DD SIMULATED BY HH DOES NOT HALT.
>
> If it is true that every HH that can possible exist can not simulate its
> ONE DD (not every on every, as you haven't shown that) to a final state,
> that doesn't even technically show the simulation doesn't halt, unless
Right and in this same way we cannot tell that every rock that
weighs more than five pounds weighs more than five pounds.
We may find some five pound rocks that only weigh three pounds.
*We can see that the following DD cannot possibly halt*
*when correctly simulated by every HH that can possibly exist*
typedef int (*ptr)(); // ptr is pointer to int function in C
00 int HH(ptr p, ptr i);
01 int DD(ptr p)
02 {
03 int Halt_Status = HH(p, p);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
_DD()
[00001c22] 55 push ebp
[00001c23] 8bec mov ebp,esp
[00001c25] 51 push ecx
[00001c26] 8b4508 mov eax,[ebp+08]
[00001c29] 50 push eax ; push DD 1c22
[00001c2a] 8b4d08 mov ecx,[ebp+08]
[00001c2d] 51 push ecx ; push DD 1c22
[00001c2e] e80ff7ffff call 00001342 ; call HH
[00001c33] 83c408 add esp,+08
[00001c36] 8945fc mov [ebp-04],eax
[00001c39] 837dfc00 cmp dword [ebp-04],+00
[00001c3d] 7402 jz 00001c41
[00001c3f] ebfe jmp 00001c3f
[00001c41] 8b45fc mov eax,[ebp-04]
[00001c44] 8be5 mov esp,ebp
[00001c46] 5d pop ebp
[00001c47] c3 ret
Size in bytes:(0038) [00001c47]
--
Copyright 2024 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 | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-02 18:20 -0400 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3ir73$2qu71$9@i2pn2.org> |
| In reply to | #106090 |
On 6/2/24 6:05 PM, olcott wrote:
> On 6/2/2024 4:43 PM, Richard Damon wrote:
>> On 6/2/24 5:25 PM, olcott wrote:
>>> On 6/2/2024 3:58 PM, Richard Damon wrote:
>>>> On 6/2/24 4:50 PM, olcott wrote:
>>>>> *We can see that the following DD cannot possibly halt*
>>>>
>>>> Unless the HH(DD,DD) aborts its simulation and returns 0, then
>>>> DD(DD) will ALWAYS halt when directly called, which is the
>>>> definition of "Halting".
>>>>
>>>> Not your LIE that it pertains to partial simulations.
>>>>
>>>>> *when correctly simulated by every HH that can possibly exist*
>>>>
>>>> Except for EVERY HH that aborts its simulation and returns 0
>>>>
>>>
>>> This may be an ADD thing.
>>> For every HH that aborts its simulation and returns 0
>>> DD correctly simulated by this HH *DID NOT HALT AND NEVER WILL HALT*
>>
>> Except you mental problems are getting in YOUR way.
>>
>> You said that "DD Can not halt" NOT "the simulation by H of DD can not
>> Halt"
>>
>
> *I said neither of those things so it may be an ADD problem*
I guess your medication is making you blind.
Read the top line quoted from you on 6/2/24 4:50 PM
You said:
"*We can see that the following DD cannot possibly halt*"
Remember, Halting is defined as the MACHINE reaching a fianl state, so
trying to qualify it with a partial simulation is an irrelevent
qualification.
>
>> Those are DIFFERENT statements.
>>
>> DD WILL Halt.
>>
>> Your claim, that I will neither confirm or deny (until you can show
>> why I should), is that the simulation by H can never reach the
>> statement after the call instruction.
>>
>
> *Still not quite what I said*
But you did in your message from 3:54 today earier in the thread:
DD correctly emulated by HH with an x86 emulator cannot possibly
reach past its own machine instruction [00001c2e]
>
>> That is NOT a definition of "Halting", and any claim that is it is
>> just a LIE.
>>
>>>
>>> Its either ADD thing in which case you salvation is not in any danger
>>> or it is not a ADD thing.
>>
>> Nope, it is YORU STUPIDITY.
>>
>> I might suggest you talk to your oncologist, as your arguements seem
>> to have decayed in the last year.
>>
>> DD(DD) Halts if HH(DD,DD) returns 0. PROVEN FACT.
>>
>> You can run it yourself to see.
>>
>>>
>>>> So, I guess you are saying that NONE of your HH can EVER stop their
>>>> simulation and return 0, so ALL your HH fail to be deciders by not
>>>> returning any answer.
>>>>
>>>> That, or you are just admitting to being the pathological liar that
>>>> you have shown yourself to be.
>>>>
>>>
>>> When DD simulated by every HH that can possibly exist does not
>>> halt this DOES PROVE THAT EACH DD SIMULATED BY HH DOES NOT HALT.
>>
>> If it is true that every HH that can possible exist can not simulate
>> its ONE DD (not every on every, as you haven't shown that) to a final
>> state, that doesn't even technically show the simulation doesn't halt,
>> unless
>
> Right and in this same way we cannot tell that every rock that
> weighs more than five pounds weighs more than five pounds.
> We may find some five pound rocks that only weigh three pounds.
RED HERRING DIVERSION.
You are just admitting that you have run out of plausable lies.
>
> *We can see that the following DD cannot possibly halt*
> *when correctly simulated by every HH that can possibly exist*
JUST NONSENSE WORDS AS AN ABORTED SIMULATION DOESN'T TALK ABOUT HALTING.
DD DOES Halt, as Halting talks about the behavior of the machine,
So, you are just proving your stupidity.
>
> typedef int (*ptr)(); // ptr is pointer to int function in C
> 00 int HH(ptr p, ptr i);
> 01 int DD(ptr p)
> 02 {
> 03 int Halt_Status = HH(p, p);
> 04 if (Halt_Status)
> 05 HERE: goto HERE;
> 06 return Halt_Status;
> 07 }
>
> _DD()
> [00001c22] 55 push ebp
> [00001c23] 8bec mov ebp,esp
> [00001c25] 51 push ecx
> [00001c26] 8b4508 mov eax,[ebp+08]
> [00001c29] 50 push eax ; push DD 1c22
> [00001c2a] 8b4d08 mov ecx,[ebp+08]
> [00001c2d] 51 push ecx ; push DD 1c22
> [00001c2e] e80ff7ffff call 00001342 ; call HH
> [00001c33] 83c408 add esp,+08
> [00001c36] 8945fc mov [ebp-04],eax
> [00001c39] 837dfc00 cmp dword [ebp-04],+00
> [00001c3d] 7402 jz 00001c41
> [00001c3f] ebfe jmp 00001c3f
> [00001c41] 8b45fc mov eax,[ebp-04]
> [00001c44] 8be5 mov esp,ebp
> [00001c46] 5d pop ebp
> [00001c47] c3 ret
> Size in bytes:(0038) [00001c47]
>
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-02 17:44 -0500 |
| Subject | Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD |
| Message-ID | <v3isk0$3hvf6$1@dont-email.me> |
| In reply to | #106091 |
On 6/2/2024 5:20 PM, Richard Damon wrote:
> On 6/2/24 6:05 PM, olcott wrote:
>> On 6/2/2024 4:43 PM, Richard Damon wrote:
>>> On 6/2/24 5:25 PM, olcott wrote:
>>>> On 6/2/2024 3:58 PM, Richard Damon wrote:
>>>>> On 6/2/24 4:50 PM, olcott wrote:
>>>>>> *We can see that the following DD cannot possibly halt*
>>>>>
>>>>> Unless the HH(DD,DD) aborts its simulation and returns 0, then
>>>>> DD(DD) will ALWAYS halt when directly called, which is the
>>>>> definition of "Halting".
>>>>>
>>>>> Not your LIE that it pertains to partial simulations.
>>>>>
>>>>>> *when correctly simulated by every HH that can possibly exist*
>>>>>
>>>>> Except for EVERY HH that aborts its simulation and returns 0
>>>>>
>>>>
>>>> This may be an ADD thing.
>>>> For every HH that aborts its simulation and returns 0
>>>> DD correctly simulated by this HH *DID NOT HALT AND NEVER WILL HALT*
>>>
>>> Except you mental problems are getting in YOUR way.
>>>
>>> You said that "DD Can not halt" NOT "the simulation by H of DD can
>>> not Halt"
>>>
>>
>> *I said neither of those things so it may be an ADD problem*
>
> I guess your medication is making you blind.
>
> Read the top line quoted from you on 6/2/24 4:50 PM
>
> You said:
> "*We can see that the following DD cannot possibly halt*"
>
*Deceitfully taking things out of context*
On 6/2/2024 3:50 PM, olcott wrote:
> *We can see that the following DD cannot possibly halt*
> *when correctly simulated by every HH that can possibly exist*
> Remember, Halting is defined as the MACHINE reaching a fianl state, so
> trying to qualify it with a partial simulation is an irrelevent
> qualification.
>
>
>>
>>> Those are DIFFERENT statements.
>>>
>>> DD WILL Halt.
>>>
>>> Your claim, that I will neither confirm or deny (until you can show
>>> why I should), is that the simulation by H can never reach the
>>> statement after the call instruction.
>>>
>>
>> *Still not quite what I said*
>
> But you did in your message from 3:54 today earier in the thread:
>
> DD correctly emulated by HH with an x86 emulator cannot possibly
> reach past its own machine instruction [00001c2e]
>
If you get my words 99.99999% perfectly then you screwed up
far too much, thus 80% is not in the ballpark.
*We can see that the following DD cannot possibly halt*
*when correctly simulated by every HH that can possibly exist*
typedef int (*ptr)(); // ptr is pointer to int function in C
00 int HH(ptr p, ptr i);
01 int DD(ptr p)
02 {
03 int Halt_Status = HH(p, p);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
_DD()
[00001c22] 55 push ebp
[00001c23] 8bec mov ebp,esp
[00001c25] 51 push ecx
[00001c26] 8b4508 mov eax,[ebp+08]
[00001c29] 50 push eax ; push DD 1c22
[00001c2a] 8b4d08 mov ecx,[ebp+08]
[00001c2d] 51 push ecx ; push DD 1c22
[00001c2e] e80ff7ffff call 00001342 ; call HH
[00001c33] 83c408 add esp,+08
[00001c36] 8945fc mov [ebp-04],eax
[00001c39] 837dfc00 cmp dword [ebp-04],+00
[00001c3d] 7402 jz 00001c41
[00001c3f] ebfe jmp 00001c3f
[00001c41] 8b45fc mov eax,[ebp-04]
[00001c44] 8be5 mov esp,ebp
[00001c46] 5d pop ebp
[00001c47] c3 ret
Size in bytes:(0038) [00001c47]
--
Copyright 2024 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]
Page 8 of 19 — ← Prev page 1 … 6 7 [8] 9 10 … 19 Next page →
Back to top | Article view | comp.theory
csiph-web