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 2 of 5 — ← Prev page 1 [2] 3 4 5 Next page →
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-10 09:09 +0200 |
| Message-ID | <v468qt$7uvj$1@dont-email.me> |
| In reply to | #106863 |
Op 10.jun.2024 om 07:17 schreef olcott:
> 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.
>
>
On 05.jun.2024 at 15:59 (CET) olcott proved that in the example
> int main()
> {
> Output("Input_Halts = ", HH(main,(ptr)0));
> }
main halts and HH reported a non-halting behaviour. This means that when
HH is used as a test for halting, it produces a false negative.
Olcott is rather silent about this result, probably, because in this
case he can not make a difference between the direct execution and the
simulation. In the D case he argues that the order of D and H makes a
difference. When D starts and calls H would be different from when H
starts and simulates D. In the above example, it is not possible to
change the order.
Since olcott himself has proven that HH produces a false negative, why
does he continue to claim that there should be a difference between
direct execution and simulation? This is again a false negative.
HH, nor H can be used as a test for halting of a program, at best as a
test for halting of olcott's simulator, but is not interesting for most
people.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-10 08:52 -0500 |
| Message-ID | <v470f0$fv9v$1@dont-email.me> |
| In reply to | #106867 |
On 6/10/2024 2:09 AM, Fred. Zwarts wrote:
> Op 10.jun.2024 om 07:17 schreef olcott:
>> 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.
>>
>>
> On 05.jun.2024 at 15:59 (CET) olcott proved that in the example
>
> > int main()
> > {
> > Output("Input_Halts = ", HH(main,(ptr)0));
> > }
>
> main halts and HH reported a non-halting behaviour. This means that when
> HH is used as a test for halting, it produces a false negative.
>
I just proved that D correctly simulated by H has different
behavior than the directly executed D(D) and you ignored it.
--
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 | joes <noreply@example.com> |
|---|---|
| Date | 2024-06-10 15:35 +0000 |
| Message-ID | <v476go$3ipmi$4@i2pn2.org> |
| In reply to | #106882 |
Am Mon, 10 Jun 2024 08:52:32 -0500 schrieb olcott:
> On 6/10/2024 2:09 AM, Fred. Zwarts wrote:
>> Op 10.jun.2024 om 07:17 schreef olcott:
>>> On 6/9/2024 1:33 AM, Fred. Zwarts wrote:
>>>> Op 08.jun.2024 om 20:47 schreef olcott:
>> On 05.jun.2024 at 15:59 (CET) olcott proved that in the example
>> > int main()
>> > {
>> > Output("Input_Halts = ", HH(main,(ptr)0));
>> > }
>> main halts and HH reported a non-halting behaviour. This means that
>> when HH is used as a test for halting, it produces a false negative.
>>
> I just proved that D simulated by H has different behavior
> than the directly executed D(D) and you ignored it.
A simulation must have the same behaviour.
--
joes
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-10 10:39 -0500 |
| Subject | Proof that D correctly simulated by H has different behavior than D(D) |
| Message-ID | <v476nl$ggn5$14@dont-email.me> |
| In reply to | #106900 |
On 6/10/2024 10:35 AM, joes wrote:
> A simulation must have the same behaviour.
>
[D correctly simulated by H proved 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*
*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.
The directly executed D(D) reaps the benefit of D correctly
simulated by H proving that *its input never halts*
Begin Local Halt Decider Simulation at Machine Address:cfc
..[00000cfc][00211839][0021183d](01) 55 push ebp
..[00000cfd][00211839][0021183d](02) 8bec mov ebp,esp
..[00000cff][00211839][0021183d](03) 8b4508 mov eax,[ebp+08]
..[00000d02][00211835][00000cfc](01) 50 push eax ; push D
..[00000d03][00211835][00000cfc](03) 8b4d08 mov ecx,[ebp+08]
..[00000d06][00211831][00000cfc](01) 51 push ecx ; push D
..[00000d07][0021182d][00000d0c](05) e800feffff call 00000b0c ; call H
This call to H is simulated H.
We can tell that it is the simulated H is providing this
trace because it has a different virtual machine stack.
The simulated H derives this execution trace of D:
machine stack stack machine assembly
address address data code language
======== ======== ======== =============== =============
..[00000cfc][0025c261][0025c265](01) 55 push ebp
..[00000cfd][0025c261][0025c265](02) 8bec mov ebp,esp
..[00000cff][0025c261][0025c265](03) 8b4508 mov eax,[ebp+08]
..[00000d02][0025c25d][00000cfc](01) 50 push eax ; push D
..[00000d03][0025c25d][00000cfc](03) 8b4d08 mov ecx,[ebp+08]
..[00000d06][0025c259][00000cfc](01) 51 push ecx ; push D
..[00000d07][0025c255][00000d0c](05) e800feffff call 00000b0c ; call H
Infinitely Nested Simulation Detected Simulation Stopped
Because the H(D,D) that D(D) calls correctly recognizes the its input
DOES NOT HALT, it correctly aborts the simulation of this input causing
the directly executed D(D) to halt.
I proved that D simulated by H can only have the same behavior as the
directly executed D(D) when D is simulated by H incorrectly.
This requires D simulated by H to skip over the machine address
[00000d07] and not call H(D,D) to simulate itself again.
D simulated by H does not do that. It simulates itself simulating 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]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-11 21:59 -0400 |
| Subject | Re: Proof that D correctly simulated by H has different behavior than D(D) |
| Message-ID | <v4ave1$3nf9n$1@i2pn2.org> |
| In reply to | #106902 |
On 6/10/24 11:39 AM, olcott wrote: > On 6/10/2024 10:35 AM, joes wrote: >> A simulation must have the same behaviour. >> > > [D correctly simulated by H proved 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* > *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). The only way for H to correctly simulate the input is to simulate the call H (and following) exactly like the direct execution did. > > _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* No, it must SIMULATE that instruction, EXACTLY like the processor would execute it, and then continue simulating the code of H. > > H does not ignore that instruction and simulates itself simulating D. > The simulated H outputs its own execution trace of D. No, it simulates the instructions the simulator it is supposed to be simiulating is simulating. H is incorrect as it isn't simulating the actual x86 instructons presented ot it. It has "skipped" to a different execution environment, in contadiction to the definition. > > The directly executed D(D) reaps the benefit of D correctly > simulated by H proving that *its input never halts* No, it has reapd the benefit of H INCORRECTLY simulating the input, and using unsound logic to incorrectly determine the behavior of the input. > > Begin Local Halt Decider Simulation at Machine Address:cfc > ..[00000cfc][00211839][0021183d](01) 55 push ebp > ..[00000cfd][00211839][0021183d](02) 8bec mov ebp,esp > ..[00000cff][00211839][0021183d](03) 8b4508 mov eax,[ebp+08] > ..[00000d02][00211835][00000cfc](01) 50 push eax ; push D > ..[00000d03][00211835][00000cfc](03) 8b4d08 mov ecx,[ebp+08] > ..[00000d06][00211831][00000cfc](01) 51 push ecx ; push D > ..[00000d07][0021182d][00000d0c](05) e800feffff call 00000b0c ; call H > This call to H is simulated H. > We can tell that it is the simulated H is providing this > trace because it has a different virtual machine stack. > The simulated H derives this execution trace of D: And thus isn't what the top level H is supposed to have done. WHere in the x86 instruction specificatin do you find this behavior specified. Your ignoring of all these comments, just proves that you understand this is incorrect, but you realize you need to push this LIE to try to push your FALSE IDEAS forward. > > machine stack stack machine assembly > address address data code language > ======== ======== ======== =============== ============= > ..[00000cfc][0025c261][0025c265](01) 55 push ebp > ..[00000cfd][0025c261][0025c265](02) 8bec mov ebp,esp > ..[00000cff][0025c261][0025c265](03) 8b4508 mov eax,[ebp+08] > ..[00000d02][0025c25d][00000cfc](01) 50 push eax ; push D > ..[00000d03][0025c25d][00000cfc](03) 8b4d08 mov ecx,[ebp+08] > ..[00000d06][0025c259][00000cfc](01) 51 push ecx ; push D > ..[00000d07][0025c255][00000d0c](05) e800feffff call 00000b0c ; call H > Infinitely Nested Simulation Detected Simulation Stopped > > Because the H(D,D) that D(D) calls correctly recognizes the its input > DOES NOT HALT, it correctly aborts the simulation of this input causing > the directly executed D(D) to halt. Except that its input DOES Halt, so you are just showing that in YOUR LOGIC, it is ok to claim false answer are correct and that halting prograrm are non-halting. You are just living the LIAR Paradox. > > I proved that D simulated by H can only have the same behavior as the > directly executed D(D) when D is simulated by H incorrectly. Nope, you have proven that H doesn't correctly simulate its input. Prehaps because you just don't understand the meaning of the word "Correct" because you don't understand what "Truth" means. > > This requires D simulated by H to skip over the machine address > [00000d07] and not call H(D,D) to simulate itself again. > D simulated by H does not do that. It simulates itself simulating D. > Why do you say that? All you are doing is proving that H incorrectly simulates its input, as it never ACTUALLY simulated the call H, and then treced the code OF H that it saw, instead it traced that code that the H it is supposed to be simulating saw, which means it shifted into a world of fantasy and make-beleive.
[toc] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-10 21:15 +0200 |
| Message-ID | <v47jd2$isl9$1@dont-email.me> |
| In reply to | #106882 |
Op 10.jun.2024 om 15:52 schreef olcott:
> On 6/10/2024 2:09 AM, Fred. Zwarts wrote:
>> Op 10.jun.2024 om 07:17 schreef olcott:
>>> 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.
>>>
>>>
>> On 05.jun.2024 at 15:59 (CET) olcott proved that in the example
>>
>> > int main()
>> > {
>> > Output("Input_Halts = ", HH(main,(ptr)0));
>> > }
>>
>> main halts and HH reported a non-halting behaviour. This means that
>> when HH is used as a test for halting, it produces a false negative.
>>
>
> I just proved that D correctly simulated by H has different
> behavior than the directly executed D(D) and you ignored it.
>
>
There is no D in the example where your proved that HH produces a false
negative.
So, I can repeat what you removed:
Olcott is rather silent about this result, probably, because in this
case he can not make a difference between the direct execution and the
simulation. In the D case he argues that the order of D and H makes a
difference. When D starts and calls H would be different from when H
starts and simulates D. In the above example, it is not possible to
change the order.
Since olcott himself has proven that HH produces a false negative, why
does he continue to claim that there should be a difference between
direct execution and simulation? This is again a false negative.
HH, nor H can be used as a test for halting of a program, at best as a
test for halting of olcott's simulator, but is not interesting for most
people.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-11 21:48 -0400 |
| Message-ID | <v4auoo$3nf9m$5@i2pn2.org> |
| In reply to | #106882 |
On 6/10/24 9:52 AM, olcott wrote:
> On 6/10/2024 2:09 AM, Fred. Zwarts wrote:
>> Op 10.jun.2024 om 07:17 schreef olcott:
>>> 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.
>>>
>>>
>> On 05.jun.2024 at 15:59 (CET) olcott proved that in the example
>>
>> > int main()
>> > {
>> > Output("Input_Halts = ", HH(main,(ptr)0));
>> > }
>>
>> main halts and HH reported a non-halting behaviour. This means that
>> when HH is used as a test for halting, it produces a false negative.
>>
>
> I just proved that D correctly simulated by H has different
> behavior than the directly executed D(D) and you ignored it.
>
>
Nope. You just proved that your H doesn't correct simulatie its input,
because it doesn't correctly simulate the CALL H instruction.
The CALL H innstruction, to be correctly simulated, must be followed by
a simulation of the instructions that follow.
SInce that ISN'T what H did, at least per your listing, it just never
did a correct simulation.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-10 14:21 -0500 |
| Subject | Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) |
| Message-ID | <v47joj$je45$1@dont-email.me> |
| In reply to | #106867 |
On 6/10/2024 2:09 AM, Fred. Zwarts wrote:
> Op 10.jun.2024 om 07:17 schreef olcott:
>> 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.
>>
>>
> On 05.jun.2024 at 15:59 (CET) olcott proved that in the example
>
> > int main()
> > {
> > Output("Input_Halts = ", HH(main,(ptr)0));
> > }
>
> main halts and HH reported a non-halting behaviour.
I cannot and will not tolerate the strawman deception
change-the-subject fake rebuttal.
*I just proved that D correctly simulated by H has different*
*behavior than the directly executed D(D) and you ignored it*
--
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 | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-10 21:41 +0200 |
| Subject | Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) |
| Message-ID | <v47kt3$jhs8$1@dont-email.me> |
| In reply to | #106910 |
Op 10.jun.2024 om 21:21 schreef olcott:
> On 6/10/2024 2:09 AM, Fred. Zwarts wrote:
>> Op 10.jun.2024 om 07:17 schreef olcott:
>>> 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.
>>>
>>>
>> On 05.jun.2024 at 15:59 (CET) olcott proved that in the example
>>
>> > int main()
>> > {
>> > Output("Input_Halts = ", HH(main,(ptr)0));
>> > }
>>
>> main halts and HH reported a non-halting behaviour.
>
> I cannot and will not tolerate the strawman deception
> change-the-subject fake rebuttal.
>
That is the easiest way to ignore that it is just a proven false
negative: Remove the proof and claim that it is a change of subject.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-10 14:47 -0500 |
| Subject | Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) |
| Message-ID | <v47l92$je45$2@dont-email.me> |
| In reply to | #106911 |
On 6/10/2024 2:41 PM, Fred. Zwarts wrote: > > That is the easiest way to ignore that it is just a proven false > negative: Remove the proof and claim that it is a change of subject. *You did not prove that this is false you only ignored it* *You did not prove that this is false you only ignored it* *You did not prove that this is false you only ignored it* D correctly simulated by H proved 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* *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]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-11 09:21 +0200 |
| Subject | Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) |
| Message-ID | <v48tt4$tqad$1@dont-email.me> |
| In reply to | #106912 |
Op 10.jun.2024 om 21:47 schreef olcott: > On 6/10/2024 2:41 PM, Fred. Zwarts wrote: >> >> That is the easiest way to ignore that it is just a proven false >> negative: Remove the proof and claim that it is a change of subject. > > *You did not prove that this is false you only ignored it* > *You did not prove that this is false you only ignored it* > *You did not prove that this is false you only ignored it* > > D correctly simulated by H proved 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* > *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). Proven false. The direct execution does not ignore the call to H. So, to get the same behaviour, the simulation should also simulate the call. The problem is that H is required to halt and return from the call, but your H does not return as required. It can't, because it is prematurely aborted. This proves that a simulation is unable to simulate itself up to the end. This is what causes the false negatives. > > _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] Olcott has shown this and similar code, both in C as in x86 code for several years now. He was never able to prove the claim that it never reaches past the call at 00000d07. He thinks that he needs an expert in C or x86 to give the proof. So he has been begging desperately for years in several newsgroups if an expert can show the proof. This has never resulted in a proof. In fact most reactions from the experts are that such a proof is impossible because the requirements for H are unclear. Olcott wants contradicting requirements for H. At the one hand he wants H to halt and, therefore, to return to its caller, at the other hand he wants a proof that H, called at 0000d07 does not return to its caller. It is a great puzzle for me why he keeps believing in these contradictory properties of H. If he could prove that the call at 0000d07 does not return, he would prove at the same time that H is not a halting function, violating its requirement. My interest is no longer in the computation theory behind this question, but in the psychological aspect. How is it possible that somewhat wants to prove that a H with contradictory properties exists? The only reason I can think of, is that he has spent so many years in this subject, that he is unable to see the truth. He is unable to read and to grasp the proof and stays in rebuttal mode, without even considering for one moment that he could be wrong.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-11 12:07 -0500 |
| Subject | D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4a07r$157ic$1@dont-email.me> |
| In reply to | #106925 |
On 6/11/2024 2:21 AM, Fred. Zwarts wrote:
> Op 10.jun.2024 om 21:47 schreef olcott:
>> 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).
>
> Proven false. The direct execution does not ignore the call to H.
Yes that is the second big mistake that I am aware that I made
within the last year.
When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
The other big mistake was what I said happens when Linz H is
applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I forgot what I said and I forgot what the
correct answer was. I do remember this is was my big mistake.
No one has ever shown any actual error with my analysis of embedded_H
applied to ⟨Ĥ⟩ ⟨Ĥ⟩. It is a verified fact that is over everyone's head
besides mine that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H cannot
possibly reach its own simulated final state of ⟨Ĥ.qn⟩.
Everyone assumes that I must be wrong and only have dogma to base
this assumption on. I have reasoning to prove that they are wrong
yet this reasoning is over their heads.
I have made isomorphic reasoning 100% concrete with this example
and every has simply ignored this reasoning 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*
*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
_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]
It is impossible for D correctly simulated by H to ever reach
its simulated final state at its own machine address [00000d1d].
People disagree with this by changing the subject to D not simulated
by H as all. They have been indoctrinated into believing that this
strawman deception is correct yet
cannot possibly show the detailed steps of how D correctly simulated
by H can possibly reach its own simulated machine address of [00000d1d].
*Here are the steps that prove that I am correct*
(1) Executed H simulates the first seven instructions of D.
(2) Simulated D calls simulated H(D,D) to simulate itself again.
(3) Simulated H simulates the first seven instructions of simulated
simulated D.
(4) Simulated simulated D simulated by simulated H calls
simulated simulated H(D,D) to simulate itself again.
*HERE ARE ALL OF CONCRETE DETAILS OF THAT*
*Begin Local Halt Decider Simulation at Machine Address:cfc*
[00000cfc][00211839][0021183d](01) 55 push ebp ; begin D
[00000cfd][00211839][0021183d](02) 8bec mov ebp,esp
[00000cff][00211839][0021183d](03) 8b4508 mov eax,[ebp+08]
[00000d02][00211835][00000cfc](01) 50 push eax ; push D
[00000d03][00211835][00000cfc](03) 8b4d08 mov ecx,[ebp+08]
[00000d06][00211831][00000cfc](01) 51 push ecx ; push D
[00000d07][0021182d][00000d0c](05) e800feffff call 00000b0c ; call H
*This call to H is simulated by directly executed H*
machine stack stack machine assembly
address address data code language
======== ======== ======== =============== =============
[00000cfc][0025c261][0025c265](01) 55 push ebp ; begin D
[00000cfd][0025c261][0025c265](02) 8bec mov ebp,esp
[00000cff][0025c261][0025c265](03) 8b4508 mov eax,[ebp+08]
[00000d02][0025c25d][00000cfc](01) 50 push eax ; push D
[00000d03][0025c25d][00000cfc](03) 8b4d08 mov ecx,[ebp+08]
[00000d06][0025c259][00000cfc](01) 51 push ecx ; push D
[00000d07][0025c255][00000d0c](05) e800feffff call 00000b0c ; call H
*This call to H would be simulated by simulated executed H*
*Infinitely Nested Simulation Detected Simulation Stopped*
--
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 | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-12 08:18 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4beis$1h0p6$1@dont-email.me> |
| In reply to | #106939 |
Op 11.jun.2024 om 19:07 schreef olcott: > On 6/11/2024 2:21 AM, Fred. Zwarts wrote: >> Op 10.jun.2024 om 21:47 schreef olcott: >>> 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). >> >> Proven false. The direct execution does not ignore the call to H. > > Yes that is the second big mistake that I am aware that I made > within the last year. > > When Ĥ is applied to ⟨Ĥ⟩ > Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ > Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn > > The other big mistake was what I said happens when Linz H is > applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I forgot what I said and I forgot what the > correct answer was. I do remember this is was my big mistake. > > No one has ever shown any actual error with my analysis of embedded_H > applied to ⟨Ĥ⟩ ⟨Ĥ⟩. It is a verified fact that is over everyone's head > besides mine that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H cannot > possibly reach its own simulated final state of ⟨Ĥ.qn⟩. > > Everyone assumes that I must be wrong and only have dogma to base > this assumption on. I have reasoning to prove that they are wrong > yet this reasoning is over their heads. > > I have made isomorphic reasoning 100% concrete with this example > and every has simply ignored this reasoning 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* > *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 > > _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] > > It is impossible for D correctly simulated by H to ever reach > its simulated final state at its own machine address [00000d1d]. > > People disagree with this by changing the subject to D not simulated > by H as all. They have been indoctrinated into believing that this > strawman deception is correct yet > > cannot possibly show the detailed steps of how D correctly simulated > by H can possibly reach its own simulated machine address of [00000d1d]. > *Here are the steps that prove that I am correct* > > (1) Executed H simulates the first seven instructions of D. > > (2) Simulated D calls simulated H(D,D) to simulate itself again. > > (3) Simulated H simulates the first seven instructions of simulated > simulated D. > > (4) Simulated simulated D simulated by simulated H calls > simulated simulated H(D,D) to simulate itself again. > > *HERE ARE ALL OF CONCRETE DETAILS OF THAT* > *Begin Local Halt Decider Simulation at Machine Address:cfc* > [00000cfc][00211839][0021183d](01) 55 push ebp ; begin D > [00000cfd][00211839][0021183d](02) 8bec mov ebp,esp > [00000cff][00211839][0021183d](03) 8b4508 mov eax,[ebp+08] > [00000d02][00211835][00000cfc](01) 50 push eax ; push D > [00000d03][00211835][00000cfc](03) 8b4d08 mov ecx,[ebp+08] > [00000d06][00211831][00000cfc](01) 51 push ecx ; push D > [00000d07][0021182d][00000d0c](05) e800feffff call 00000b0c ; call H > *This call to H is simulated by directly executed H* > > machine stack stack machine assembly > address address data code language > ======== ======== ======== =============== ============= > [00000cfc][0025c261][0025c265](01) 55 push ebp ; begin D > [00000cfd][0025c261][0025c265](02) 8bec mov ebp,esp > [00000cff][0025c261][0025c265](03) 8b4508 mov eax,[ebp+08] > [00000d02][0025c25d][00000cfc](01) 50 push eax ; push D > [00000d03][0025c25d][00000cfc](03) 8b4d08 mov ecx,[ebp+08] > [00000d06][0025c259][00000cfc](01) 51 push ecx ; push D > [00000d07][0025c255][00000d0c](05) e800feffff call 00000b0c ; call H > *This call to H would be simulated by simulated executed H* > *Infinitely Nested Simulation Detected Simulation Stopped* > > There is no infinite nested simulation detected, because the simulation is aborted prematurely. It is just an incorrect simulation, because H is unable to simulate itself up to the abort. This shows that trying to simulate H by itself is a bad idea, because it will never reach the crucial part of H, where it aborts the simulation.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-12 09:47 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4cceu$1mi5i$2@dont-email.me> |
| In reply to | #106971 |
On 6/12/2024 1:18 AM, Fred. Zwarts wrote: > Op 11.jun.2024 om 19:07 schreef olcott: >> On 6/11/2024 2:21 AM, Fred. Zwarts wrote: >>> Op 10.jun.2024 om 21:47 schreef olcott: >>>> 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). >>> >>> Proven false. The direct execution does not ignore the call to H. >> >> Yes that is the second big mistake that I am aware that I made >> within the last year. >> >> When Ĥ is applied to ⟨Ĥ⟩ >> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >> >> The other big mistake was what I said happens when Linz H is >> applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I forgot what I said and I forgot what the >> correct answer was. I do remember this is was my big mistake. >> >> No one has ever shown any actual error with my analysis of embedded_H >> applied to ⟨Ĥ⟩ ⟨Ĥ⟩. It is a verified fact that is over everyone's head >> besides mine that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H cannot >> possibly reach its own simulated final state of ⟨Ĥ.qn⟩. >> >> Everyone assumes that I must be wrong and only have dogma to base >> this assumption on. I have reasoning to prove that they are wrong >> yet this reasoning is over their heads. >> >> I have made isomorphic reasoning 100% concrete with this example >> and every has simply ignored this reasoning 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* >> *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 >> >> _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] >> >> It is impossible for D correctly simulated by H to ever reach >> its simulated final state at its own machine address [00000d1d]. >> >> People disagree with this by changing the subject to D not simulated >> by H as all. They have been indoctrinated into believing that this >> strawman deception is correct yet >> >> cannot possibly show the detailed steps of how D correctly simulated >> by H can possibly reach its own simulated machine address of [00000d1d]. >> *Here are the steps that prove that I am correct* >> >> (1) Executed H simulates the first seven instructions of D. >> >> (2) Simulated D calls simulated H(D,D) to simulate itself again. >> >> (3) Simulated H simulates the first seven instructions of simulated >> simulated D. >> >> (4) Simulated simulated D simulated by simulated H calls >> simulated simulated H(D,D) to simulate itself again. >> >> *HERE ARE ALL OF CONCRETE DETAILS OF THAT* >> *Begin Local Halt Decider Simulation at Machine Address:cfc* >> [00000cfc][00211839][0021183d](01) 55 push ebp ; begin D >> [00000cfd][00211839][0021183d](02) 8bec mov ebp,esp >> [00000cff][00211839][0021183d](03) 8b4508 mov eax,[ebp+08] >> [00000d02][00211835][00000cfc](01) 50 push eax ; push D >> [00000d03][00211835][00000cfc](03) 8b4d08 mov ecx,[ebp+08] >> [00000d06][00211831][00000cfc](01) 51 push ecx ; push D >> [00000d07][0021182d][00000d0c](05) e800feffff call 00000b0c ; call H >> *This call to H is simulated by directly executed H* >> >> machine stack stack machine assembly >> address address data code language >> ======== ======== ======== =============== ============= >> [00000cfc][0025c261][0025c265](01) 55 push ebp ; begin D >> [00000cfd][0025c261][0025c265](02) 8bec mov ebp,esp >> [00000cff][0025c261][0025c265](03) 8b4508 mov eax,[ebp+08] >> [00000d02][0025c25d][00000cfc](01) 50 push eax ; push D >> [00000d03][0025c25d][00000cfc](03) 8b4d08 mov ecx,[ebp+08] >> [00000d06][0025c259][00000cfc](01) 51 push ecx ; push D >> [00000d07][0025c255][00000d0c](05) e800feffff call 00000b0c ; call H >> *This call to H would be simulated by simulated executed H* >> *Infinitely Nested Simulation Detected Simulation Stopped* >> >> > > There is no infinite nested simulation detected, If I am wrong then a specific sequence of steps of D correctly simulated by H where D terminates normally can be provided. Every attempt of rebuttal of this only had pure bluster and no actual sequence of steps as its basis. If this cannot be provided then that proves that there is no sequence of finite string transformation rules that derives the behavior of the directly executed D(D) from the input to H(D,D). This proves that when simulating halt decider H(D,D) computes the mapping from its inputs the behavior of the directly executed D(D) is proven to be irrelevant because there is no mapping that reaches this behavior. -- 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 | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-12 20:19 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4corm$1p0h0$1@dont-email.me> |
| In reply to | #106986 |
Op 12.jun.2024 om 16:47 schreef olcott: > On 6/12/2024 1:18 AM, Fred. Zwarts wrote: >> Op 11.jun.2024 om 19:07 schreef olcott: >>> On 6/11/2024 2:21 AM, Fred. Zwarts wrote: >>>> Op 10.jun.2024 om 21:47 schreef olcott: >>>>> 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). >>>> >>>> Proven false. The direct execution does not ignore the call to H. >>> >>> Yes that is the second big mistake that I am aware that I made >>> within the last year. >>> >>> When Ĥ is applied to ⟨Ĥ⟩ >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>> >>> The other big mistake was what I said happens when Linz H is >>> applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I forgot what I said and I forgot what the >>> correct answer was. I do remember this is was my big mistake. >>> >>> No one has ever shown any actual error with my analysis of embedded_H >>> applied to ⟨Ĥ⟩ ⟨Ĥ⟩. It is a verified fact that is over everyone's head >>> besides mine that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H cannot >>> possibly reach its own simulated final state of ⟨Ĥ.qn⟩. >>> >>> Everyone assumes that I must be wrong and only have dogma to base >>> this assumption on. I have reasoning to prove that they are wrong >>> yet this reasoning is over their heads. >>> >>> I have made isomorphic reasoning 100% concrete with this example >>> and every has simply ignored this reasoning 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* >>> *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 >>> >>> _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] >>> >>> It is impossible for D correctly simulated by H to ever reach >>> its simulated final state at its own machine address [00000d1d]. >>> >>> People disagree with this by changing the subject to D not simulated >>> by H as all. They have been indoctrinated into believing that this >>> strawman deception is correct yet >>> >>> cannot possibly show the detailed steps of how D correctly simulated >>> by H can possibly reach its own simulated machine address of [00000d1d]. >>> *Here are the steps that prove that I am correct* >>> >>> (1) Executed H simulates the first seven instructions of D. >>> >>> (2) Simulated D calls simulated H(D,D) to simulate itself again. >>> >>> (3) Simulated H simulates the first seven instructions of simulated >>> simulated D. >>> >>> (4) Simulated simulated D simulated by simulated H calls >>> simulated simulated H(D,D) to simulate itself again. >>> >>> *HERE ARE ALL OF CONCRETE DETAILS OF THAT* >>> *Begin Local Halt Decider Simulation at Machine Address:cfc* >>> [00000cfc][00211839][0021183d](01) 55 push ebp ; begin D >>> [00000cfd][00211839][0021183d](02) 8bec mov ebp,esp >>> [00000cff][00211839][0021183d](03) 8b4508 mov eax,[ebp+08] >>> [00000d02][00211835][00000cfc](01) 50 push eax ; push D >>> [00000d03][00211835][00000cfc](03) 8b4d08 mov ecx,[ebp+08] >>> [00000d06][00211831][00000cfc](01) 51 push ecx ; push D >>> [00000d07][0021182d][00000d0c](05) e800feffff call 00000b0c ; call H >>> *This call to H is simulated by directly executed H* >>> >>> machine stack stack machine assembly >>> address address data code language >>> ======== ======== ======== =============== ============= >>> [00000cfc][0025c261][0025c265](01) 55 push ebp ; begin D >>> [00000cfd][0025c261][0025c265](02) 8bec mov ebp,esp >>> [00000cff][0025c261][0025c265](03) 8b4508 mov eax,[ebp+08] >>> [00000d02][0025c25d][00000cfc](01) 50 push eax ; push D >>> [00000d03][0025c25d][00000cfc](03) 8b4d08 mov ecx,[ebp+08] >>> [00000d06][0025c259][00000cfc](01) 51 push ecx ; push D >>> [00000d07][0025c255][00000d0c](05) e800feffff call 00000b0c ; call H >>> *This call to H would be simulated by simulated executed H* >>> *Infinitely Nested Simulation Detected Simulation Stopped* >>> >>> >> >> There is no infinite nested simulation detected, > > If I am wrong then a specific sequence of steps of D correctly > simulated by H where D terminates normally can be provided. No infinite execution has been detected, only a premature abortion. That is a much better explanation why H did not return. It is like an archer who is asked to hit a target twice as far as his bow can reach. His bow reaches 50m and the target is at 100m. He misses. Then he uses a new bow that reaches 100m, but now the target is at 200m. He is able to reach the old target, but again he misses the target for the new bow. He can continue, if the bow reaches further, the target is also further away. But note, the target is never at infinity. Similarly, the target of the simulator is never at infinity, but always some steps further that the simulation goes. You can make a simulator that simulates further, which can reach the target of the old simulator, but it is unable to reach its own target. So, there is no infinite recursion, but the simulation always misses the target. The simulation is never able to simulate itself up to the end. It always aborts prematurely.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-12 13:24 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4cp5s$1pe0q$1@dont-email.me> |
| In reply to | #106993 |
On 6/12/2024 1:19 PM, Fred. Zwarts wrote: > Op 12.jun.2024 om 16:47 schreef olcott: >> On 6/12/2024 1:18 AM, Fred. Zwarts wrote: >>> Op 11.jun.2024 om 19:07 schreef olcott: >>>> On 6/11/2024 2:21 AM, Fred. Zwarts wrote: >>>>> Op 10.jun.2024 om 21:47 schreef olcott: >>>>>> 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). >>>>> >>>>> Proven false. The direct execution does not ignore the call to H. >>>> >>>> Yes that is the second big mistake that I am aware that I made >>>> within the last year. >>>> >>>> When Ĥ is applied to ⟨Ĥ⟩ >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>> >>>> The other big mistake was what I said happens when Linz H is >>>> applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I forgot what I said and I forgot what the >>>> correct answer was. I do remember this is was my big mistake. >>>> >>>> No one has ever shown any actual error with my analysis of embedded_H >>>> applied to ⟨Ĥ⟩ ⟨Ĥ⟩. It is a verified fact that is over everyone's head >>>> besides mine that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H cannot >>>> possibly reach its own simulated final state of ⟨Ĥ.qn⟩. >>>> >>>> Everyone assumes that I must be wrong and only have dogma to base >>>> this assumption on. I have reasoning to prove that they are wrong >>>> yet this reasoning is over their heads. >>>> >>>> I have made isomorphic reasoning 100% concrete with this example >>>> and every has simply ignored this reasoning 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* >>>> *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 >>>> >>>> _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] >>>> >>>> It is impossible for D correctly simulated by H to ever reach >>>> its simulated final state at its own machine address [00000d1d]. >>>> >>>> People disagree with this by changing the subject to D not simulated >>>> by H as all. They have been indoctrinated into believing that this >>>> strawman deception is correct yet >>>> >>>> cannot possibly show the detailed steps of how D correctly simulated >>>> by H can possibly reach its own simulated machine address of >>>> [00000d1d]. >>>> *Here are the steps that prove that I am correct* >>>> >>>> (1) Executed H simulates the first seven instructions of D. >>>> >>>> (2) Simulated D calls simulated H(D,D) to simulate itself again. >>>> >>>> (3) Simulated H simulates the first seven instructions of simulated >>>> simulated D. >>>> >>>> (4) Simulated simulated D simulated by simulated H calls >>>> simulated simulated H(D,D) to simulate itself again. >>>> >>>> *HERE ARE ALL OF CONCRETE DETAILS OF THAT* >>>> *Begin Local Halt Decider Simulation at Machine Address:cfc* >>>> [00000cfc][00211839][0021183d](01) 55 push ebp ; begin D >>>> [00000cfd][00211839][0021183d](02) 8bec mov ebp,esp >>>> [00000cff][00211839][0021183d](03) 8b4508 mov eax,[ebp+08] >>>> [00000d02][00211835][00000cfc](01) 50 push eax ; push D >>>> [00000d03][00211835][00000cfc](03) 8b4d08 mov ecx,[ebp+08] >>>> [00000d06][00211831][00000cfc](01) 51 push ecx ; push D >>>> [00000d07][0021182d][00000d0c](05) e800feffff call 00000b0c ; call H >>>> *This call to H is simulated by directly executed H* >>>> >>>> machine stack stack machine assembly >>>> address address data code language >>>> ======== ======== ======== =============== ============= >>>> [00000cfc][0025c261][0025c265](01) 55 push ebp ; begin D >>>> [00000cfd][0025c261][0025c265](02) 8bec mov ebp,esp >>>> [00000cff][0025c261][0025c265](03) 8b4508 mov eax,[ebp+08] >>>> [00000d02][0025c25d][00000cfc](01) 50 push eax ; push D >>>> [00000d03][0025c25d][00000cfc](03) 8b4d08 mov ecx,[ebp+08] >>>> [00000d06][0025c259][00000cfc](01) 51 push ecx ; push D >>>> [00000d07][0025c255][00000d0c](05) e800feffff call 00000b0c ; call H >>>> *This call to H would be simulated by simulated executed H* >>>> *Infinitely Nested Simulation Detected Simulation Stopped* >>>> >>>> >>> >>> There is no infinite nested simulation detected, >> >> If I am wrong then a specific sequence of steps of D correctly >> simulated by H where D terminates normally can be provided. > > No infinite execution has been detected, You seem to simply not understand that D correctly simulated by H would eventually crash due to out-of-memory 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] | [prev] | [next] | [standalone]
| From | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-12 21:13 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4cs0b$1p0h1$1@dont-email.me> |
| In reply to | #106994 |
Op 12.jun.2024 om 20:24 schreef olcott: > On 6/12/2024 1:19 PM, Fred. Zwarts wrote: >> Op 12.jun.2024 om 16:47 schreef olcott: >>> On 6/12/2024 1:18 AM, Fred. Zwarts wrote: >>>> Op 11.jun.2024 om 19:07 schreef olcott: >>>>> On 6/11/2024 2:21 AM, Fred. Zwarts wrote: >>>>>> Op 10.jun.2024 om 21:47 schreef olcott: >>>>>>> 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). >>>>>> >>>>>> Proven false. The direct execution does not ignore the call to H. >>>>> >>>>> Yes that is the second big mistake that I am aware that I made >>>>> within the last year. >>>>> >>>>> When Ĥ is applied to ⟨Ĥ⟩ >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>> >>>>> The other big mistake was what I said happens when Linz H is >>>>> applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I forgot what I said and I forgot what the >>>>> correct answer was. I do remember this is was my big mistake. >>>>> >>>>> No one has ever shown any actual error with my analysis of embedded_H >>>>> applied to ⟨Ĥ⟩ ⟨Ĥ⟩. It is a verified fact that is over everyone's head >>>>> besides mine that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H cannot >>>>> possibly reach its own simulated final state of ⟨Ĥ.qn⟩. >>>>> >>>>> Everyone assumes that I must be wrong and only have dogma to base >>>>> this assumption on. I have reasoning to prove that they are wrong >>>>> yet this reasoning is over their heads. >>>>> >>>>> I have made isomorphic reasoning 100% concrete with this example >>>>> and every has simply ignored this reasoning 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* >>>>> *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 >>>>> >>>>> _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] >>>>> >>>>> It is impossible for D correctly simulated by H to ever reach >>>>> its simulated final state at its own machine address [00000d1d]. >>>>> >>>>> People disagree with this by changing the subject to D not simulated >>>>> by H as all. They have been indoctrinated into believing that this >>>>> strawman deception is correct yet >>>>> >>>>> cannot possibly show the detailed steps of how D correctly simulated >>>>> by H can possibly reach its own simulated machine address of >>>>> [00000d1d]. >>>>> *Here are the steps that prove that I am correct* >>>>> >>>>> (1) Executed H simulates the first seven instructions of D. >>>>> >>>>> (2) Simulated D calls simulated H(D,D) to simulate itself again. >>>>> >>>>> (3) Simulated H simulates the first seven instructions of simulated >>>>> simulated D. >>>>> >>>>> (4) Simulated simulated D simulated by simulated H calls >>>>> simulated simulated H(D,D) to simulate itself again. >>>>> >>>>> *HERE ARE ALL OF CONCRETE DETAILS OF THAT* >>>>> *Begin Local Halt Decider Simulation at Machine Address:cfc* >>>>> [00000cfc][00211839][0021183d](01) 55 push ebp ; >>>>> begin D >>>>> [00000cfd][00211839][0021183d](02) 8bec mov ebp,esp >>>>> [00000cff][00211839][0021183d](03) 8b4508 mov eax,[ebp+08] >>>>> [00000d02][00211835][00000cfc](01) 50 push eax ; push D >>>>> [00000d03][00211835][00000cfc](03) 8b4d08 mov ecx,[ebp+08] >>>>> [00000d06][00211831][00000cfc](01) 51 push ecx ; push D >>>>> [00000d07][0021182d][00000d0c](05) e800feffff call 00000b0c ; call H >>>>> *This call to H is simulated by directly executed H* >>>>> >>>>> machine stack stack machine assembly >>>>> address address data code language >>>>> ======== ======== ======== =============== ============= >>>>> [00000cfc][0025c261][0025c265](01) 55 push ebp ; >>>>> begin D >>>>> [00000cfd][0025c261][0025c265](02) 8bec mov ebp,esp >>>>> [00000cff][0025c261][0025c265](03) 8b4508 mov eax,[ebp+08] >>>>> [00000d02][0025c25d][00000cfc](01) 50 push eax ; push D >>>>> [00000d03][0025c25d][00000cfc](03) 8b4d08 mov ecx,[ebp+08] >>>>> [00000d06][0025c259][00000cfc](01) 51 push ecx ; push D >>>>> [00000d07][0025c255][00000d0c](05) e800feffff call 00000b0c ; call H >>>>> *This call to H would be simulated by simulated executed H* >>>>> *Infinitely Nested Simulation Detected Simulation Stopped* >>>>> >>>>> >>>> >>>> There is no infinite nested simulation detected, >>> >>> If I am wrong then a specific sequence of steps of D correctly >>> simulated by H where D terminates normally can be provided. >> >> No infinite execution has been detected, > > You seem to simply not understand that D correctly simulated > by H would eventually crash due to out-of-memory error. > Exactly. A correct H simulated by H does not exist. But, again, you misses the point. It was in the part that you omitted. So, again: No infinite execution has been detected, only a premature abortion. That is a much better explanation why H did not return. It is like an archer who is asked to hit a target twice as far as his bow can reach. His bow reaches 50m and the target is at 100m. He misses. Then he uses a new bow that reaches 100m, but now the target is at 200m. He is able to reach the old target, but again he misses the target for the new bow. He can continue, if the bow reaches further, the target is also further away. But note, the target is never at infinity. Similarly, the target of the simulator is never at infinity, but always some steps further that the simulation goes. You can make a simulator that simulates further, which can reach the target of the old simulator, but it is unable to reach its own target. So, there is no infinite recursion, but the simulation always misses the target. The simulation is never able to simulate itself up to the end. It always aborts prematurely.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-12 14:20 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4csdq$1q0a8$1@dont-email.me> |
| In reply to | #106995 |
On 6/12/2024 2:13 PM, Fred. Zwarts wrote: > Op 12.jun.2024 om 20:24 schreef olcott: >> On 6/12/2024 1:19 PM, Fred. Zwarts wrote: >>> Op 12.jun.2024 om 16:47 schreef olcott: >>>>> >>>>> There is no infinite nested simulation detected, >>>> >>>> If I am wrong then a specific sequence of steps of D correctly >>>> simulated by H where D terminates normally can be provided. >>> >>> No infinite execution has been detected, >> >> You seem to simply not understand that D correctly simulated >> by H would eventually crash due to out-of-memory error. >> > > Exactly. A correct H simulated by H does not exist. But, again, you > misses the point. It was in the part that you omitted. > So, again: > > No infinite execution has been detected, only a premature abortion. On 5/29/2021 2:26 PM, olcott wrote: https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ If that was true then you could provide every step of D correctly simulated by H such that D simulated by H reaches its own simulated "ret" instruction. *That you don't do this seems to prove that you know you are a liar* _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] -- 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 | "Fred. Zwarts" <F.Zwarts@HetNet.nl> |
|---|---|
| Date | 2024-06-12 21:46 +0200 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4ctuq$1p0h1$2@dont-email.me> |
| In reply to | #106996 |
Op 12.jun.2024 om 21:20 schreef olcott: > On 6/12/2024 2:13 PM, Fred. Zwarts wrote: >> Op 12.jun.2024 om 20:24 schreef olcott: >>> On 6/12/2024 1:19 PM, Fred. Zwarts wrote: >>>> Op 12.jun.2024 om 16:47 schreef olcott: >>>>>> >>>>>> There is no infinite nested simulation detected, >>>>> >>>>> If I am wrong then a specific sequence of steps of D correctly >>>>> simulated by H where D terminates normally can be provided. >>>> >>>> No infinite execution has been detected, >>> >>> You seem to simply not understand that D correctly simulated >>> by H would eventually crash due to out-of-memory error. >>> >> >> Exactly. A correct H simulated by H does not exist. But, again, you >> misses the point. It was in the part that you omitted. >> So, again: >> >> No infinite execution has been detected, only a premature abortion. > > On 5/29/2021 2:26 PM, olcott wrote: > https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ > > If that was true then you could provide every step of D correctly > simulated by H such that D simulated by H reaches its own simulated > "ret" instruction. I said that each H is unable to hit its target, so how could it reach the "ret" instruction of D? Please, think before you reply. Try again, it is not that difficult. Just take the time to read and think about it. You seem to think that the archer is trying to reach infinity. But that is not what I say. If D does not reach its "ret," it is exactly because it was aborted. The target of the simulation was just some steps too far for this H, but not at infinity. It is like an archer who is asked to hit a target twice as far as his bow can reach. His bow reaches 50m and the target is at 100m. He misses. Then he uses a new bow that reaches 100m, but now the target is at 200m. He is able to reach the old target, but again he misses the target for the new bow. He can continue, if the bow reaches further, the target is also further away. But note, the target is never at infinity. Similarly, the target of the simulator is never at infinity, but always some steps further that the simulation goes. You can make a simulator that simulates further, which can reach the target of the old simulator, but it is unable to reach its own target. So, there is no infinite recursion, but the simulation always misses the target. The simulation is never able to simulate itself up to the end. It always aborts prematurely.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-12 14:53 -0500 |
| Subject | Re: D correctly simulated by H proved for THREE YEARS --- rewritten |
| Message-ID | <v4cuc6$1qedu$1@dont-email.me> |
| In reply to | #106997 |
On 6/12/2024 2:46 PM, Fred. Zwarts wrote: > Op 12.jun.2024 om 21:20 schreef olcott: >> On 6/12/2024 2:13 PM, Fred. Zwarts wrote: >>> Op 12.jun.2024 om 20:24 schreef olcott: >>>> On 6/12/2024 1:19 PM, Fred. Zwarts wrote: >>>>> Op 12.jun.2024 om 16:47 schreef olcott: >>>>>>> >>>>>>> There is no infinite nested simulation detected, >>>>>> >>>>>> If I am wrong then a specific sequence of steps of D correctly >>>>>> simulated by H where D terminates normally can be provided. >>>>> >>>>> No infinite execution has been detected, >>>> >>>> You seem to simply not understand that D correctly simulated >>>> by H would eventually crash due to out-of-memory error. >>>> >>> >>> Exactly. A correct H simulated by H does not exist. But, again, you >>> misses the point. It was in the part that you omitted. >>> So, again: >>> >>> No infinite execution has been detected, only a premature abortion. >> >> On 5/29/2021 2:26 PM, olcott wrote: >> https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ >> >> If that was true then you could provide every step of D correctly >> simulated by H such that D simulated by H reaches its own simulated >> "ret" instruction. > > I said that each H is unable to hit its target, so how could it reach > the "ret" instruction of D? Please, think before you reply. It is a binary choice either D correctly simulated by H can possibly terminate normally by reaching its "ret" instruction or not. Your attempt to twist these words to make it look like there is more than these two possibilities is either ignorant or deceptive. -- 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 2 of 5 — ← Prev page 1 [2] 3 4 5 Next page →
Back to top | Article view | comp.theory
csiph-web