Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #106719 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2024-06-08 13:47 -0500 |
| Last post | 2024-06-10 23:32 -0400 |
| Articles | 20 on this page of 87 — 5 participants |
Back to article view | Back to comp.theory
Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-08 13:47 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-08 14:49 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-08 16:32 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-08 16:32 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-09 08:33 +0200
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-09 07:21 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-09 14:08 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-09 09:13 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-09 14:08 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Mikko <mikko.levanto@iki.fi> - 2024-06-10 10:48 +0300
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-10 10:09 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-10 23:32 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Mikko <mikko.levanto@iki.fi> - 2024-06-11 11:02 +0300
DDD correctly simulated by HH cannot possibly halt olcott <polcott333@gmail.com> - 2024-06-11 12:24 -0500
Re: DDD correctly simulated by HH cannot possibly halt Richard Damon <richard@damon-family.org> - 2024-06-11 21:46 -0400
Re: DDD correctly simulated by HH cannot possibly halt Mikko <mikko.levanto@iki.fi> - 2024-06-12 10:20 +0300
Re: DDD correctly simulated by HH cannot possibly halt olcott <polcott333@gmail.com> - 2024-06-12 10:17 -0500
Re: DDD correctly simulated by HH cannot possibly halt Mikko <mikko.levanto@iki.fi> - 2024-06-15 15:03 +0300
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Mikko <mikko.levanto@iki.fi> - 2024-06-15 14:59 +0300
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-10 00:17 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-10 09:09 +0200
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-10 08:52 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) joes <noreply@example.com> - 2024-06-10 15:35 +0000
Proof that D correctly simulated by H has different behavior than D(D) olcott <polcott333@gmail.com> - 2024-06-10 10:39 -0500
Re: Proof that D correctly simulated by H has different behavior than D(D) Richard Damon <richard@damon-family.org> - 2024-06-11 21:59 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-10 21:15 +0200
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-11 21:48 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) olcott <polcott333@gmail.com> - 2024-06-10 14:21 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-10 21:41 +0200
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) olcott <polcott333@gmail.com> - 2024-06-10 14:47 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-11 09:21 +0200
D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-11 12:07 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-12 08:18 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-12 09:47 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-12 20:19 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-12 13:24 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-12 21:13 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-12 14:20 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-12 21:46 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-12 14:53 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-13 10:15 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-13 07:44 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-13 21:33 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-13 14:41 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-14 11:59 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-14 07:49 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-14 21:00 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-14 14:18 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-14 22:03 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-14 15:46 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-15 11:03 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-15 07:12 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Richard Damon <richard@damon-family.org> - 2024-06-15 09:51 -0400
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-15 16:06 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-15 09:13 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Richard Damon <richard@damon-family.org> - 2024-06-15 10:29 -0400
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-15 16:37 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-15 09:48 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Richard Damon <richard@damon-family.org> - 2024-06-15 11:02 -0400
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-15 17:12 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-15 10:23 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Richard Damon <richard@damon-family.org> - 2024-06-15 11:39 -0400
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-16 08:21 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-16 07:37 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Richard Damon <richard@damon-family.org> - 2024-06-16 13:30 -0400
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-16 21:08 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-17 08:39 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-17 16:21 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-17 09:35 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-17 16:51 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Mikko <mikko.levanto@iki.fi> - 2024-06-17 10:22 +0300
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-17 08:07 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Mikko <mikko.levanto@iki.fi> - 2024-06-18 10:54 +0300
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-18 07:55 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-18 11:16 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-18 07:43 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-18 17:25 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-18 10:39 -0500
Re: D correctly simulated by H proved for THREE YEARS --- rewritten "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-18 17:53 +0200
Re: D correctly simulated by H proved for THREE YEARS --- rewritten Mikko <mikko.levanto@iki.fi> - 2024-06-18 19:32 +0300
Re: D correctly simulated by H proved for THREE YEARS --- rewritten olcott <polcott333@gmail.com> - 2024-06-18 11:41 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) Richard Damon <richard@damon-family.org> - 2024-06-11 22:17 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-10 07:16 -0400
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-10 12:54 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) joes <noreply@example.com> - 2024-06-10 18:21 +0000
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) olcott <polcott333@gmail.com> - 2024-06-10 13:48 -0500
Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) Richard Damon <richard@damon-family.org> - 2024-06-10 23:32 -0400
Page 1 of 5 [1] 2 3 4 5 Next page →
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-08 13:47 -0500 |
| Subject | Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1) |
| Message-ID | <v428vv$2no74$2@dont-email.me> |
Before we can get to the behavior of the directly executed
DD(DD) we must first see that the Sipser approved criteria
have been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
> I don't think that is the shell game. PO really /has/ an H
> (it's trivial to do for this one case) that correctly determines
> that P(P) *would* never stop running *unless* aborted.
Try to show how this DD correctly simulated by any HH ever
stops running without having its simulation aborted by HH.
_DD()
[00001e12] 55 push ebp
[00001e13] 8bec mov ebp,esp
[00001e15] 51 push ecx
[00001e16] 8b4508 mov eax,[ebp+08]
[00001e19] 50 push eax ; push DD
[00001e1a] 8b4d08 mov ecx,[ebp+08]
[00001e1d] 51 push ecx ; push DD
[00001e1e] e85ff5ffff call 00001382 ; call HH
A {correct simulation} means that each instruction of the
above x86 machine language of DD is correctly simulated
by HH and simulated in the correct order.
In other words the first seven steps of DD correctly simulated
by HH call HH(DD,DD) to repeat these first seven steps. HH then
simulates itself simulating DD until this second instance of DD
calls another HH(DD,DD) to repeat these first seven steps again.
New slave_stack at:10306d
Begin Local Halt Decider Simulation Execution Trace Stored at:113075
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001c22][00113061][00113065] 55 push ebp
[00001c23][00113061][00113065] 8bec mov ebp,esp
[00001c25][0011305d][00103031] 51 push ecx
[00001c26][0011305d][00103031] 8b4508 mov eax,[ebp+08]
[00001c29][00113059][00001c22] 50 push eax ; push DD
[00001c2a][00113059][00001c22] 8b4d08 mov ecx,[ebp+08]
[00001c2d][00113055][00001c22] 51 push ecx ; push DD
[00001c2e][00113051][00001c33] e80ff7ffff call 00001342 ; call HH
New slave_stack at:14da95
[00001c22][0015da89][0015da8d] 55 push ebp
[00001c23][0015da89][0015da8d] 8bec mov ebp,esp
[00001c25][0015da85][0014da59] 51 push ecx
[00001c26][0015da85][0014da59] 8b4508 mov eax,[ebp+08]
[00001c29][0015da81][00001c22] 50 push eax ; push DD
[00001c2a][0015da81][00001c22] 8b4d08 mov ecx,[ebp+08]
[00001c2d][0015da7d][00001c22] 51 push ecx ; push DD
[00001c2e][0015da79][00001c33] e80ff7ffff call 00001342 ; call HH
Local Halt Decider: Recursive Simulation Detected Simulation Stopped
The above is the complete proof that DD correctly simulated
by any HH that can possibly exist never stops running without
having its simulation aborted by HH (or crashing for OOM error).
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-08 14:49 -0500 |
| Message-ID | <v42cjt$2p81p$1@dont-email.me> |
| In reply to | #106719 |
*This has been corrected so that it can be verified that*
*the execution trace matches the x86 source-code of DD*
(two versions of my text files were out-of-sync)
Before we can get to the behavior of the directly executed
DD(DD) we must first see that the Sipser approved criteria
have been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
> I don't think that is the shell game. PO really /has/ an H
> (it's trivial to do for this one case) that correctly determines
> that P(P) *would* never stop running *unless* aborted.
Try to show how this DD correctly simulated by any HH ever
stops running without having its simulation aborted by HH.
_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
A {correct simulation} means that each instruction of the
above x86 machine language of DD is correctly simulated
by HH and simulated in the correct order.
In other words the first seven steps of DD correctly simulated
by HH call HH(DD,DD) to repeat these first seven steps. HH then
simulates itself simulating DD until this second instance of DD
calls another HH(DD,DD) to repeat these first seven steps again.
New slave_stack at:10306d
Begin Local Halt Decider Simulation Execution Trace Stored at:113075
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001c22][00113061][00113065] 55 push ebp ; begin DD
[00001c23][00113061][00113065] 8bec mov ebp,esp
[00001c25][0011305d][00103031] 51 push ecx
[00001c26][0011305d][00103031] 8b4508 mov eax,[ebp+08]
[00001c29][00113059][00001c22] 50 push eax ; push DD
[00001c2a][00113059][00001c22] 8b4d08 mov ecx,[ebp+08]
[00001c2d][00113055][00001c22] 51 push ecx ; push DD
[00001c2e][00113051][00001c33] e80ff7ffff call 00001342 ; call HH
New slave_stack at:14da95
[00001c22][0015da89][0015da8d] 55 push ebp ; begin DD
[00001c23][0015da89][0015da8d] 8bec mov ebp,esp
[00001c25][0015da85][0014da59] 51 push ecx
[00001c26][0015da85][0014da59] 8b4508 mov eax,[ebp+08]
[00001c29][0015da81][00001c22] 50 push eax ; push DD
[00001c2a][0015da81][00001c22] 8b4d08 mov ecx,[ebp+08]
[00001c2d][0015da7d][00001c22] 51 push ecx ; push DD
[00001c2e][0015da79][00001c33] e80ff7ffff call 00001342 ; call HH
Local Halt Decider: Recursive Simulation Detected Simulation Stopped
The above is the complete proof that DD correctly simulated
by any HH that can possibly exist never stops running without
having its simulation aborted by HH (or crashing for OOM error).
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-08 16:32 -0400 |
| Message-ID | <v42f55$3cg3t$28@i2pn2.org> |
| In reply to | #106720 |
On 6/8/24 3:49 PM, olcott wrote:
> *This has been corrected so that it can be verified that*
> *the execution trace matches the x86 source-code of DD*
> (two versions of my text files were out-of-sync)
>
> Before we can get to the behavior of the directly executed
> DD(DD) we must first see that the Sipser approved criteria
> have been met:
>
> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
> If simulating halt decider H correctly simulates its input D
> until H correctly determines that its simulated D would never
> stop running unless aborted then
>
> H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
Which, since his definition of "Correct Simulation" is not yours, you
can not use.
For you to use it, you need to first show that your H actually does a
correct simulation of the input, which is a simualation that actually
recreates the behavior of the input, which requires a simulation that
never aborts.
Since your H doesn't do this, your logic fails.
Sipser would also allow for us to hypothocate that THIS H changes into
such a simulator, but in doing so, the input does not change (since it
can't) and thus for your system, that means the DD still says paired
with the original HH that you are going to claim to be correct.
Since that simulation WILL HALT if H ever decides to abort and return 0,
as long as that option remains, H can never correctly determine that its
simulation would not halt if not aborted.
So, you FAIL to acheive the requirements, and can not use the clause
that you did use, so you have lost correctness of your decider.
>
> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
> > I don't think that is the shell game. PO really /has/ an H
> > (it's trivial to do for this one case) that correctly determines
> > that P(P) *would* never stop running *unless* aborted.
>
> Try to show how this DD correctly simulated by any HH ever
> stops running without having its simulation aborted by HH.
And who cares, since you have defined your "correct simulation" to allow
for just partial simuations, and thus do not indicate non-halting behavior.
>
> _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
>
> A {correct simulation} means that each instruction of the
> above x86 machine language of DD is correctly simulated
> by HH and simulated in the correct order.
>
> In other words the first seven steps of DD correctly simulated
> by HH call HH(DD,DD) to repeat these first seven steps. HH then
> simulates itself simulating DD until this second instance of DD
> calls another HH(DD,DD) to repeat these first seven steps again.
Nope, as after the 7th instruction must be the 8th instruction, which is
thw Call HH instruction. To meet your definition, the simulation must
then continue into HH as THAT is the correct behavior of that instruction
So your arguement is totally off track, andyou are failing to meet even
your own requirements.
>
> New slave_stack at:10306d
> Begin Local Halt Decider Simulation Execution Trace Stored at:113075
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> [00001c22][00113061][00113065] 55 push ebp ; begin DD
> [00001c23][00113061][00113065] 8bec mov ebp,esp
> [00001c25][0011305d][00103031] 51 push ecx
> [00001c26][0011305d][00103031] 8b4508 mov eax,[ebp+08]
> [00001c29][00113059][00001c22] 50 push eax ; push DD
> [00001c2a][00113059][00001c22] 8b4d08 mov ecx,[ebp+08]
> [00001c2d][00113055][00001c22] 51 push ecx ; push DD
> [00001c2e][00113051][00001c33] e80ff7ffff call 00001342 ; call HH
> New slave_stack at:14da95
> [00001c22][0015da89][0015da8d] 55 push ebp ; begin DD
> [00001c23][0015da89][0015da8d] 8bec mov ebp,esp
> [00001c25][0015da85][0014da59] 51 push ecx
> [00001c26][0015da85][0014da59] 8b4508 mov eax,[ebp+08]
> [00001c29][0015da81][00001c22] 50 push eax ; push DD
> [00001c2a][0015da81][00001c22] 8b4d08 mov ecx,[ebp+08]
> [00001c2d][0015da7d][00001c22] 51 push ecx ; push DD
> [00001c2e][0015da79][00001c33] e80ff7ffff call 00001342 ; call HH
> Local Halt Decider: Recursive Simulation Detected Simulation Stopped
>
> The above is the complete proof that DD correctly simulated
> by any HH that can possibly exist never stops running without
> having its simulation aborted by HH (or crashing for OOM error).
>
But if fails to meet your definition of "Correct Simulation" so your
argument is just shown to be a LIE.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-08 16:32 -0400 |
| Message-ID | <v42f59$3cg3t$29@i2pn2.org> |
| In reply to | #106719 |
On 6/8/24 2:47 PM, olcott wrote:
> Before we can get to the behavior of the directly executed
> DD(DD) we must first see that the Sipser approved criteria
> have been met:
>
> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
> If simulating halt decider H correctly simulates its input D
> until H correctly determines that its simulated D would never
> stop running unless aborted then
>
> H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
But it hasn't since the Sipser criteria is based on "Correct SImulation"
meaning a simulation the exactly reproduces the behavior of the directly
executed code, which means a simulation that doesn't stop until it
reaches a final state (even if that takes forever).
H does NOT do that sort of simulation, nor does it correctly determine
that THIS input (and thus still calling the original H), if simulated by
that sort of simulator will not halt, so you never satisfy the
requirements, so can never claim the right of the second clause.
This has been explained to you many times, and your repeating it just
shows a reckless disregard for the truth, and could open you up to a
defamation suit by Professor Sipser. It also shows that your
understanding of what other people say needs to be kept suspect, and you
are proving yourself to be a pathological liar.
>
> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
> > I don't think that is the shell game. PO really /has/ an H
> > (it's trivial to do for this one case) that correctly determines
> > that P(P) *would* never stop running *unless* aborted.
>
> Try to show how this DD correctly simulated by any HH ever
> stops running without having its simulation aborted by HH.
And why do we care?
>
> _DD()
> [00001e12] 55 push ebp
> [00001e13] 8bec mov ebp,esp
> [00001e15] 51 push ecx
> [00001e16] 8b4508 mov eax,[ebp+08]
> [00001e19] 50 push eax ; push DD
> [00001e1a] 8b4d08 mov ecx,[ebp+08]
> [00001e1d] 51 push ecx ; push DD
> [00001e1e] e85ff5ffff call 00001382 ; call HH
>
> A {correct simulation} means that each instruction of the
> above x86 machine language of DD is correctly simulated
> by HH and simulated in the correct order.
>
> In other words the first seven steps of DD correctly simulated
> by HH call HH(DD,DD) to repeat these first seven steps. HH then
> simulates itself simulating DD until this second instance of DD
> calls another HH(DD,DD) to repeat these first seven steps again.
Nope, by your definition
>
> New slave_stack at:10306d
> Begin Local Halt Decider Simulation Execution Trace Stored at:113075
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> [00001c22][00113061][00113065] 55 push ebp
> [00001c23][00113061][00113065] 8bec mov ebp,esp
> [00001c25][0011305d][00103031] 51 push ecx
> [00001c26][0011305d][00103031] 8b4508 mov eax,[ebp+08]
> [00001c29][00113059][00001c22] 50 push eax ; push DD
> [00001c2a][00113059][00001c22] 8b4d08 mov ecx,[ebp+08]
> [00001c2d][00113055][00001c22] 51 push ecx ; push DD
> [00001c2e][00113051][00001c33] e80ff7ffff call 00001342 ; call HH
> New slave_stack at:14da95
And this does not happen by your definition of a correst simulation, but
the trace SHOULD continue at address 00001342, and show the code of HH
What do you think the actual x86 instrucitons mean?
It just shows your intent to decieve.
The following does NOT happen again in the context of the correct x86
simulation of the code given to HH.
So, your trace just proves that you are a LIAR.
And this is not an honest mistake, as you have been told this many
times, but you are unable to accept the truth.
> [00001c22][0015da89][0015da8d] 55 push ebp
> [00001c23][0015da89][0015da8d] 8bec mov ebp,esp
> [00001c25][0015da85][0014da59] 51 push ecx
> [00001c26][0015da85][0014da59] 8b4508 mov eax,[ebp+08]
> [00001c29][0015da81][00001c22] 50 push eax ; push DD
> [00001c2a][0015da81][00001c22] 8b4d08 mov ecx,[ebp+08]
> [00001c2d][0015da7d][00001c22] 51 push ecx ; push DD
> [00001c2e][0015da79][00001c33] e80ff7ffff call 00001342 ; call HH
> Local Halt Decider: Recursive Simulation Detected Simulation Stopped
>
> The above is the complete proof that DD correctly simulated
> by any HH that can possibly exist never stops running without
> having its simulation aborted by HH (or crashing for OOM error).
>
>
Nope, it shows that you can't even follow your own definitions.
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-09 08:33 +0200 |
| Message-ID | <v43ib7$38hnd$1@dont-email.me> |
| In reply to | #106719 |
Op 08.jun.2024 om 20:47 schreef olcott: > Before we can get to the behavior of the directly executed > DD(DD) we must first see that the Sipser approved criteria > have been met: > > <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> > If simulating halt decider H correctly simulates its input D > until H correctly determines that its simulated D would never > stop running unless aborted then > > H can abort its simulation of D and correctly report that D > specifies a non-halting sequence of configurations. > </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022> > > On 10/14/2022 7:44 PM, Ben Bacarisse wrote: > > I don't think that is the shell game. PO really /has/ an H > > (it's trivial to do for this one case) that correctly determines > > that P(P) *would* never stop running *unless* aborted. > > Try to show how this DD correctly simulated by any HH ever > stops running without having its simulation aborted by HH. Stopping at your first error. So, we can focus on it. Your are asking a question that contradicts itself. A correct simulation of HH that aborts itself, should simulate up to the point where the simulated HH aborts. That is logically impossible. So, either it is a correct simulation and then we see that the simulated HH aborts and returns, or the simulation is incorrect, because it assumes incorrectly that things that happen (abort) do not happen. A premature conclusion.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-09 07:21 -0500 |
| Message-ID | <v446ne$3fscf$1@dont-email.me> |
| In reply to | #106754 |
On 6/9/2024 1:33 AM, Fred. Zwarts wrote: > Op 08.jun.2024 om 20:47 schreef olcott: >> Before we can get to the behavior of the directly executed >> DD(DD) we must first see that the Sipser approved criteria >> have been met: >> >> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >> If simulating halt decider H correctly simulates its input D >> until H correctly determines that its simulated D would never >> stop running unless aborted then >> >> H can abort its simulation of D and correctly report that D >> specifies a non-halting sequence of configurations. >> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022> >> >> On 10/14/2022 7:44 PM, Ben Bacarisse wrote: >> > I don't think that is the shell game. PO really /has/ an H >> > (it's trivial to do for this one case) that correctly determines >> > that P(P) *would* never stop running *unless* aborted. >> >> Try to show how this DD correctly simulated by any HH ever >> stops running without having its simulation aborted by HH. > > Stopping at your first error. So, we can focus on it. Your are asking a > question that contradicts itself. In other words the best selling author of theory of computation textbooks doesn't have a clue? > A correct simulation of HH that aborts itself, > should simulate up to the > point where the simulated HH aborts. The outer HH always sees a longer execution trace than the inner ones. Unless the outer one aborts none of them abort. > That is logically impossible. So, > either it is a correct simulation and then we see that the simulated HH > aborts and returns, or the simulation is incorrect, because it assumes > incorrectly that things that happen (abort) do not happen. > A premature conclusion. > > _DD() [00001e32] 55 push ebp ; Begin DD [00001e33] 8bec mov ebp,esp [00001e35] 51 push ecx [00001e36] 8b4508 mov eax,[ebp+08] [00001e39] 50 push eax ; push DD [00001e3a] 8b4d08 mov ecx,[ebp+08] [00001e3d] 51 push ecx ; push DD [00001e3e] e83ff5ffff call 00001382 ; call DD If you can't see this then you seem to just not have enough technical skill: The first seven steps of DD correctly simulated by HH call HH(DD,DD) to repeat these first seven steps. HH then simulates itself simulating DD until this second instance of DD calls another HH(DD,DD) to repeat these first seven steps again. -- 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-09 14:08 -0400 |
| Message-ID | <v44r2f$3egpa$8@i2pn2.org> |
| In reply to | #106765 |
On 6/9/24 8:21 AM, olcott wrote: > On 6/9/2024 1:33 AM, Fred. Zwarts wrote: >> Op 08.jun.2024 om 20:47 schreef olcott: >>> Before we can get to the behavior of the directly executed >>> DD(DD) we must first see that the Sipser approved criteria >>> have been met: >>> >>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>> If simulating halt decider H correctly simulates its input D >>> until H correctly determines that its simulated D would never >>> stop running unless aborted then >>> >>> H can abort its simulation of D and correctly report that D >>> specifies a non-halting sequence of configurations. >>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022> >>> >>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote: >>> > I don't think that is the shell game. PO really /has/ an H >>> > (it's trivial to do for this one case) that correctly determines >>> > that P(P) *would* never stop running *unless* aborted. >>> >>> Try to show how this DD correctly simulated by any HH ever >>> stops running without having its simulation aborted by HH. >> >> Stopping at your first error. So, we can focus on it. Your are asking >> a question that contradicts itself. > > In other words the best selling author of theory of > computation textbooks doesn't have a clue? Nope, you asked him a defective question, and he did his best. H can not have done a correct simulation, per the definitions in place, and abort its simulation. > >> A correct simulation of HH that aborts itself, >> should simulate up to the point where the simulated HH aborts. > > The outer HH always sees a longer execution trace than > the inner ones. Unless the outer one aborts none of them > abort. No, you are forgetting that simulation is not the reality, but an exploration of it. THe outer HH sees a longer execution trace then the simulated part of the inner one. "The inner one" would generally mean the execution of that inner one, (not an aborted simualation of it) and that, since it is the exact same algorithm and data, will see EXACTLY the same execution trace as the outer one saw when it interrupt its simulation. Your problem is you seem to have forgotten that simulation are just explorations of the reality of the execution, and not a reality of themselves. > >> That is logically impossible. So, either it is a correct simulation >> and then we see that the simulated HH aborts and returns, or the >> simulation is incorrect, because it assumes incorrectly that things >> that happen (abort) do not happen. >> A premature conclusion. >> >> > > _DD() > [00001e32] 55 push ebp ; Begin DD > [00001e33] 8bec mov ebp,esp > [00001e35] 51 push ecx > [00001e36] 8b4508 mov eax,[ebp+08] > [00001e39] 50 push eax ; push DD > [00001e3a] 8b4d08 mov ecx,[ebp+08] > [00001e3d] 51 push ecx ; push DD > [00001e3e] e83ff5ffff call 00001382 ; call DD > > If you can't see this then you seem to just not have > enough technical skill: > > The first seven steps of DD correctly simulated by HH call > HH(DD,DD) to repeat these first seven steps. Nope, becase the outer simulator, if simulating per your definition, won't simulate the input given to that simulated HH, but will simulate the CODE of HH as it simulates DD(DD). So that outer HH will NEVER see the actual address 00001E32 again. EVER. > > HH then simulates itself simulating DD until this second > instance of DD calls another HH(DD,DD) to repeat these first > seven steps again. > Which means you keep on changing what simulation you are looking at, which violates your definiton of simulation.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-09 09:13 -0500 |
| Message-ID | <v44da3$3i5jo$1@dont-email.me> |
| In reply to | #106754 |
On 6/9/2024 1:33 AM, Fred. Zwarts wrote:
> Op 08.jun.2024 om 20:47 schreef olcott:
>> Before we can get to the behavior of the directly executed
>> DD(DD) we must first see that the Sipser approved criteria
>> have been met:
>>
>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>> If simulating halt decider H correctly simulates its input D
>> until H correctly determines that its simulated D would never
>> stop running unless aborted then
>>
>> H can abort its simulation of D and correctly report that D
>> specifies a non-halting sequence of configurations.
>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>>
>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
>> > I don't think that is the shell game. PO really /has/ an H
>> > (it's trivial to do for this one case) that correctly determines
>> > that P(P) *would* never stop running *unless* aborted.
>>
>> Try to show how this DD correctly simulated by any HH ever
>> stops running without having its simulation aborted by HH.
>
> Stopping at your first error. So, we can focus on it. Your are asking a
> question that contradicts itself.
> A correct simulation of HH that aborts itself, should simulate up to the
> point where the simulated HH aborts. That is logically impossible. So,
> either it is a correct simulation and then we see that the simulated HH
> aborts and returns, or the simulation is incorrect, because it assumes
> incorrectly that things that happen (abort) do not happen.
> A premature conclusion.
>
>
I have a clearer explanation now that I have gone through
all of Mikko's posts: (you must know C to understand this)
typedef void (*ptr)(); // pointer to void function
void HHH(ptr P, ptr I)
{
P(I);
return;
}
void DDD(int (*x)())
{
HHH(x, x);
return;
}
int main()
{
HHH(DDD,DDD);
}
In the above Neither DDD nor HHH ever reach their own return
statement thus never halt.
When HHH is a simulating halt decider then HHH sees that
DDD correctly simulated by HHH cannot possibly reach its
own return statement, AKA
simulating halt decider HHH correctly simulates its input DDD
until HHH correctly determines that its simulated DDD would never
stop running unless aborted
--
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-09 14:08 -0400 |
| Message-ID | <v44r30$3egpa$9@i2pn2.org> |
| In reply to | #106776 |
On 6/9/24 10:13 AM, olcott wrote:
> On 6/9/2024 1:33 AM, Fred. Zwarts wrote:
>> Op 08.jun.2024 om 20:47 schreef olcott:
>>> Before we can get to the behavior of the directly executed
>>> DD(DD) we must first see that the Sipser approved criteria
>>> have been met:
>>>
>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>> If simulating halt decider H correctly simulates its input D
>>> until H correctly determines that its simulated D would never
>>> stop running unless aborted then
>>>
>>> H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>>>
>>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
>>> > I don't think that is the shell game. PO really /has/ an H
>>> > (it's trivial to do for this one case) that correctly determines
>>> > that P(P) *would* never stop running *unless* aborted.
>>>
>>> Try to show how this DD correctly simulated by any HH ever
>>> stops running without having its simulation aborted by HH.
>>
>> Stopping at your first error. So, we can focus on it. Your are asking
>> a question that contradicts itself.
>> A correct simulation of HH that aborts itself, should simulate up to
>> the point where the simulated HH aborts. That is logically impossible.
>> So, either it is a correct simulation and then we see that the
>> simulated HH aborts and returns, or the simulation is incorrect,
>> because it assumes incorrectly that things that happen (abort) do not
>> happen.
>> A premature conclusion.
>>
>>
>
> I have a clearer explanation now that I have gone through
> all of Mikko's posts: (you must know C to understand this)
>
> typedef void (*ptr)(); // pointer to void function
>
> void HHH(ptr P, ptr I)
> {
> P(I);
> return;
> }
>
> void DDD(int (*x)())
> {
> HHH(x, x);
> return;
> }
>
> int main()
> {
> HHH(DDD,DDD);
> }
>
> In the above Neither DDD nor HHH ever reach their own return
> statement thus never halt.
>
> When HHH is a simulating halt decider then HHH sees that
> DDD correctly simulated by HHH cannot possibly reach its
> own return statement, AKA
But by the above, it isn't. That is just par for your course, you like
to assume things are what they are not and don't bother to check.
That is why you are wrong so often, and your arguments just invalid
>
> simulating halt decider HHH correctly simulates its input DDD
> until HHH correctly determines that its simulated DDD would never
> stop running unless aborted
>
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-10 10:48 +0300 |
| Message-ID | <v46b4u$99o6$1@dont-email.me> |
| In reply to | #106776 |
On 2024-06-09 14:13:23 +0000, olcott said:
> On 6/9/2024 1:33 AM, Fred. Zwarts wrote:
>> Op 08.jun.2024 om 20:47 schreef olcott:
>>> Before we can get to the behavior of the directly executed
>>> DD(DD) we must first see that the Sipser approved criteria
>>> have been met:
>>>
>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>> If simulating halt decider H correctly simulates its input D
>>> until H correctly determines that its simulated D would never
>>> stop running unless aborted then
>>>
>>> H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>>>
>>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
>>> > I don't think that is the shell game. PO really /has/ an H
>>> > (it's trivial to do for this one case) that correctly determines
>>> > that P(P) *would* never stop running *unless* aborted.
>>>
>>> Try to show how this DD correctly simulated by any HH ever
>>> stops running without having its simulation aborted by HH.
>>
>> Stopping at your first error. So, we can focus on it. Your are asking a
>> question that contradicts itself.
>> A correct simulation of HH that aborts itself, should simulate up to
>> the point where the simulated HH aborts. That is logically impossible.
>> So, either it is a correct simulation and then we see that the
>> simulated HH aborts and returns, or the simulation is incorrect,
>> because it assumes incorrectly that things that happen (abort) do not
>> happen.
>> A premature conclusion.
>>
>>
>
> I have a clearer explanation now that I have gone through
> all of Mikko's posts: (you must know C to understand this)
>
> typedef void (*ptr)(); // pointer to void function
>
> void HHH(ptr P, ptr I)
> {
> P(I);
> return;
> }
>
> void DDD(int (*x)())
> {
> HHH(x, x);
> return;
> }
>
> int main()
> {
> HHH(DDD,DDD);
> }
>
> In the above Neither DDD nor HHH ever reach their own return
> statement thus never halt.
>
> When HHH is a simulating halt decider then HHH sees that
As the code above shows, HHH is not a simulating halt decider:
(a) HHH does not simulate, (b) HHH does not decide.
Consequently, you are talking about nothing.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-10 10:09 -0500 |
| Message-ID | <v474uv$ggn5$8@dont-email.me> |
| In reply to | #106870 |
On 6/10/2024 2:48 AM, Mikko wrote:
> On 2024-06-09 14:13:23 +0000, olcott said:
>
>> On 6/9/2024 1:33 AM, Fred. Zwarts wrote:
>>> Op 08.jun.2024 om 20:47 schreef olcott:
>>>> Before we can get to the behavior of the directly executed
>>>> DD(DD) we must first see that the Sipser approved criteria
>>>> have been met:
>>>>
>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>>> If simulating halt decider H correctly simulates its input D
>>>> until H correctly determines that its simulated D would never
>>>> stop running unless aborted then
>>>>
>>>> H can abort its simulation of D and correctly report that D
>>>> specifies a non-halting sequence of configurations.
>>>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>>>>
>>>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
>>>> > I don't think that is the shell game. PO really /has/ an H
>>>> > (it's trivial to do for this one case) that correctly determines
>>>> > that P(P) *would* never stop running *unless* aborted.
>>>>
>>>> Try to show how this DD correctly simulated by any HH ever
>>>> stops running without having its simulation aborted by HH.
>>>
>>> Stopping at your first error. So, we can focus on it. Your are asking
>>> a question that contradicts itself.
>>> A correct simulation of HH that aborts itself, should simulate up to
>>> the point where the simulated HH aborts. That is logically
>>> impossible. So, either it is a correct simulation and then we see
>>> that the simulated HH aborts and returns, or the simulation is
>>> incorrect, because it assumes incorrectly that things that happen
>>> (abort) do not happen.
>>> A premature conclusion.
>>>
>>>
>>
>> I have a clearer explanation now that I have gone through
>> all of Mikko's posts: (you must know C to understand this)
>>
>> typedef void (*ptr)(); // pointer to void function
>>
>> void HHH(ptr P, ptr I)
>> {
>> P(I);
>> return;
>> }
>>
>> void DDD(int (*x)())
>> {
>> HHH(x, x);
>> return;
>> }
>>
>> int main()
>> {
>> HHH(DDD,DDD);
>> }
>>
>> In the above Neither DDD nor HHH ever reach their own return
>> statement thus never halt.
>>
>> When HHH is a simulating halt decider then HHH sees that
>
> As the code above shows, HHH is not a simulating halt decider:
> (a) HHH does not simulate, (b) HHH does not decide.
> Consequently, you are talking about nothing.
>
Yes that is correct. I begin with ordinary infinite recursion.
If my reviewer does not understand that then they lack sufficient
technical competence to review my work.
After they first understand infinite recursion then I show how
infinite recursion is isomorphic to nested simulation.
--
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-10 23:32 -0400 |
| Message-ID | <v48gh0$3kcoe$1@i2pn2.org> |
| In reply to | #106893 |
On 6/10/24 11:09 AM, olcott wrote:
> On 6/10/2024 2:48 AM, Mikko wrote:
>> On 2024-06-09 14:13:23 +0000, olcott said:
>>
>>> On 6/9/2024 1:33 AM, Fred. Zwarts wrote:
>>>> Op 08.jun.2024 om 20:47 schreef olcott:
>>>>> Before we can get to the behavior of the directly executed
>>>>> DD(DD) we must first see that the Sipser approved criteria
>>>>> have been met:
>>>>>
>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>>>> If simulating halt decider H correctly simulates its input D
>>>>> until H correctly determines that its simulated D would never
>>>>> stop running unless aborted then
>>>>>
>>>>> H can abort its simulation of D and correctly report that D
>>>>> specifies a non-halting sequence of configurations.
>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>>>>>
>>>>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
>>>>> > I don't think that is the shell game. PO really /has/ an H
>>>>> > (it's trivial to do for this one case) that correctly determines
>>>>> > that P(P) *would* never stop running *unless* aborted.
>>>>>
>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>> stops running without having its simulation aborted by HH.
>>>>
>>>> Stopping at your first error. So, we can focus on it. Your are
>>>> asking a question that contradicts itself.
>>>> A correct simulation of HH that aborts itself, should simulate up to
>>>> the point where the simulated HH aborts. That is logically
>>>> impossible. So, either it is a correct simulation and then we see
>>>> that the simulated HH aborts and returns, or the simulation is
>>>> incorrect, because it assumes incorrectly that things that happen
>>>> (abort) do not happen.
>>>> A premature conclusion.
>>>>
>>>>
>>>
>>> I have a clearer explanation now that I have gone through
>>> all of Mikko's posts: (you must know C to understand this)
>>>
>>> typedef void (*ptr)(); // pointer to void function
>>>
>>> void HHH(ptr P, ptr I)
>>> {
>>> P(I);
>>> return;
>>> }
>>>
>>> void DDD(int (*x)())
>>> {
>>> HHH(x, x);
>>> return;
>>> }
>>>
>>> int main()
>>> {
>>> HHH(DDD,DDD);
>>> }
>>>
>>> In the above Neither DDD nor HHH ever reach their own return
>>> statement thus never halt.
>>>
>>> When HHH is a simulating halt decider then HHH sees that
>>
>> As the code above shows, HHH is not a simulating halt decider:
>> (a) HHH does not simulate, (b) HHH does not decide.
>> Consequently, you are talking about nothing.
>>
>
> Yes that is correct. I begin with ordinary infinite recursion.
> If my reviewer does not understand that then they lack sufficient
> technical competence to review my work.
>
> After they first understand infinite recursion then I show how
> infinite recursion is isomorphic to nested simulation.
>
Except that YOU fail to see the differences between the two, and so you
get stuck in your lies.
And, because you reuse names, it shows a proable intent to be deceptive.
It might be that YOU can't get in your mind the similarities without
reusing the names in that deceptive manner, but it just acts like a sign
of being deceptive to the rest of us.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-11 11:02 +0300 |
| Message-ID | <v490b8$v2i4$1@dont-email.me> |
| In reply to | #106893 |
On 2024-06-10 15:09:19 +0000, olcott said:
> On 6/10/2024 2:48 AM, Mikko wrote:
>> On 2024-06-09 14:13:23 +0000, olcott said:
>>
>>> On 6/9/2024 1:33 AM, Fred. Zwarts wrote:
>>>> Op 08.jun.2024 om 20:47 schreef olcott:
>>>>> Before we can get to the behavior of the directly executed
>>>>> DD(DD) we must first see that the Sipser approved criteria
>>>>> have been met:
>>>>>
>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>>>> If simulating halt decider H correctly simulates its input D
>>>>> until H correctly determines that its simulated D would never
>>>>> stop running unless aborted then
>>>>>
>>>>> H can abort its simulation of D and correctly report that D
>>>>> specifies a non-halting sequence of configurations.
>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>>>>>
>>>>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
>>>>> > I don't think that is the shell game. PO really /has/ an H
>>>>> > (it's trivial to do for this one case) that correctly determines
>>>>> > that P(P) *would* never stop running *unless* aborted.
>>>>>
>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>> stops running without having its simulation aborted by HH.
>>>>
>>>> Stopping at your first error. So, we can focus on it. Your are asking a
>>>> question that contradicts itself.
>>>> A correct simulation of HH that aborts itself, should simulate up to
>>>> the point where the simulated HH aborts. That is logically impossible.
>>>> So, either it is a correct simulation and then we see that the
>>>> simulated HH aborts and returns, or the simulation is incorrect,
>>>> because it assumes incorrectly that things that happen (abort) do not
>>>> happen.
>>>> A premature conclusion.
>>>>
>>>>
>>>
>>> I have a clearer explanation now that I have gone through
>>> all of Mikko's posts: (you must know C to understand this)
>>>
>>> typedef void (*ptr)(); // pointer to void function
>>>
>>> void HHH(ptr P, ptr I)
>>> {
>>> P(I);
>>> return;
>>> }
>>>
>>> void DDD(int (*x)())
>>> {
>>> HHH(x, x);
>>> return;
>>> }
>>>
>>> int main()
>>> {
>>> HHH(DDD,DDD);
>>> }
>>>
>>> In the above Neither DDD nor HHH ever reach their own return
>>> statement thus never halt.
>>>
>>> When HHH is a simulating halt decider then HHH sees that
>>
>> As the code above shows, HHH is not a simulating halt decider:
>> (a) HHH does not simulate, (b) HHH does not decide.
>> Consequently, you are talking about nothing.
>>
>
> Yes that is correct. I begin with ordinary infinite recursion.
> If my reviewer does not understand that then they lack sufficient
> technical competence to review my work.
>
> After they first understand infinite recursion then I show how
> infinite recursion is isomorphic to nested simulation.
To proove an isomorphism required much more effort that proving merely
what you need to prove. It is easier to prove a claim about recursive
calls and then transform that proof to a proof about nested simulation.
Other aspects of an isomorphism are not relevant so hardly worth of a
proof.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-11 12:24 -0500 |
| Subject | DDD correctly simulated by HH cannot possibly halt |
| Message-ID | <v4a192$157ic$4@dont-email.me> |
| In reply to | #106932 |
On 6/11/2024 3:02 AM, Mikko wrote:
> On 2024-06-10 15:09:19 +0000, olcott said:
>
>> On 6/10/2024 2:48 AM, Mikko wrote:
>>> On 2024-06-09 14:13:23 +0000, olcott said:
>>>
>>>> On 6/9/2024 1:33 AM, Fred. Zwarts wrote:
>>>>> Op 08.jun.2024 om 20:47 schreef olcott:
>>>>>> Before we can get to the behavior of the directly executed
>>>>>> DD(DD) we must first see that the Sipser approved criteria
>>>>>> have been met:
>>>>>>
>>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>>>>> If simulating halt decider H correctly simulates its input D
>>>>>> until H correctly determines that its simulated D would never
>>>>>> stop running unless aborted then
>>>>>>
>>>>>> H can abort its simulation of D and correctly report that D
>>>>>> specifies a non-halting sequence of configurations.
>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>>>>>>
>>>>>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
>>>>>> > I don't think that is the shell game. PO really /has/ an H
>>>>>> > (it's trivial to do for this one case) that correctly determines
>>>>>> > that P(P) *would* never stop running *unless* aborted.
>>>>>>
>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>> stops running without having its simulation aborted by HH.
>>>>>
>>>>> Stopping at your first error. So, we can focus on it. Your are
>>>>> asking a question that contradicts itself.
>>>>> A correct simulation of HH that aborts itself, should simulate up
>>>>> to the point where the simulated HH aborts. That is logically
>>>>> impossible. So, either it is a correct simulation and then we see
>>>>> that the simulated HH aborts and returns, or the simulation is
>>>>> incorrect, because it assumes incorrectly that things that happen
>>>>> (abort) do not happen.
>>>>> A premature conclusion.
>>>>>
>>>>>
>>>>
>>>> I have a clearer explanation now that I have gone through
>>>> all of Mikko's posts: (you must know C to understand this)
>>>>
>>>> typedef void (*ptr)(); // pointer to void function
>>>>
>>>> void HHH(ptr P, ptr I)
>>>> {
>>>> P(I);
>>>> return;
>>>> }
>>>>
>>>> void DDD(int (*x)())
>>>> {
>>>> HHH(x, x);
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> HHH(DDD,DDD);
>>>> }
>>>>
>>>> In the above Neither DDD nor HHH ever reach their own return
>>>> statement thus never halt.
>>>>
>>>> When HHH is a simulating halt decider then HHH sees that
>>>
>>> As the code above shows, HHH is not a simulating halt decider:
>>> (a) HHH does not simulate, (b) HHH does not decide.
>>> Consequently, you are talking about nothing.
>>>
>>
>> Yes that is correct. I begin with ordinary infinite recursion.
>> If my reviewer does not understand that then they lack sufficient
>> technical competence to review my work.
>>
>> After they first understand infinite recursion then I show how
>> infinite recursion is isomorphic to nested simulation.
>
> To proove an isomorphism required much more effort that proving merely
> what you need to prove. It is easier to prove a claim about recursive
> calls and then transform that proof to a proof about nested simulation.
> Other aspects of an isomorphism are not relevant so hardly worth of a
> proof.
>
void DDD(int (*x)())
{
HH(x, x);
}
_DDD()
[00001de2] 55 push ebp
[00001de3] 8bec mov ebp,esp
[00001de5] 8b4508 mov eax,[ebp+08]
[00001de8] 50 push eax ; push DDD
[00001de9] 8b4d08 mov ecx,[ebp+08]
[00001dec] 51 push ecx ; push DDD
[00001ded] e890f5ffff call 00001382 ; call HH
[00001df2] 83c408 add esp,+08
[00001df5] 5d pop ebp
[00001df6] c3 ret
Size in bytes:(0021) [00001df6]
DDD correctly simulated by HH cannot possibly reach its own
simulated "ret" instruction at [00001df6] and terminate normally
and no one can possibly show the detailed steps of how it could.
--
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-11 21:46 -0400 |
| Subject | Re: DDD correctly simulated by HH cannot possibly halt |
| Message-ID | <v4aukt$3nf9m$4@i2pn2.org> |
| In reply to | #106942 |
On 6/11/24 1:24 PM, olcott wrote:
> On 6/11/2024 3:02 AM, Mikko wrote:
>> On 2024-06-10 15:09:19 +0000, olcott said:
>>
>>> On 6/10/2024 2:48 AM, Mikko wrote:
>>>> On 2024-06-09 14:13:23 +0000, olcott said:
>>>>
>>>>> On 6/9/2024 1:33 AM, Fred. Zwarts wrote:
>>>>>> Op 08.jun.2024 om 20:47 schreef olcott:
>>>>>>> Before we can get to the behavior of the directly executed
>>>>>>> DD(DD) we must first see that the Sipser approved criteria
>>>>>>> have been met:
>>>>>>>
>>>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words
>>>>>>> 10/13/2022>
>>>>>>> If simulating halt decider H correctly simulates its input D
>>>>>>> until H correctly determines that its simulated D would never
>>>>>>> stop running unless aborted then
>>>>>>>
>>>>>>> H can abort its simulation of D and correctly report that D
>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim
>>>>>>> words10/13/2022>
>>>>>>>
>>>>>>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
>>>>>>> > I don't think that is the shell game. PO really /has/ an H
>>>>>>> > (it's trivial to do for this one case) that correctly determines
>>>>>>> > that P(P) *would* never stop running *unless* aborted.
>>>>>>>
>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>
>>>>>> Stopping at your first error. So, we can focus on it. Your are
>>>>>> asking a question that contradicts itself.
>>>>>> A correct simulation of HH that aborts itself, should simulate up
>>>>>> to the point where the simulated HH aborts. That is logically
>>>>>> impossible. So, either it is a correct simulation and then we see
>>>>>> that the simulated HH aborts and returns, or the simulation is
>>>>>> incorrect, because it assumes incorrectly that things that happen
>>>>>> (abort) do not happen.
>>>>>> A premature conclusion.
>>>>>>
>>>>>>
>>>>>
>>>>> I have a clearer explanation now that I have gone through
>>>>> all of Mikko's posts: (you must know C to understand this)
>>>>>
>>>>> typedef void (*ptr)(); // pointer to void function
>>>>>
>>>>> void HHH(ptr P, ptr I)
>>>>> {
>>>>> P(I);
>>>>> return;
>>>>> }
>>>>>
>>>>> void DDD(int (*x)())
>>>>> {
>>>>> HHH(x, x);
>>>>> return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> HHH(DDD,DDD);
>>>>> }
>>>>>
>>>>> In the above Neither DDD nor HHH ever reach their own return
>>>>> statement thus never halt.
>>>>>
>>>>> When HHH is a simulating halt decider then HHH sees that
>>>>
>>>> As the code above shows, HHH is not a simulating halt decider:
>>>> (a) HHH does not simulate, (b) HHH does not decide.
>>>> Consequently, you are talking about nothing.
>>>>
>>>
>>> Yes that is correct. I begin with ordinary infinite recursion.
>>> If my reviewer does not understand that then they lack sufficient
>>> technical competence to review my work.
>>>
>>> After they first understand infinite recursion then I show how
>>> infinite recursion is isomorphic to nested simulation.
>>
>> To proove an isomorphism required much more effort that proving merely
>> what you need to prove. It is easier to prove a claim about recursive
>> calls and then transform that proof to a proof about nested simulation.
>> Other aspects of an isomorphism are not relevant so hardly worth of a
>> proof.
>>
>
> void DDD(int (*x)())
> {
> HH(x, x);
> }
>
> _DDD()
> [00001de2] 55 push ebp
> [00001de3] 8bec mov ebp,esp
> [00001de5] 8b4508 mov eax,[ebp+08]
> [00001de8] 50 push eax ; push DDD
> [00001de9] 8b4d08 mov ecx,[ebp+08]
> [00001dec] 51 push ecx ; push DDD
> [00001ded] e890f5ffff call 00001382 ; call HH
> [00001df2] 83c408 add esp,+08
> [00001df5] 5d pop ebp
> [00001df6] c3 ret
> Size in bytes:(0021) [00001df6]
>
> DDD correctly simulated by HH cannot possibly reach its own
> simulated "ret" instruction at [00001df6] and terminate normally
> and no one can possibly show the detailed steps of how it could.
>
And the question still is why should we care.
Partial simulations do not, by themselves, prove non-halting behavior.
So, you are just diverting yourself from the task you claim to be
working on.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-12 10:20 +0300 |
| Subject | Re: DDD correctly simulated by HH cannot possibly halt |
| Message-ID | <v4bi7n$1htdn$1@dont-email.me> |
| In reply to | #106942 |
On 2024-06-11 17:24:50 +0000, olcott said:
> On 6/11/2024 3:02 AM, Mikko wrote:
>> On 2024-06-10 15:09:19 +0000, olcott said:
>>
>>> On 6/10/2024 2:48 AM, Mikko wrote:
>>>> On 2024-06-09 14:13:23 +0000, olcott said:
>>>>
>>>>> On 6/9/2024 1:33 AM, Fred. Zwarts wrote:
>>>>>> Op 08.jun.2024 om 20:47 schreef olcott:
>>>>>>> Before we can get to the behavior of the directly executed
>>>>>>> DD(DD) we must first see that the Sipser approved criteria
>>>>>>> have been met:
>>>>>>>
>>>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>>>>>> If simulating halt decider H correctly simulates its input D
>>>>>>> until H correctly determines that its simulated D would never
>>>>>>> stop running unless aborted then
>>>>>>>
>>>>>>> H can abort its simulation of D and correctly report that D
>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>>>>>>>
>>>>>>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
>>>>>>> > I don't think that is the shell game. PO really /has/ an H
>>>>>>> > (it's trivial to do for this one case) that correctly determines
>>>>>>> > that P(P) *would* never stop running *unless* aborted.
>>>>>>>
>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>
>>>>>> Stopping at your first error. So, we can focus on it. Your are asking a
>>>>>> question that contradicts itself.
>>>>>> A correct simulation of HH that aborts itself, should simulate up to
>>>>>> the point where the simulated HH aborts. That is logically impossible.
>>>>>> So, either it is a correct simulation and then we see that the
>>>>>> simulated HH aborts and returns, or the simulation is incorrect,
>>>>>> because it assumes incorrectly that things that happen (abort) do not
>>>>>> happen.
>>>>>> A premature conclusion.
>>>>>>
>>>>>>
>>>>>
>>>>> I have a clearer explanation now that I have gone through
>>>>> all of Mikko's posts: (you must know C to understand this)
>>>>>
>>>>> typedef void (*ptr)(); // pointer to void function
>>>>>
>>>>> void HHH(ptr P, ptr I)
>>>>> {
>>>>> P(I);
>>>>> return;
>>>>> }
>>>>>
>>>>> void DDD(int (*x)())
>>>>> {
>>>>> HHH(x, x);
>>>>> return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> HHH(DDD,DDD);
>>>>> }
>>>>>
>>>>> In the above Neither DDD nor HHH ever reach their own return
>>>>> statement thus never halt.
>>>>>
>>>>> When HHH is a simulating halt decider then HHH sees that
>>>>
>>>> As the code above shows, HHH is not a simulating halt decider:
>>>> (a) HHH does not simulate, (b) HHH does not decide.
>>>> Consequently, you are talking about nothing.
>>>>
>>>
>>> Yes that is correct. I begin with ordinary infinite recursion.
>>> If my reviewer does not understand that then they lack sufficient
>>> technical competence to review my work.
>>>
>>> After they first understand infinite recursion then I show how
>>> infinite recursion is isomorphic to nested simulation.
>>
>> To proove an isomorphism required much more effort that proving merely
>> what you need to prove. It is easier to prove a claim about recursive
>> calls and then transform that proof to a proof about nested simulation.
>> Other aspects of an isomorphism are not relevant so hardly worth of a
>> proof.
>>
>
> void DDD(int (*x)())
> {
> HH(x, x);
> }
>
> _DDD()
> [00001de2] 55 push ebp
> [00001de3] 8bec mov ebp,esp
> [00001de5] 8b4508 mov eax,[ebp+08]
> [00001de8] 50 push eax ; push DDD
> [00001de9] 8b4d08 mov ecx,[ebp+08]
> [00001dec] 51 push ecx ; push DDD
> [00001ded] e890f5ffff call 00001382 ; call HH
> [00001df2] 83c408 add esp,+08
> [00001df5] 5d pop ebp
> [00001df6] c3 ret
> Size in bytes:(0021) [00001df6]
>
> DDD correctly simulated by HH cannot possibly reach its own
> simulated "ret" instruction at [00001df6] and terminate normally
> and no one can possibly show the detailed steps of how it could.
You cannot prove that without restricting x.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-12 10:17 -0500 |
| Subject | Re: DDD correctly simulated by HH cannot possibly halt |
| Message-ID | <v4ce6f$1mi5i$3@dont-email.me> |
| In reply to | #106974 |
On 6/12/2024 2:20 AM, Mikko wrote:
> On 2024-06-11 17:24:50 +0000, olcott said:
>
>> On 6/11/2024 3:02 AM, Mikko wrote:
>>> On 2024-06-10 15:09:19 +0000, olcott said:
>>>
>>>> On 6/10/2024 2:48 AM, Mikko wrote:
>>>>> On 2024-06-09 14:13:23 +0000, olcott said:
>>>>>
>>>>>> On 6/9/2024 1:33 AM, Fred. Zwarts wrote:
>>>>>>> Op 08.jun.2024 om 20:47 schreef olcott:
>>>>>>>> Before we can get to the behavior of the directly executed
>>>>>>>> DD(DD) we must first see that the Sipser approved criteria
>>>>>>>> have been met:
>>>>>>>>
>>>>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words
>>>>>>>> 10/13/2022>
>>>>>>>> If simulating halt decider H correctly simulates its input D
>>>>>>>> until H correctly determines that its simulated D would never
>>>>>>>> stop running unless aborted then
>>>>>>>>
>>>>>>>> H can abort its simulation of D and correctly report that D
>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim
>>>>>>>> words10/13/2022>
>>>>>>>>
>>>>>>>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
>>>>>>>> > I don't think that is the shell game. PO really /has/ an H
>>>>>>>> > (it's trivial to do for this one case) that correctly determines
>>>>>>>> > that P(P) *would* never stop running *unless* aborted.
>>>>>>>>
>>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>
>>>>>>> Stopping at your first error. So, we can focus on it. Your are
>>>>>>> asking a question that contradicts itself.
>>>>>>> A correct simulation of HH that aborts itself, should simulate up
>>>>>>> to the point where the simulated HH aborts. That is logically
>>>>>>> impossible. So, either it is a correct simulation and then we see
>>>>>>> that the simulated HH aborts and returns, or the simulation is
>>>>>>> incorrect, because it assumes incorrectly that things that happen
>>>>>>> (abort) do not happen.
>>>>>>> A premature conclusion.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> I have a clearer explanation now that I have gone through
>>>>>> all of Mikko's posts: (you must know C to understand this)
>>>>>>
>>>>>> typedef void (*ptr)(); // pointer to void function
>>>>>>
>>>>>> void HHH(ptr P, ptr I)
>>>>>> {
>>>>>> P(I);
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> void DDD(int (*x)())
>>>>>> {
>>>>>> HHH(x, x);
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> HHH(DDD,DDD);
>>>>>> }
>>>>>>
>>>>>> In the above Neither DDD nor HHH ever reach their own return
>>>>>> statement thus never halt.
>>>>>>
>>>>>> When HHH is a simulating halt decider then HHH sees that
>>>>>
>>>>> As the code above shows, HHH is not a simulating halt decider:
>>>>> (a) HHH does not simulate, (b) HHH does not decide.
>>>>> Consequently, you are talking about nothing.
>>>>>
>>>>
>>>> Yes that is correct. I begin with ordinary infinite recursion.
>>>> If my reviewer does not understand that then they lack sufficient
>>>> technical competence to review my work.
>>>>
>>>> After they first understand infinite recursion then I show how
>>>> infinite recursion is isomorphic to nested simulation.
>>>
>>> To proove an isomorphism required much more effort that proving merely
>>> what you need to prove. It is easier to prove a claim about recursive
>>> calls and then transform that proof to a proof about nested simulation.
>>> Other aspects of an isomorphism are not relevant so hardly worth of a
>>> proof.
>>>
>>
>> void DDD(int (*x)())
>> {
>> HH(x, x);
>> }
>>
>> _DDD()
>> [00001de2] 55 push ebp
>> [00001de3] 8bec mov ebp,esp
>> [00001de5] 8b4508 mov eax,[ebp+08]
>> [00001de8] 50 push eax ; push DDD
>> [00001de9] 8b4d08 mov ecx,[ebp+08]
>> [00001dec] 51 push ecx ; push DDD
>> [00001ded] e890f5ffff call 00001382 ; call HH
>> [00001df2] 83c408 add esp,+08
>> [00001df5] 5d pop ebp
>> [00001df6] c3 ret
>> Size in bytes:(0021) [00001df6]
>>
>> DDD correctly simulated by HH cannot possibly reach its own
>> simulated "ret" instruction at [00001df6] and terminate normally
>> and no one can possibly show the detailed steps of how it could.
>
> You cannot prove that without restricting x.
>
x is merely a parameter to DDD and we are only talking about the
case where this parameter has the value of DDD AKA the halting
problem counter-example input.
There is no mapping from the input to HH(DDD,DDD) to
the behavior of the directly executed DDD(DDD) through
any sequence of finite string transformation rules.
All deciders are only required to compute the mapping
FROM THEIR INPUTS, the behavior of DDD(DDD) has no
mapping from the inputs to HH(DDD,DDD).
If I am wrong then a specific sequence of steps of
DDD correctly simulated by HH where DDD terminates
normally can be provided.
One can presume that HH must report on the behavior
of the directly executed DDD(DDD) yet when one is
required to show the steps of the computed mapping one fails.
Because deciders only compute the mapping from their
inputs then HH(DDD,DDD) is not allowed to report on
the behavior of the directly executed DDD(DDD) because
there is no mapping.
--
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 | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-15 15:03 +0300 |
| Subject | Re: DDD correctly simulated by HH cannot possibly halt |
| Message-ID | <v4jvv5$3evhe$1@dont-email.me> |
| In reply to | #106987 |
On 2024-06-12 15:17:34 +0000, olcott said:
> On 6/12/2024 2:20 AM, Mikko wrote:
>> On 2024-06-11 17:24:50 +0000, olcott said:
>>
>>> On 6/11/2024 3:02 AM, Mikko wrote:
>>>> On 2024-06-10 15:09:19 +0000, olcott said:
>>>>
>>>>> On 6/10/2024 2:48 AM, Mikko wrote:
>>>>>> On 2024-06-09 14:13:23 +0000, olcott said:
>>>>>>
>>>>>>> On 6/9/2024 1:33 AM, Fred. Zwarts wrote:
>>>>>>>> Op 08.jun.2024 om 20:47 schreef olcott:
>>>>>>>>> Before we can get to the behavior of the directly executed
>>>>>>>>> DD(DD) we must first see that the Sipser approved criteria
>>>>>>>>> have been met:
>>>>>>>>>
>>>>>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>>>>>>>> If simulating halt decider H correctly simulates its input D
>>>>>>>>> until H correctly determines that its simulated D would never
>>>>>>>>> stop running unless aborted then
>>>>>>>>>
>>>>>>>>> H can abort its simulation of D and correctly report that D
>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>>>>>>>>>
>>>>>>>>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
>>>>>>>>> > I don't think that is the shell game. PO really /has/ an H
>>>>>>>>> > (it's trivial to do for this one case) that correctly determines
>>>>>>>>> > that P(P) *would* never stop running *unless* aborted.
>>>>>>>>>
>>>>>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>>>>>> stops running without having its simulation aborted by HH.
>>>>>>>>
>>>>>>>> Stopping at your first error. So, we can focus on it. Your are asking a
>>>>>>>> question that contradicts itself.
>>>>>>>> A correct simulation of HH that aborts itself, should simulate up to
>>>>>>>> the point where the simulated HH aborts. That is logically impossible.
>>>>>>>> So, either it is a correct simulation and then we see that the
>>>>>>>> simulated HH aborts and returns, or the simulation is incorrect,
>>>>>>>> because it assumes incorrectly that things that happen (abort) do not
>>>>>>>> happen.
>>>>>>>> A premature conclusion.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> I have a clearer explanation now that I have gone through
>>>>>>> all of Mikko's posts: (you must know C to understand this)
>>>>>>>
>>>>>>> typedef void (*ptr)(); // pointer to void function
>>>>>>>
>>>>>>> void HHH(ptr P, ptr I)
>>>>>>> {
>>>>>>> P(I);
>>>>>>> return;
>>>>>>> }
>>>>>>>
>>>>>>> void DDD(int (*x)())
>>>>>>> {
>>>>>>> HHH(x, x);
>>>>>>> return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> HHH(DDD,DDD);
>>>>>>> }
>>>>>>>
>>>>>>> In the above Neither DDD nor HHH ever reach their own return
>>>>>>> statement thus never halt.
>>>>>>>
>>>>>>> When HHH is a simulating halt decider then HHH sees that
>>>>>>
>>>>>> As the code above shows, HHH is not a simulating halt decider:
>>>>>> (a) HHH does not simulate, (b) HHH does not decide.
>>>>>> Consequently, you are talking about nothing.
>>>>>>
>>>>>
>>>>> Yes that is correct. I begin with ordinary infinite recursion.
>>>>> If my reviewer does not understand that then they lack sufficient
>>>>> technical competence to review my work.
>>>>>
>>>>> After they first understand infinite recursion then I show how
>>>>> infinite recursion is isomorphic to nested simulation.
>>>>
>>>> To proove an isomorphism required much more effort that proving merely
>>>> what you need to prove. It is easier to prove a claim about recursive
>>>> calls and then transform that proof to a proof about nested simulation.
>>>> Other aspects of an isomorphism are not relevant so hardly worth of a
>>>> proof.
>>>>
>>>
>>> void DDD(int (*x)())
>>> {
>>> HH(x, x);
>>> }
>>>
>>> _DDD()
>>> [00001de2] 55 push ebp
>>> [00001de3] 8bec mov ebp,esp
>>> [00001de5] 8b4508 mov eax,[ebp+08]
>>> [00001de8] 50 push eax ; push DDD
>>> [00001de9] 8b4d08 mov ecx,[ebp+08]
>>> [00001dec] 51 push ecx ; push DDD
>>> [00001ded] e890f5ffff call 00001382 ; call HH
>>> [00001df2] 83c408 add esp,+08
>>> [00001df5] 5d pop ebp
>>> [00001df6] c3 ret
>>> Size in bytes:(0021) [00001df6]
>>>
>>> DDD correctly simulated by HH cannot possibly reach its own
>>> simulated "ret" instruction at [00001df6] and terminate normally
>>> and no one can possibly show the detailed steps of how it could.
>>
>> You cannot prove that without restricting x.
>>
>
> x is merely a parameter to DDD and we are only talking about the
> case where this parameter has the value of DDD AKA the halting
> problem counter-example input.
Your claim about DDD correctly simulated by HH wihtout that or
any other restriction on x.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-15 14:59 +0300 |
| Message-ID | <v4jvni$3etj9$1@dont-email.me> |
| In reply to | #106893 |
On 2024-06-10 15:09:19 +0000, olcott said:
> On 6/10/2024 2:48 AM, Mikko wrote:
>> On 2024-06-09 14:13:23 +0000, olcott said:
>>
>>> On 6/9/2024 1:33 AM, Fred. Zwarts wrote:
>>>> Op 08.jun.2024 om 20:47 schreef olcott:
>>>>> Before we can get to the behavior of the directly executed
>>>>> DD(DD) we must first see that the Sipser approved criteria
>>>>> have been met:
>>>>>
>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>>>> If simulating halt decider H correctly simulates its input D
>>>>> until H correctly determines that its simulated D would never
>>>>> stop running unless aborted then
>>>>>
>>>>> H can abort its simulation of D and correctly report that D
>>>>> specifies a non-halting sequence of configurations.
>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
>>>>>
>>>>> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
>>>>> > I don't think that is the shell game. PO really /has/ an H
>>>>> > (it's trivial to do for this one case) that correctly determines
>>>>> > that P(P) *would* never stop running *unless* aborted.
>>>>>
>>>>> Try to show how this DD correctly simulated by any HH ever
>>>>> stops running without having its simulation aborted by HH.
>>>>
>>>> Stopping at your first error. So, we can focus on it. Your are asking a
>>>> question that contradicts itself.
>>>> A correct simulation of HH that aborts itself, should simulate up to
>>>> the point where the simulated HH aborts. That is logically impossible.
>>>> So, either it is a correct simulation and then we see that the
>>>> simulated HH aborts and returns, or the simulation is incorrect,
>>>> because it assumes incorrectly that things that happen (abort) do not
>>>> happen.
>>>> A premature conclusion.
>>>>
>>>>
>>>
>>> I have a clearer explanation now that I have gone through
>>> all of Mikko's posts: (you must know C to understand this)
>>>
>>> typedef void (*ptr)(); // pointer to void function
>>>
>>> void HHH(ptr P, ptr I)
>>> {
>>> P(I);
>>> return;
>>> }
>>>
>>> void DDD(int (*x)())
>>> {
>>> HHH(x, x);
>>> return;
>>> }
>>>
>>> int main()
>>> {
>>> HHH(DDD,DDD);
>>> }
>>>
>>> In the above Neither DDD nor HHH ever reach their own return
>>> statement thus never halt.
>>>
>>> When HHH is a simulating halt decider then HHH sees that
>>
>> As the code above shows, HHH is not a simulating halt decider:
>> (a) HHH does not simulate, (b) HHH does not decide.
>> Consequently, you are talking about nothing.
>
> Yes that is correct.
Nice to see that you agree that you are talking obout nothing.
> I begin with ordinary infinite recursion.
> If my reviewer does not understand that then they lack sufficient
> technical competence to review my work.
I don't think you can infer so much from a failure to understand what
you are trying to say about nothing.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-10 00:17 -0500 |
| Message-ID | <v4628o$6ero$1@dont-email.me> |
| In reply to | #106754 |
On 6/9/2024 1:33 AM, Fred. Zwarts wrote: > Op 08.jun.2024 om 20:47 schreef olcott: >> Before we can get to the behavior of the directly executed >> DD(DD) we must first see that the Sipser approved criteria >> have been met: >> >> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >> If simulating halt decider H correctly simulates its input D >> until H correctly determines that its simulated D would never >> stop running unless aborted then >> >> H can abort its simulation of D and correctly report that D >> specifies a non-halting sequence of configurations. >> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022> >> >> On 10/14/2022 7:44 PM, Ben Bacarisse wrote: >> > I don't think that is the shell game. PO really /has/ an H >> > (it's trivial to do for this one case) that correctly determines >> > that P(P) *would* never stop running *unless* aborted. >> >> Try to show how this DD correctly simulated by any HH ever >> stops running without having its simulation aborted by HH. > > Stopping at your first error. So, we can focus on it. Your are asking a > question that contradicts itself. > A correct simulation of HH that aborts itself, should simulate up to the > point where the simulated HH aborts. That is logically impossible. So, > either it is a correct simulation and then we see that the simulated HH > aborts and returns, or the simulation is incorrect, because it assumes > incorrectly that things that happen (abort) do not happen. > A premature conclusion. > > *No one has verified the actual facts of this for THREE YEARS* *No one has verified the actual facts of this for THREE YEARS* *No one has verified the actual facts of this for THREE YEARS* On 5/29/2021 2:26 PM, olcott wrote: https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ THE ONLY POSSIBLE WAY for D simulated by H to have the same behavior as the directly executed D(D) is for the instructions of D to be incorrectly simulated by H (details provided below). _D() [00000cfc](01) 55 push ebp [00000cfd](02) 8bec mov ebp,esp [00000cff](03) 8b4508 mov eax,[ebp+08] [00000d02](01) 50 push eax ; push D [00000d03](03) 8b4d08 mov ecx,[ebp+08] [00000d06](01) 51 push ecx ; push D [00000d07](05) e800feffff call 00000b0c ; call H [00000d0c](03) 83c408 add esp,+08 [00000d0f](02) 85c0 test eax,eax [00000d11](02) 7404 jz 00000d17 [00000d13](02) 33c0 xor eax,eax [00000d15](02) eb05 jmp 00000d1c [00000d17](05) b801000000 mov eax,00000001 [00000d1c](01) 5d pop ebp [00000d1d](01) c3 ret Size in bytes:(0034) [00000d1d] In order for D simulated by H to have the same behavior as the directly executed D(D) H must ignore the instruction at machine address [00000d07]. *That is an incorrect simulation of D* H does not ignore that instruction and simulates itself simulating D. The simulated H outputs its own execution trace of D. -- 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 1 of 5 [1] 2 3 4 5 Next page →
Back to top | Article view | comp.theory
csiph-web