Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #107210 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2024-06-15 11:22 -0500 |
| Last post | 2024-06-20 09:53 +0200 |
| Articles | 20 on this page of 44 — 5 participants |
Back to article view | Back to comp.theory
H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-15 11:22 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Richard Damon <richard@damon-family.org> - 2024-06-15 12:33 -0400
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-15 16:56 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Richard Damon <richard@damon-family.org> - 2024-06-15 19:01 -0400
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-15 18:30 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Richard Damon <richard@damon-family.org> - 2024-06-15 19:37 -0400
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-15 19:05 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Richard Damon <richard@damon-family.org> - 2024-06-15 20:13 -0400
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-15 19:48 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Richard Damon <richard@damon-family.org> - 2024-06-15 21:19 -0400
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-15 20:42 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Richard Damon <richard@damon-family.org> - 2024-06-15 21:58 -0400
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Mikko <mikko.levanto@iki.fi> - 2024-06-16 11:00 +0300
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-16 07:48 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Richard Damon <richard@damon-family.org> - 2024-06-16 13:30 -0400
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Mikko <mikko.levanto@iki.fi> - 2024-06-17 10:19 +0300
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-17 07:57 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Mikko <mikko.levanto@iki.fi> - 2024-06-18 11:01 +0300
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-18 07:48 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Mikko <mikko.levanto@iki.fi> - 2024-06-18 19:04 +0300
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Mikko <mikko.levanto@iki.fi> - 2024-06-16 10:53 +0300
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-16 07:47 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Richard Damon <richard@damon-family.org> - 2024-06-16 13:30 -0400
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Mikko <mikko.levanto@iki.fi> - 2024-06-17 10:20 +0300
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-17 08:03 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Richard Damon <richard@damon-family.org> - 2024-06-17 18:46 -0400
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Mikko <mikko.levanto@iki.fi> - 2024-06-18 11:03 +0300
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-18 07:57 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Mikko <mikko.levanto@iki.fi> - 2024-06-18 19:05 +0300
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-18 13:55 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Mikko <mikko.levanto@iki.fi> - 2024-06-19 11:36 +0300
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-19 08:44 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Mikko <mikko.levanto@iki.fi> - 2024-06-20 08:05 +0300
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-20 00:19 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-18 14:04 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-19 09:58 +0200
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-19 07:58 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-19 15:46 +0200
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-19 09:55 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-19 17:39 +0200
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-19 10:46 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES Alan Mackenzie <acm@muc.de> - 2024-06-19 16:29 +0000
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES olcott <polcott333@gmail.com> - 2024-06-19 12:07 -0500
Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-20 09:53 +0200
Page 2 of 3 — ← Prev page 1 [2] 3 Next page →
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-16 10:53 +0300 |
| Message-ID | <v4m5l6$3v4ql$1@dont-email.me> |
| In reply to | #107210 |
On 2024-06-15 16:22:09 +0000, olcott said: > On 6/13/2024 8:24 PM, Richard Damon wrote: > > On 6/13/24 11:32 AM, olcott wrote: > >> > >> It is contingent upon you to show the exact steps of how H computes > >> the mapping from the x86 machine language finite string input to > >> H(D,D) using the finite string transformation rules specified by > >> the semantics of the x86 programming language that reaches the > >> behavior of the directly executed D(D) > >> > > > > Why? I don't claim it can. > > The first six steps of this mapping are when instructions > at the machine address range of [00000cfc] to [00000d06] > are simulated/executed. > > After that the behavior of D correctly simulated by H diverges > from the behavior of D(D) because the call to H(D,D) by D > correctly simulated by H cannot possibly return to D. > > _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] When you put "V2" or "V3" or something similar on the subject line you should tell what is different from the original version. -- Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-16 07:47 -0500 |
| Message-ID | <v4mmsd$1qt6$3@dont-email.me> |
| In reply to | #107261 |
On 6/16/2024 2:53 AM, Mikko wrote: > On 2024-06-15 16:22:09 +0000, olcott said: > >> On 6/13/2024 8:24 PM, Richard Damon wrote: >> > On 6/13/24 11:32 AM, olcott wrote: >> >> >> >> It is contingent upon you to show the exact steps of how H computes >> >> the mapping from the x86 machine language finite string input to >> >> H(D,D) using the finite string transformation rules specified by >> >> the semantics of the x86 programming language that reaches the >> >> behavior of the directly executed D(D) >> >> >> > >> > Why? I don't claim it can. >> >> The first six steps of this mapping are when instructions >> at the machine address range of [00000cfc] to [00000d06] >> are simulated/executed. >> >> After that the behavior of D correctly simulated by H diverges >> from the behavior of D(D) because the call to H(D,D) by D >> correctly simulated by H cannot possibly return to D. >> >> _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] > > When you put "V2" or "V3" or something similar on the subject line > you should tell what is different from the original version. > I ask what are the steps I provide 6 steps and then ask what are the next steps. I provide all of the steps. -- 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-16 13:30 -0400 |
| Message-ID | <v4n7g3$61l9$6@i2pn2.org> |
| In reply to | #107269 |
On 6/16/24 8:47 AM, olcott wrote: > On 6/16/2024 2:53 AM, Mikko wrote: >> On 2024-06-15 16:22:09 +0000, olcott said: >> >>> On 6/13/2024 8:24 PM, Richard Damon wrote: >>> > On 6/13/24 11:32 AM, olcott wrote: >>> >> >>> >> It is contingent upon you to show the exact steps of how H computes >>> >> the mapping from the x86 machine language finite string input to >>> >> H(D,D) using the finite string transformation rules specified by >>> >> the semantics of the x86 programming language that reaches the >>> >> behavior of the directly executed D(D) >>> >> >>> > >>> > Why? I don't claim it can. >>> >>> The first six steps of this mapping are when instructions >>> at the machine address range of [00000cfc] to [00000d06] >>> are simulated/executed. >>> >>> After that the behavior of D correctly simulated by H diverges >>> from the behavior of D(D) because the call to H(D,D) by D >>> correctly simulated by H cannot possibly return to D. >>> >>> _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] >> >> When you put "V2" or "V3" or something similar on the subject line >> you should tell what is different from the original version. >> > > I ask what are the steps > I provide 6 steps and then ask what are the next steps. > I provide all of the steps. > but the NEXT step is the call H instruction, follwed by the simulation of the insturciton of H, at which point you hit problem. You seem to be trying to define that the "input" is independent of the H, but then you simulator CAN'T BE CORRECT, as it needs to process behavior of the input that hasn't been given. You try to weasle by saying it can use the contents of the memory that is their, but then it is no longer looking at the behavior specified by the input if that has been excluded as part of the input, so that is just a lie. That means, that the input must actually include all the code of H (and everything H calls) and thus, you can't change the code of H that D calls when you perform your proof, but need to make a new function, like H1, that you do your variations over. And, when you do that, it turns out that the new Hs that simulate enough longer can see that their correct simulation will reach that final state, and thus your claims are shown to be just a lie. The problem come to a head when we look at the definition of D, as described in Linz's H^. The basic definition of what H^ is supposed to be doing, is to ask H to decide on the behavior of H^ applied to a description of itself, and then do the opposite. Since your D does that "ask H" part by calling H(D,D), then that MUST be the method of asking H about the behavior of THIS D, and thus there must be sufficient information in that input to do that, which means, that this input needs to represent the WHOLE PROGRAM, and thus includes a copy of the H it was using, and specifically a copy of THAT H, not some other one with a different behavior.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-17 10:20 +0300 |
| Message-ID | <v4oo36$hnns$1@dont-email.me> |
| In reply to | #107269 |
On 2024-06-16 12:47:09 +0000, olcott said: > On 6/16/2024 2:53 AM, Mikko wrote: >> On 2024-06-15 16:22:09 +0000, olcott said: >> >>> On 6/13/2024 8:24 PM, Richard Damon wrote: >>> > On 6/13/24 11:32 AM, olcott wrote: >>> >> >>> >> It is contingent upon you to show the exact steps of how H computes >>> >> the mapping from the x86 machine language finite string input to >>> >> H(D,D) using the finite string transformation rules specified by >>> >> the semantics of the x86 programming language that reaches the >>> >> behavior of the directly executed D(D) >>> >> >>> > >>> > Why? I don't claim it can. >>> >>> The first six steps of this mapping are when instructions >>> at the machine address range of [00000cfc] to [00000d06] >>> are simulated/executed. >>> >>> After that the behavior of D correctly simulated by H diverges >>> from the behavior of D(D) because the call to H(D,D) by D >>> correctly simulated by H cannot possibly return to D. >>> >>> _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] >> >> When you put "V2" or "V3" or something similar on the subject line >> you should tell what is different from the original version. >> > > I ask what are the steps > I provide 6 steps and then ask what are the next steps. > I provide all of the steps. In which version? -- Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-17 08:03 -0500 |
| Message-ID | <v4pc7t$ln46$3@dont-email.me> |
| In reply to | #107304 |
On 6/17/2024 2:20 AM, Mikko wrote:
> On 2024-06-16 12:47:09 +0000, olcott said:
>
>> On 6/16/2024 2:53 AM, Mikko wrote:
>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>
>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>> >>
>>>> >> It is contingent upon you to show the exact steps of how H computes
>>>> >> the mapping from the x86 machine language finite string input to
>>>> >> H(D,D) using the finite string transformation rules specified by
>>>> >> the semantics of the x86 programming language that reaches the
>>>> >> behavior of the directly executed D(D)
>>>> >>
>>>> >
>>>> > Why? I don't claim it can.
>>>>
>>>> The first six steps of this mapping are when instructions
>>>> at the machine address range of [00000cfc] to [00000d06]
>>>> are simulated/executed.
>>>>
>>>> After that the behavior of D correctly simulated by H diverges
>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>> correctly simulated by H cannot possibly return to D.
>>>>
>>>> _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]
>>>
>>> When you put "V2" or "V3" or something similar on the subject line
>>> you should tell what is different from the original version.
>>>
>>
>> I ask what are the steps
>> I provide 6 steps and then ask what are the next steps.
>> I provide all of the steps.
>
> In which version?
>
*This is the simplest possible version*
void DDD()
{
H0(DDD);
}
After six steps of DDD are correctly emulated by H0
what machine address of DDD would it be at?
_DDD()
[00001fd2] 55 push ebp ; housekeeping
[00001fd3] 8bec mov ebp,esp ; housekeeping
[00001fd5] 68d21f0000 push 00001fd2 ; push DDD
[00001fda] e8f3f9ffff call 000019d2 ; call H0
[00001fdf] 83c404 add esp,+04 ; housekeeping
[00001fe2] 5d pop ebp ; housekeeping
[00001fe3] c3 ret ; return to caller
Size in bytes:(0018) [00001fe3]
--
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-17 18:46 -0400 |
| Message-ID | <v4qebu$a0nm$2@i2pn2.org> |
| In reply to | #107313 |
On 6/17/24 9:03 AM, olcott wrote:
> On 6/17/2024 2:20 AM, Mikko wrote:
>> On 2024-06-16 12:47:09 +0000, olcott said:
>>
>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>
>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>> >>
>>>>> >> It is contingent upon you to show the exact steps of how H
>>>>> computes
>>>>> >> the mapping from the x86 machine language finite string input to
>>>>> >> H(D,D) using the finite string transformation rules specified by
>>>>> >> the semantics of the x86 programming language that reaches the
>>>>> >> behavior of the directly executed D(D)
>>>>> >>
>>>>> >
>>>>> > Why? I don't claim it can.
>>>>>
>>>>> The first six steps of this mapping are when instructions
>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>> are simulated/executed.
>>>>>
>>>>> After that the behavior of D correctly simulated by H diverges
>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>> correctly simulated by H cannot possibly return to D.
>>>>>
>>>>> _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]
>>>>
>>>> When you put "V2" or "V3" or something similar on the subject line
>>>> you should tell what is different from the original version.
>>>>
>>>
>>> I ask what are the steps
>>> I provide 6 steps and then ask what are the next steps.
>>> I provide all of the steps.
>>
>> In which version?
>>
>
> *This is the simplest possible version*
>
> void DDD()
> {
> H0(DDD);
> }
>
> After six steps of DDD are correctly emulated by H0
> what machine address of DDD would it be at?
>
> _DDD()
> [00001fd2] 55 push ebp ; housekeeping
> [00001fd3] 8bec mov ebp,esp ; housekeeping
> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
> [00001fda] e8f3f9ffff call 000019d2 ; call H0
> [00001fdf] 83c404 add esp,+04 ; housekeeping
> [00001fe2] 5d pop ebp ; housekeeping
> [00001fe3] c3 ret ; return to caller
> Size in bytes:(0018) [00001fe3]
>
Somewhere in H0.
It get there after four steps of DDD are correctly emulated by H0.
Since you don't provide H0, the questions are:
If this is all the input provided, how can H0 actually simulate that
fifth instruction.
Or, is the code of *THIS* H0 included as part of the input, and thus
when you start to talk about other H0 simulating this input, they need
that same H0 included.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-18 11:03 +0300 |
| Message-ID | <v4revs$18him$1@dont-email.me> |
| In reply to | #107313 |
On 2024-06-17 13:03:56 +0000, olcott said:
> On 6/17/2024 2:20 AM, Mikko wrote:
>> On 2024-06-16 12:47:09 +0000, olcott said:
>>
>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>
>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>> >>
>>>>> >> It is contingent upon you to show the exact steps of how H computes
>>>>> >> the mapping from the x86 machine language finite string input to
>>>>> >> H(D,D) using the finite string transformation rules specified by
>>>>> >> the semantics of the x86 programming language that reaches the
>>>>> >> behavior of the directly executed D(D)
>>>>> >>
>>>>> >
>>>>> > Why? I don't claim it can.
>>>>>
>>>>> The first six steps of this mapping are when instructions
>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>> are simulated/executed.
>>>>>
>>>>> After that the behavior of D correctly simulated by H diverges
>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>> correctly simulated by H cannot possibly return to D.
>>>>>
>>>>> _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]
>>>>
>>>> When you put "V2" or "V3" or something similar on the subject line
>>>> you should tell what is different from the original version.
>>>>
>>>
>>> I ask what are the steps
>>> I provide 6 steps and then ask what are the next steps.
>>> I provide all of the steps.
>>
>> In which version?
>>
>
> *This is the simplest possible version*
>
> void DDD()
> {
> H0(DDD);
> }
>
> After six steps of DDD are correctly emulated by H0
> what machine address of DDD would it be at?
>
> _DDD()
> [00001fd2] 55 push ebp ; housekeeping
> [00001fd3] 8bec mov ebp,esp ; housekeeping
> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
> [00001fda] e8f3f9ffff call 000019d2 ; call H0
> [00001fdf] 83c404 add esp,+04 ; housekeeping
> [00001fe2] 5d pop ebp ; housekeeping
> [00001fe3] c3 ret ; return to caller
> Size in bytes:(0018) [00001fe3]
So how is this a difference between the original version and V2 and V3?
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-18 07:57 -0500 |
| Message-ID | <v4s07h$1boeu$5@dont-email.me> |
| In reply to | #107356 |
On 6/18/2024 3:03 AM, Mikko wrote:
> On 2024-06-17 13:03:56 +0000, olcott said:
>
>> On 6/17/2024 2:20 AM, Mikko wrote:
>>> On 2024-06-16 12:47:09 +0000, olcott said:
>>>
>>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>>
>>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>>> >>
>>>>>> >> It is contingent upon you to show the exact steps of how H
>>>>>> computes
>>>>>> >> the mapping from the x86 machine language finite string input to
>>>>>> >> H(D,D) using the finite string transformation rules specified by
>>>>>> >> the semantics of the x86 programming language that reaches the
>>>>>> >> behavior of the directly executed D(D)
>>>>>> >>
>>>>>> >
>>>>>> > Why? I don't claim it can.
>>>>>>
>>>>>> The first six steps of this mapping are when instructions
>>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>>> are simulated/executed.
>>>>>>
>>>>>> After that the behavior of D correctly simulated by H diverges
>>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>>> correctly simulated by H cannot possibly return to D.
>>>>>>
>>>>>> _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]
>>>>>
>>>>> When you put "V2" or "V3" or something similar on the subject line
>>>>> you should tell what is different from the original version.
>>>>>
>>>>
>>>> I ask what are the steps
>>>> I provide 6 steps and then ask what are the next steps.
>>>> I provide all of the steps.
>>>
>>> In which version?
>>>
>>
>> *This is the simplest possible version*
>>
>> void DDD()
>> {
>> H0(DDD);
>> }
>>
>> After six steps of DDD are correctly emulated by H0
>> what machine address of DDD would it be at?
>>
>> _DDD()
>> [00001fd2] 55 push ebp ; housekeeping
>> [00001fd3] 8bec mov ebp,esp ; housekeeping
>> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
>> [00001fda] e8f3f9ffff call 000019d2 ; call H0
>> [00001fdf] 83c404 add esp,+04 ; housekeeping
>> [00001fe2] 5d pop ebp ; housekeeping
>> [00001fe3] c3 ret ; return to caller
>> Size in bytes:(0018) [00001fe3]
>
> So how is this a difference between the original version and V2 and V3?
>
No params thus easier to see that it pushes its own machine address.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-18 19:05 +0300 |
| Message-ID | <v4sb8k$1e266$2@dont-email.me> |
| In reply to | #107366 |
On 2024-06-18 12:57:21 +0000, olcott said:
> On 6/18/2024 3:03 AM, Mikko wrote:
>> On 2024-06-17 13:03:56 +0000, olcott said:
>>
>>> On 6/17/2024 2:20 AM, Mikko wrote:
>>>> On 2024-06-16 12:47:09 +0000, olcott said:
>>>>
>>>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>>>
>>>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>>>> >>
>>>>>>> >> It is contingent upon you to show the exact steps of how H computes
>>>>>>> >> the mapping from the x86 machine language finite string input to
>>>>>>> >> H(D,D) using the finite string transformation rules specified by
>>>>>>> >> the semantics of the x86 programming language that reaches the
>>>>>>> >> behavior of the directly executed D(D)
>>>>>>> >>
>>>>>>> >
>>>>>>> > Why? I don't claim it can.
>>>>>>>
>>>>>>> The first six steps of this mapping are when instructions
>>>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>>>> are simulated/executed.
>>>>>>>
>>>>>>> After that the behavior of D correctly simulated by H diverges
>>>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>>>> correctly simulated by H cannot possibly return to D.
>>>>>>>
>>>>>>> _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]
>>>>>>
>>>>>> When you put "V2" or "V3" or something similar on the subject line
>>>>>> you should tell what is different from the original version.
>>>>>>
>>>>>
>>>>> I ask what are the steps
>>>>> I provide 6 steps and then ask what are the next steps.
>>>>> I provide all of the steps.
>>>>
>>>> In which version?
>>>>
>>>
>>> *This is the simplest possible version*
>>>
>>> void DDD()
>>> {
>>> H0(DDD);
>>> }
>>>
>>> After six steps of DDD are correctly emulated by H0
>>> what machine address of DDD would it be at?
>>>
>>> _DDD()
>>> [00001fd2] 55 push ebp ; housekeeping
>>> [00001fd3] 8bec mov ebp,esp ; housekeeping
>>> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
>>> [00001fda] e8f3f9ffff call 000019d2 ; call H0
>>> [00001fdf] 83c404 add esp,+04 ; housekeeping
>>> [00001fe2] 5d pop ebp ; housekeeping
>>> [00001fe3] c3 ret ; return to caller
>>> Size in bytes:(0018) [00001fe3]
>>
>> So how is this a difference between the original version and V2 and V3?
>>
>
> No params thus easier to see that it pushes its own machine address.
My question is still unanswered.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-18 13:55 -0500 |
| Message-ID | <v4sl6p$1g2ci$1@dont-email.me> |
| In reply to | #107379 |
On 6/18/2024 11:05 AM, Mikko wrote:
> On 2024-06-18 12:57:21 +0000, olcott said:
>
>> On 6/18/2024 3:03 AM, Mikko wrote:
>>> On 2024-06-17 13:03:56 +0000, olcott said:
>>>
>>>> On 6/17/2024 2:20 AM, Mikko wrote:
>>>>> On 2024-06-16 12:47:09 +0000, olcott said:
>>>>>
>>>>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>>>>
>>>>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>>>>> >>
>>>>>>>> >> It is contingent upon you to show the exact steps of how H
>>>>>>>> computes
>>>>>>>> >> the mapping from the x86 machine language finite string
>>>>>>>> input to
>>>>>>>> >> H(D,D) using the finite string transformation rules
>>>>>>>> specified by
>>>>>>>> >> the semantics of the x86 programming language that reaches the
>>>>>>>> >> behavior of the directly executed D(D)
>>>>>>>> >>
>>>>>>>> >
>>>>>>>> > Why? I don't claim it can.
>>>>>>>>
>>>>>>>> The first six steps of this mapping are when instructions
>>>>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>>>>> are simulated/executed.
>>>>>>>>
>>>>>>>> After that the behavior of D correctly simulated by H diverges
>>>>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>>>>> correctly simulated by H cannot possibly return to D.
>>>>>>>>
>>>>>>>> _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]
>>>>>>>
>>>>>>> When you put "V2" or "V3" or something similar on the subject line
>>>>>>> you should tell what is different from the original version.
>>>>>>>
>>>>>>
>>>>>> I ask what are the steps
>>>>>> I provide 6 steps and then ask what are the next steps.
>>>>>> I provide all of the steps.
>>>>>
>>>>> In which version?
>>>>>
>>>>
>>>> *This is the simplest possible version*
>>>>
>>>> void DDD()
>>>> {
>>>> H0(DDD);
>>>> }
>>>>
>>>> After six steps of DDD are correctly emulated by H0
>>>> what machine address of DDD would it be at?
>>>>
>>>> _DDD()
>>>> [00001fd2] 55 push ebp ; housekeeping
>>>> [00001fd3] 8bec mov ebp,esp ; housekeeping
>>>> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
>>>> [00001fda] e8f3f9ffff call 000019d2 ; call H0
>>>> [00001fdf] 83c404 add esp,+04 ; housekeeping
>>>> [00001fe2] 5d pop ebp ; housekeeping
>>>> [00001fe3] c3 ret ; return to caller
>>>> Size in bytes:(0018) [00001fe3]
>>>
>>> So how is this a difference between the original version and V2 and V3?
>>>
>>
>> No params thus easier to see that it pushes its own machine address.
>
> My question is still unanswered.
>
When I answer the question that the difference
is that one of them had parameters and the other one
does not have parameters it is dishonest of you
to say that I did not answer the question.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-19 11:36 +0300 |
| Message-ID | <v4u5at$1sof1$1@dont-email.me> |
| In reply to | #107396 |
On 2024-06-18 18:55:21 +0000, olcott said:
> On 6/18/2024 11:05 AM, Mikko wrote:
>> On 2024-06-18 12:57:21 +0000, olcott said:
>>
>>> On 6/18/2024 3:03 AM, Mikko wrote:
>>>> On 2024-06-17 13:03:56 +0000, olcott said:
>>>>
>>>>> On 6/17/2024 2:20 AM, Mikko wrote:
>>>>>> On 2024-06-16 12:47:09 +0000, olcott said:
>>>>>>
>>>>>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>>>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>>>>>> >>
>>>>>>>>> >> It is contingent upon you to show the exact steps of how H computes
>>>>>>>>> >> the mapping from the x86 machine language finite string input to
>>>>>>>>> >> H(D,D) using the finite string transformation rules specified by
>>>>>>>>> >> the semantics of the x86 programming language that reaches the
>>>>>>>>> >> behavior of the directly executed D(D)
>>>>>>>>> >>
>>>>>>>>> >
>>>>>>>>> > Why? I don't claim it can.
>>>>>>>>>
>>>>>>>>> The first six steps of this mapping are when instructions
>>>>>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>>>>>> are simulated/executed.
>>>>>>>>>
>>>>>>>>> After that the behavior of D correctly simulated by H diverges
>>>>>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>>>>>> correctly simulated by H cannot possibly return to D.
>>>>>>>>>
>>>>>>>>> _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]
>>>>>>>>
>>>>>>>> When you put "V2" or "V3" or something similar on the subject line
>>>>>>>> you should tell what is different from the original version.
>>>>>>>>
>>>>>>>
>>>>>>> I ask what are the steps
>>>>>>> I provide 6 steps and then ask what are the next steps.
>>>>>>> I provide all of the steps.
>>>>>>
>>>>>> In which version?
>>>>>>
>>>>>
>>>>> *This is the simplest possible version*
>>>>>
>>>>> void DDD()
>>>>> {
>>>>> H0(DDD);
>>>>> }
>>>>>
>>>>> After six steps of DDD are correctly emulated by H0
>>>>> what machine address of DDD would it be at?
>>>>>
>>>>> _DDD()
>>>>> [00001fd2] 55 push ebp ; housekeeping
>>>>> [00001fd3] 8bec mov ebp,esp ; housekeeping
>>>>> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
>>>>> [00001fda] e8f3f9ffff call 000019d2 ; call H0
>>>>> [00001fdf] 83c404 add esp,+04 ; housekeeping
>>>>> [00001fe2] 5d pop ebp ; housekeeping
>>>>> [00001fe3] c3 ret ; return to caller
>>>>> Size in bytes:(0018) [00001fe3]
>>>>
>>>> So how is this a difference between the original version and V2 and V3?
>>>>
>>>
>>> No params thus easier to see that it pushes its own machine address.
>>
>> My question is still unanswered.
>>
>
> When I answer the question that the difference
> is that one of them had parameters and the other one
> does not have parameters it is dishonest of you
> to say that I did not answer the question.
The qestion is not answered until you say which of the three versions
has parameters and which has not and how the third one differs from
the one that has parameters and from the one that nas not.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-19 08:44 -0500 |
| Message-ID | <v4unbc$1vpm0$8@dont-email.me> |
| In reply to | #107416 |
On 6/19/2024 3:36 AM, Mikko wrote:
> On 2024-06-18 18:55:21 +0000, olcott said:
>
>> On 6/18/2024 11:05 AM, Mikko wrote:
>>> On 2024-06-18 12:57:21 +0000, olcott said:
>>>
>>>> On 6/18/2024 3:03 AM, Mikko wrote:
>>>>> On 2024-06-17 13:03:56 +0000, olcott said:
>>>>>
>>>>>> On 6/17/2024 2:20 AM, Mikko wrote:
>>>>>>> On 2024-06-16 12:47:09 +0000, olcott said:
>>>>>>>
>>>>>>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>>>>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>>>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>>>>>>> >>
>>>>>>>>>> >> It is contingent upon you to show the exact steps of how H
>>>>>>>>>> computes
>>>>>>>>>> >> the mapping from the x86 machine language finite string
>>>>>>>>>> input to
>>>>>>>>>> >> H(D,D) using the finite string transformation rules
>>>>>>>>>> specified by
>>>>>>>>>> >> the semantics of the x86 programming language that reaches
>>>>>>>>>> the
>>>>>>>>>> >> behavior of the directly executed D(D)
>>>>>>>>>> >>
>>>>>>>>>> >
>>>>>>>>>> > Why? I don't claim it can.
>>>>>>>>>>
>>>>>>>>>> The first six steps of this mapping are when instructions
>>>>>>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>>>>>>> are simulated/executed.
>>>>>>>>>>
>>>>>>>>>> After that the behavior of D correctly simulated by H diverges
>>>>>>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>>>>>>> correctly simulated by H cannot possibly return to D.
>>>>>>>>>>
>>>>>>>>>> _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]
>>>>>>>>>
>>>>>>>>> When you put "V2" or "V3" or something similar on the subject line
>>>>>>>>> you should tell what is different from the original version.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I ask what are the steps
>>>>>>>> I provide 6 steps and then ask what are the next steps.
>>>>>>>> I provide all of the steps.
>>>>>>>
>>>>>>> In which version?
>>>>>>>
>>>>>>
>>>>>> *This is the simplest possible version*
>>>>>>
>>>>>> void DDD()
>>>>>> {
>>>>>> H0(DDD);
>>>>>> }
>>>>>>
>>>>>> After six steps of DDD are correctly emulated by H0
>>>>>> what machine address of DDD would it be at?
>>>>>>
>>>>>> _DDD()
>>>>>> [00001fd2] 55 push ebp ; housekeeping
>>>>>> [00001fd3] 8bec mov ebp,esp ; housekeeping
>>>>>> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
>>>>>> [00001fda] e8f3f9ffff call 000019d2 ; call H0
>>>>>> [00001fdf] 83c404 add esp,+04 ; housekeeping
>>>>>> [00001fe2] 5d pop ebp ; housekeeping
>>>>>> [00001fe3] c3 ret ; return to caller
>>>>>> Size in bytes:(0018) [00001fe3]
>>>>>
>>>>> So how is this a difference between the original version and V2 and
>>>>> V3?
>>>>>
>>>>
>>>> No params thus easier to see that it pushes its own machine address.
>>>
>>> My question is still unanswered.
>>>
>>
>> When I answer the question that the difference
>> is that one of them had parameters and the other one
>> does not have parameters it is dishonest of you
>> to say that I did not answer the question.
>
> The qestion is not answered until you say which of the three versions
> has parameters and which has not and how the third one differs from
> the one that has parameters and from the one that nas not.
>
typedef void (*ptr)();
int H0(ptr P);
int H(ptr P, ptr I);
void DDD()
{
H0(DDD);
}
void DDDD(ptr x)
{
H(x,x);
}
That seems to be saying that you don't know enough about the C
programming language to know what a parameter is thus cannot
tell the difference between DDD that has no parameters and DDDD
that had one parameter.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-20 08:05 +0300 |
| Message-ID | <v50dbn$2e5ko$1@dont-email.me> |
| In reply to | #107430 |
On 2024-06-19 13:44:12 +0000, olcott said:
> On 6/19/2024 3:36 AM, Mikko wrote:
>> On 2024-06-18 18:55:21 +0000, olcott said:
>>
>>> On 6/18/2024 11:05 AM, Mikko wrote:
>>>> On 2024-06-18 12:57:21 +0000, olcott said:
>>>>
>>>>> On 6/18/2024 3:03 AM, Mikko wrote:
>>>>>> On 2024-06-17 13:03:56 +0000, olcott said:
>>>>>>
>>>>>>> On 6/17/2024 2:20 AM, Mikko wrote:
>>>>>>>> On 2024-06-16 12:47:09 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>>>>>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>>>>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>>>>>>>> >>
>>>>>>>>>>> >> It is contingent upon you to show the exact steps of how H computes
>>>>>>>>>>> >> the mapping from the x86 machine language finite string input to
>>>>>>>>>>> >> H(D,D) using the finite string transformation rules specified by
>>>>>>>>>>> >> the semantics of the x86 programming language that reaches the
>>>>>>>>>>> >> behavior of the directly executed D(D)
>>>>>>>>>>> >>
>>>>>>>>>>> >
>>>>>>>>>>> > Why? I don't claim it can.
>>>>>>>>>>>
>>>>>>>>>>> The first six steps of this mapping are when instructions
>>>>>>>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>>>>>>>> are simulated/executed.
>>>>>>>>>>>
>>>>>>>>>>> After that the behavior of D correctly simulated by H diverges
>>>>>>>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>>>>>>>> correctly simulated by H cannot possibly return to D.
>>>>>>>>>>>
>>>>>>>>>>> _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]
>>>>>>>>>>
>>>>>>>>>> When you put "V2" or "V3" or something similar on the subject line
>>>>>>>>>> you should tell what is different from the original version.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I ask what are the steps
>>>>>>>>> I provide 6 steps and then ask what are the next steps.
>>>>>>>>> I provide all of the steps.
>>>>>>>>
>>>>>>>> In which version?
>>>>>>>>
>>>>>>>
>>>>>>> *This is the simplest possible version*
>>>>>>>
>>>>>>> void DDD()
>>>>>>> {
>>>>>>> H0(DDD);
>>>>>>> }
>>>>>>>
>>>>>>> After six steps of DDD are correctly emulated by H0
>>>>>>> what machine address of DDD would it be at?
>>>>>>>
>>>>>>> _DDD()
>>>>>>> [00001fd2] 55 push ebp ; housekeeping
>>>>>>> [00001fd3] 8bec mov ebp,esp ; housekeeping
>>>>>>> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
>>>>>>> [00001fda] e8f3f9ffff call 000019d2 ; call H0
>>>>>>> [00001fdf] 83c404 add esp,+04 ; housekeeping
>>>>>>> [00001fe2] 5d pop ebp ; housekeeping
>>>>>>> [00001fe3] c3 ret ; return to caller
>>>>>>> Size in bytes:(0018) [00001fe3]
>>>>>>
>>>>>> So how is this a difference between the original version and V2 and V3?
>>>>>>
>>>>>
>>>>> No params thus easier to see that it pushes its own machine address.
>>>>
>>>> My question is still unanswered.
>>>>
>>>
>>> When I answer the question that the difference
>>> is that one of them had parameters and the other one
>>> does not have parameters it is dishonest of you
>>> to say that I did not answer the question.
>>
>> The qestion is not answered until you say which of the three versions
>> has parameters and which has not and how the third one differs from
>> the one that has parameters and from the one that nas not.
>>
>
> typedef void (*ptr)();
> int H0(ptr P);
> int H(ptr P, ptr I);
>
> void DDD()
> {
> H0(DDD);
> }
>
> void DDDD(ptr x)
> {
> H(x,x);
> }
>
> That seems to be saying that you don't know enough about the C
> programming language to know what a parameter is thus cannot
> tell the difference between DDD that has no parameters and DDDD
> that had one parameter.
My question is still unanswered. Apparently you do not undestand
the concept of question.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-20 00:19 -0500 |
| Message-ID | <v50e5o$2e5ij$2@dont-email.me> |
| In reply to | #107416 |
On 6/19/2024 3:36 AM, Mikko wrote:
> On 2024-06-18 18:55:21 +0000, olcott said:
>
>> On 6/18/2024 11:05 AM, Mikko wrote:
>>> On 2024-06-18 12:57:21 +0000, olcott said:
>>>
>>>> On 6/18/2024 3:03 AM, Mikko wrote:
>>>>> On 2024-06-17 13:03:56 +0000, olcott said:
>>>>>
>>>>>> On 6/17/2024 2:20 AM, Mikko wrote:
>>>>>>> On 2024-06-16 12:47:09 +0000, olcott said:
>>>>>>>
>>>>>>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>>>>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>>>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>>>>>>> >>
>>>>>>>>>> >> It is contingent upon you to show the exact steps of how H
>>>>>>>>>> computes
>>>>>>>>>> >> the mapping from the x86 machine language finite string
>>>>>>>>>> input to
>>>>>>>>>> >> H(D,D) using the finite string transformation rules
>>>>>>>>>> specified by
>>>>>>>>>> >> the semantics of the x86 programming language that reaches
>>>>>>>>>> the
>>>>>>>>>> >> behavior of the directly executed D(D)
>>>>>>>>>> >>
>>>>>>>>>> >
>>>>>>>>>> > Why? I don't claim it can.
>>>>>>>>>>
>>>>>>>>>> The first six steps of this mapping are when instructions
>>>>>>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>>>>>>> are simulated/executed.
>>>>>>>>>>
>>>>>>>>>> After that the behavior of D correctly simulated by H diverges
>>>>>>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>>>>>>> correctly simulated by H cannot possibly return to D.
>>>>>>>>>>
>>>>>>>>>> _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]
>>>>>>>>>
>>>>>>>>> When you put "V2" or "V3" or something similar on the subject line
>>>>>>>>> you should tell what is different from the original version.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I ask what are the steps
>>>>>>>> I provide 6 steps and then ask what are the next steps.
>>>>>>>> I provide all of the steps.
>>>>>>>
>>>>>>> In which version?
>>>>>>>
>>>>>>
>>>>>> *This is the simplest possible version*
>>>>>>
>>>>>> void DDD()
>>>>>> {
>>>>>> H0(DDD);
>>>>>> }
>>>>>>
>>>>>> After six steps of DDD are correctly emulated by H0
>>>>>> what machine address of DDD would it be at?
>>>>>>
>>>>>> _DDD()
>>>>>> [00001fd2] 55 push ebp ; housekeeping
>>>>>> [00001fd3] 8bec mov ebp,esp ; housekeeping
>>>>>> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
>>>>>> [00001fda] e8f3f9ffff call 000019d2 ; call H0
>>>>>> [00001fdf] 83c404 add esp,+04 ; housekeeping
>>>>>> [00001fe2] 5d pop ebp ; housekeeping
>>>>>> [00001fe3] c3 ret ; return to caller
>>>>>> Size in bytes:(0018) [00001fe3]
>>>>>
>>>>> So how is this a difference between the original version and V2 and
>>>>> V3?
>>>>>
>>>>
>>>> No params thus easier to see that it pushes its own machine address.
>>>
>>> My question is still unanswered.
>>>
>>
>> When I answer the question that the difference
>> is that one of them had parameters and the other one
>> does not have parameters it is dishonest of you
>> to say that I did not answer the question.
>
> The qestion is not answered until you say which of the three versions
> has parameters and which has not and how the third one differs from
> the one that has parameters and from the one that nas not.
>
I just simplified it to the one with zero parameters.
void DDD()
{
HH0(DDD);
}
--
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 | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-18 14:04 -0500 |
| Message-ID | <v4slo4$1g4ib$1@dont-email.me> |
| In reply to | #107379 |
On 6/18/2024 11:05 AM, Mikko wrote:
> On 2024-06-18 12:57:21 +0000, olcott said:
>
>> On 6/18/2024 3:03 AM, Mikko wrote:
>>> On 2024-06-17 13:03:56 +0000, olcott said:
>>>
>>>> On 6/17/2024 2:20 AM, Mikko wrote:
>>>>> On 2024-06-16 12:47:09 +0000, olcott said:
>>>>>
>>>>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>>>>
>>>>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>>>>> >>
>>>>>>>> >> It is contingent upon you to show the exact steps of how H
>>>>>>>> computes
>>>>>>>> >> the mapping from the x86 machine language finite string
>>>>>>>> input to
>>>>>>>> >> H(D,D) using the finite string transformation rules
>>>>>>>> specified by
>>>>>>>> >> the semantics of the x86 programming language that reaches the
>>>>>>>> >> behavior of the directly executed D(D)
>>>>>>>> >>
>>>>>>>> >
>>>>>>>> > Why? I don't claim it can.
>>>>>>>>
>>>>>>>> The first six steps of this mapping are when instructions
>>>>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>>>>> are simulated/executed.
>>>>>>>>
>>>>>>>> After that the behavior of D correctly simulated by H diverges
>>>>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>>>>> correctly simulated by H cannot possibly return to D.
>>>>>>>>
>>>>>>>> _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]
>>>>>>>
>>>>>>> When you put "V2" or "V3" or something similar on the subject line
>>>>>>> you should tell what is different from the original version.
>>>>>>>
>>>>>>
>>>>>> I ask what are the steps
>>>>>> I provide 6 steps and then ask what are the next steps.
>>>>>> I provide all of the steps.
>>>>>
>>>>> In which version?
>>>>>
>>>>
>>>> *This is the simplest possible version*
>>>>
>>>> void DDD()
>>>> {
>>>> H0(DDD);
>>>> }
>>>>
>>>> After six steps of DDD are correctly emulated by H0
>>>> what machine address of DDD would it be at?
>>>>
>>>> _DDD()
>>>> [00001fd2] 55 push ebp ; housekeeping
>>>> [00001fd3] 8bec mov ebp,esp ; housekeeping
>>>> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
>>>> [00001fda] e8f3f9ffff call 000019d2 ; call H0
>>>> [00001fdf] 83c404 add esp,+04 ; housekeeping
>>>> [00001fe2] 5d pop ebp ; housekeeping
>>>> [00001fe3] c3 ret ; return to caller
>>>> Size in bytes:(0018) [00001fe3]
>>>
>>> So how is this a difference between the original version and V2 and V3?
>>>
>>
>> No params thus easier to see that it pushes its own machine address.
>
> My question is still unanswered.
>
*The simplest possible case*
void DDD()
{
H0(DDD);
}
*The next simplest case*
typedef void (*ptr)();
void DDD(ptr x)
{
HH(x, x);
}
*The conventional case*
typedef int (*ptr2)();
int P(ptr2 x)
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
I had to keep dumbing it down to make it more
difficult to reject out-of-hand without review.
--
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-19 09:58 +0200 |
| Message-ID | <v4u33c$1rrod$1@dont-email.me> |
| In reply to | #107397 |
Op 18.jun.2024 om 21:04 schreef olcott:
> On 6/18/2024 11:05 AM, Mikko wrote:
>> On 2024-06-18 12:57:21 +0000, olcott said:
>>
>>> On 6/18/2024 3:03 AM, Mikko wrote:
>>>> On 2024-06-17 13:03:56 +0000, olcott said:
>>>>
>>>>> On 6/17/2024 2:20 AM, Mikko wrote:
>>>>>> On 2024-06-16 12:47:09 +0000, olcott said:
>>>>>>
>>>>>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>>>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>>>>>> >>
>>>>>>>>> >> It is contingent upon you to show the exact steps of how H
>>>>>>>>> computes
>>>>>>>>> >> the mapping from the x86 machine language finite string
>>>>>>>>> input to
>>>>>>>>> >> H(D,D) using the finite string transformation rules
>>>>>>>>> specified by
>>>>>>>>> >> the semantics of the x86 programming language that reaches the
>>>>>>>>> >> behavior of the directly executed D(D)
>>>>>>>>> >>
>>>>>>>>> >
>>>>>>>>> > Why? I don't claim it can.
>>>>>>>>>
>>>>>>>>> The first six steps of this mapping are when instructions
>>>>>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>>>>>> are simulated/executed.
>>>>>>>>>
>>>>>>>>> After that the behavior of D correctly simulated by H diverges
>>>>>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>>>>>> correctly simulated by H cannot possibly return to D.
>>>>>>>>>
>>>>>>>>> _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]
>>>>>>>>
>>>>>>>> When you put "V2" or "V3" or something similar on the subject line
>>>>>>>> you should tell what is different from the original version.
>>>>>>>>
>>>>>>>
>>>>>>> I ask what are the steps
>>>>>>> I provide 6 steps and then ask what are the next steps.
>>>>>>> I provide all of the steps.
>>>>>>
>>>>>> In which version?
>>>>>>
>>>>>
>>>>> *This is the simplest possible version*
>>>>>
>>>>> void DDD()
>>>>> {
>>>>> H0(DDD);
>>>>> }
>>>>>
>>>>> After six steps of DDD are correctly emulated by H0
>>>>> what machine address of DDD would it be at?
>>>>>
>>>>> _DDD()
>>>>> [00001fd2] 55 push ebp ; housekeeping
>>>>> [00001fd3] 8bec mov ebp,esp ; housekeeping
>>>>> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
>>>>> [00001fda] e8f3f9ffff call 000019d2 ; call H0
>>>>> [00001fdf] 83c404 add esp,+04 ; housekeeping
>>>>> [00001fe2] 5d pop ebp ; housekeeping
>>>>> [00001fe3] c3 ret ; return to caller
>>>>> Size in bytes:(0018) [00001fe3]
>>>>
>>>> So how is this a difference between the original version and V2 and V3?
>>>>
>>>
>>> No params thus easier to see that it pushes its own machine address.
>>
>> My question is still unanswered.
>>
>
> *The simplest possible case*
> void DDD()
> {
> H0(DDD);
> }
>
> *The next simplest case*
> typedef void (*ptr)();
> void DDD(ptr x)
> {
> HH(x, x);
> }
>
> *The conventional case*
> typedef int (*ptr2)();
> int P(ptr2 x)
> {
> int Halt_Status = H(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return Halt_Status;
> }
>
> I had to keep dumbing it down to make it more
> difficult to reject out-of-hand without review.
No, this is not the simplest case. You are making it unnecessary
complex. The simplest case is:
int main()
{
return H(main, 0);
}
No D, DD, or DDD is needed.
For this case you proved that main halts, whereas H reports non-halting,
i.e. a false negative.
This shows that in your more complex (but equivalent) cases there is
also a false negative.
Of course, you prefer the more complex cases, because there you can play
your invalid claim that the direct execution and the simulation of
DDD(DDD) show different behaviour., but the simplest case shows that it
is not true. It is just a false negative.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-19 07:58 -0500 |
| Message-ID | <v4ukld$1vpm0$1@dont-email.me> |
| In reply to | #107412 |
On 6/19/2024 2:58 AM, Fred. Zwarts wrote:
> Op 18.jun.2024 om 21:04 schreef olcott:
>> On 6/18/2024 11:05 AM, Mikko wrote:
>>> On 2024-06-18 12:57:21 +0000, olcott said:
>>>
>>>> On 6/18/2024 3:03 AM, Mikko wrote:
>>>>> On 2024-06-17 13:03:56 +0000, olcott said:
>>>>>
>>>>>> On 6/17/2024 2:20 AM, Mikko wrote:
>>>>>>> On 2024-06-16 12:47:09 +0000, olcott said:
>>>>>>>
>>>>>>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>>>>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>>>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>>>>>>> >>
>>>>>>>>>> >> It is contingent upon you to show the exact steps of how H
>>>>>>>>>> computes
>>>>>>>>>> >> the mapping from the x86 machine language finite string
>>>>>>>>>> input to
>>>>>>>>>> >> H(D,D) using the finite string transformation rules
>>>>>>>>>> specified by
>>>>>>>>>> >> the semantics of the x86 programming language that reaches
>>>>>>>>>> the
>>>>>>>>>> >> behavior of the directly executed D(D)
>>>>>>>>>> >>
>>>>>>>>>> >
>>>>>>>>>> > Why? I don't claim it can.
>>>>>>>>>>
>>>>>>>>>> The first six steps of this mapping are when instructions
>>>>>>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>>>>>>> are simulated/executed.
>>>>>>>>>>
>>>>>>>>>> After that the behavior of D correctly simulated by H diverges
>>>>>>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>>>>>>> correctly simulated by H cannot possibly return to D.
>>>>>>>>>>
>>>>>>>>>> _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]
>>>>>>>>>
>>>>>>>>> When you put "V2" or "V3" or something similar on the subject line
>>>>>>>>> you should tell what is different from the original version.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I ask what are the steps
>>>>>>>> I provide 6 steps and then ask what are the next steps.
>>>>>>>> I provide all of the steps.
>>>>>>>
>>>>>>> In which version?
>>>>>>>
>>>>>>
>>>>>> *This is the simplest possible version*
>>>>>>
>>>>>> void DDD()
>>>>>> {
>>>>>> H0(DDD);
>>>>>> }
>>>>>>
>>>>>> After six steps of DDD are correctly emulated by H0
>>>>>> what machine address of DDD would it be at?
>>>>>>
>>>>>> _DDD()
>>>>>> [00001fd2] 55 push ebp ; housekeeping
>>>>>> [00001fd3] 8bec mov ebp,esp ; housekeeping
>>>>>> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
>>>>>> [00001fda] e8f3f9ffff call 000019d2 ; call H0
>>>>>> [00001fdf] 83c404 add esp,+04 ; housekeeping
>>>>>> [00001fe2] 5d pop ebp ; housekeeping
>>>>>> [00001fe3] c3 ret ; return to caller
>>>>>> Size in bytes:(0018) [00001fe3]
>>>>>
>>>>> So how is this a difference between the original version and V2 and
>>>>> V3?
>>>>>
>>>>
>>>> No params thus easier to see that it pushes its own machine address.
>>>
>>> My question is still unanswered.
>>>
>>
>> *The simplest possible case*
>> void DDD()
>> {
>> H0(DDD);
>> }
>>
>> *The next simplest case*
>> typedef void (*ptr)();
>> void DDD(ptr x)
>> {
>> HH(x, x);
>> }
>>
>> *The conventional case*
>> typedef int (*ptr2)();
>> int P(ptr2 x)
>> {
>> int Halt_Status = H(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return Halt_Status;
>> }
>>
>> I had to keep dumbing it down to make it more
>> difficult to reject out-of-hand without review.
>
> No, this is not the simplest case. You are making it unnecessary
> complex. The simplest case is:
>
> int main()
> {
> return H(main, 0);
> }
>
> No D, DD, or DDD is needed.
> For this case you proved that main halts, whereas H reports non-halting,
> i.e. a false negative.
> This shows that in your more complex (but equivalent) cases there is
> also a false negative.
> Of course, you prefer the more complex cases, because there you can play
> your invalid claim that the direct execution and the simulation of
> DDD(DDD) show different behaviour., but the simplest case shows that it
> is not true. It is just a false negative.
_DDD()
[000020a2] 55 push ebp ; housekeeping
[000020a3] 8bec mov ebp,esp ; housekeeping
[000020a5] 68a2200000 push 000020a2 ; push DDD
[000020aa] e8f3f9ffff call 00001aa2 ; call H0
[000020af] 83c404 add esp,+04 ; housekeeping
[000020b2] 5d pop ebp ; housekeeping
[000020b3] c3 ret ; never gets here
Size in bytes:(0018) [000020b3]
Exactly which step of DDD emulated by H0 was emulated
incorrectly such that this emulation would be complete?
AKA DDD emulated by H0 reaches machine address [000020b3]
--
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-19 15:46 +0200 |
| Message-ID | <v4unf7$1vtc8$1@dont-email.me> |
| In reply to | #107423 |
Op 19.jun.2024 om 14:58 schreef olcott:
> On 6/19/2024 2:58 AM, Fred. Zwarts wrote:
>> Op 18.jun.2024 om 21:04 schreef olcott:
>>> On 6/18/2024 11:05 AM, Mikko wrote:
>>>> On 2024-06-18 12:57:21 +0000, olcott said:
>>>>
>>>>> On 6/18/2024 3:03 AM, Mikko wrote:
>>>>>> On 2024-06-17 13:03:56 +0000, olcott said:
>>>>>>
>>>>>>> On 6/17/2024 2:20 AM, Mikko wrote:
>>>>>>>> On 2024-06-16 12:47:09 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>>>>>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>>>>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>>>>>>>> >>
>>>>>>>>>>> >> It is contingent upon you to show the exact steps of how
>>>>>>>>>>> H computes
>>>>>>>>>>> >> the mapping from the x86 machine language finite string
>>>>>>>>>>> input to
>>>>>>>>>>> >> H(D,D) using the finite string transformation rules
>>>>>>>>>>> specified by
>>>>>>>>>>> >> the semantics of the x86 programming language that
>>>>>>>>>>> reaches the
>>>>>>>>>>> >> behavior of the directly executed D(D)
>>>>>>>>>>> >>
>>>>>>>>>>> >
>>>>>>>>>>> > Why? I don't claim it can.
>>>>>>>>>>>
>>>>>>>>>>> The first six steps of this mapping are when instructions
>>>>>>>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>>>>>>>> are simulated/executed.
>>>>>>>>>>>
>>>>>>>>>>> After that the behavior of D correctly simulated by H diverges
>>>>>>>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>>>>>>>> correctly simulated by H cannot possibly return to D.
>>>>>>>>>>>
>>>>>>>>>>> _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]
>>>>>>>>>>
>>>>>>>>>> When you put "V2" or "V3" or something similar on the subject
>>>>>>>>>> line
>>>>>>>>>> you should tell what is different from the original version.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I ask what are the steps
>>>>>>>>> I provide 6 steps and then ask what are the next steps.
>>>>>>>>> I provide all of the steps.
>>>>>>>>
>>>>>>>> In which version?
>>>>>>>>
>>>>>>>
>>>>>>> *This is the simplest possible version*
>>>>>>>
>>>>>>> void DDD()
>>>>>>> {
>>>>>>> H0(DDD);
>>>>>>> }
>>>>>>>
>>>>>>> After six steps of DDD are correctly emulated by H0
>>>>>>> what machine address of DDD would it be at?
>>>>>>>
>>>>>>> _DDD()
>>>>>>> [00001fd2] 55 push ebp ; housekeeping
>>>>>>> [00001fd3] 8bec mov ebp,esp ; housekeeping
>>>>>>> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
>>>>>>> [00001fda] e8f3f9ffff call 000019d2 ; call H0
>>>>>>> [00001fdf] 83c404 add esp,+04 ; housekeeping
>>>>>>> [00001fe2] 5d pop ebp ; housekeeping
>>>>>>> [00001fe3] c3 ret ; return to caller
>>>>>>> Size in bytes:(0018) [00001fe3]
>>>>>>
>>>>>> So how is this a difference between the original version and V2
>>>>>> and V3?
>>>>>>
>>>>>
>>>>> No params thus easier to see that it pushes its own machine address.
>>>>
>>>> My question is still unanswered.
>>>>
>>>
>>> *The simplest possible case*
>>> void DDD()
>>> {
>>> H0(DDD);
>>> }
>>>
>>> *The next simplest case*
>>> typedef void (*ptr)();
>>> void DDD(ptr x)
>>> {
>>> HH(x, x);
>>> }
>>>
>>> *The conventional case*
>>> typedef int (*ptr2)();
>>> int P(ptr2 x)
>>> {
>>> int Halt_Status = H(x, x);
>>> if (Halt_Status)
>>> HERE: goto HERE;
>>> return Halt_Status;
>>> }
>>>
>>> I had to keep dumbing it down to make it more
>>> difficult to reject out-of-hand without review.
>>
>> No, this is not the simplest case. You are making it unnecessary
>> complex. The simplest case is:
>>
>> int main()
>> {
>> return H(main, 0);
>> }
>>
>> No D, DD, or DDD is needed.
>> For this case you proved that main halts, whereas H reports
>> non-halting, i.e. a false negative.
>> This shows that in your more complex (but equivalent) cases there is
>> also a false negative.
>> Of course, you prefer the more complex cases, because there you can
>> play your invalid claim that the direct execution and the simulation
>> of DDD(DDD) show different behaviour., but the simplest case shows
>> that it is not true. It is just a false negative.
>
> _DDD()
> [000020a2] 55 push ebp ; housekeeping
> [000020a3] 8bec mov ebp,esp ; housekeeping
> [000020a5] 68a2200000 push 000020a2 ; push DDD
> [000020aa] e8f3f9ffff call 00001aa2 ; call H0
> [000020af] 83c404 add esp,+04 ; housekeeping
> [000020b2] 5d pop ebp ; housekeeping
> [000020b3] c3 ret ; never gets here
> Size in bytes:(0018) [000020b3]
>
> Exactly which step of DDD emulated by H0 was emulated
> incorrectly such that this emulation would be complete?
> AKA DDD emulated by H0 reaches machine address [000020b3]
>
>
That has been pointed out to you so many times. It seems really to
difficult for you. So, you prefer to forget or ignore it.
The 'call' instruction at 000020aa is incorrectly simulated. H0 is
required to halt, i.e. to return, but your simulation does not show the
'ret' instruction of H0.
It seems you are so confused that you do not understand it. Therefore,
you think it is a change of subject or gibberish. Showing that it is
over your head.
Instead of fixing the problem, you just repeat the claim without any new
argument.
The simulation fails, because it is aborted one cycle too soon, before
the simulated H0 would reach its 'ret' instruction. A correct simulation
would see this. Unfortunately, H0 is unable to correctly simulate itself.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-19 09:55 -0500 |
| Message-ID | <v4urgp$21810$1@dont-email.me> |
| In reply to | #107431 |
On 6/19/2024 8:46 AM, Fred. Zwarts wrote:
> Op 19.jun.2024 om 14:58 schreef olcott:
>> On 6/19/2024 2:58 AM, Fred. Zwarts wrote:
>>> Op 18.jun.2024 om 21:04 schreef olcott:
>>>> On 6/18/2024 11:05 AM, Mikko wrote:
>>>>> On 2024-06-18 12:57:21 +0000, olcott said:
>>>>>
>>>>>> On 6/18/2024 3:03 AM, Mikko wrote:
>>>>>>> On 2024-06-17 13:03:56 +0000, olcott said:
>>>>>>>
>>>>>>>> On 6/17/2024 2:20 AM, Mikko wrote:
>>>>>>>>> On 2024-06-16 12:47:09 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>>>>>>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>>>>>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>>>>>>>>> >>
>>>>>>>>>>>> >> It is contingent upon you to show the exact steps of how
>>>>>>>>>>>> H computes
>>>>>>>>>>>> >> the mapping from the x86 machine language finite string
>>>>>>>>>>>> input to
>>>>>>>>>>>> >> H(D,D) using the finite string transformation rules
>>>>>>>>>>>> specified by
>>>>>>>>>>>> >> the semantics of the x86 programming language that
>>>>>>>>>>>> reaches the
>>>>>>>>>>>> >> behavior of the directly executed D(D)
>>>>>>>>>>>> >>
>>>>>>>>>>>> >
>>>>>>>>>>>> > Why? I don't claim it can.
>>>>>>>>>>>>
>>>>>>>>>>>> The first six steps of this mapping are when instructions
>>>>>>>>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>>>>>>>>> are simulated/executed.
>>>>>>>>>>>>
>>>>>>>>>>>> After that the behavior of D correctly simulated by H diverges
>>>>>>>>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>>>>>>>>> correctly simulated by H cannot possibly return to D.
>>>>>>>>>>>>
>>>>>>>>>>>> _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]
>>>>>>>>>>>
>>>>>>>>>>> When you put "V2" or "V3" or something similar on the subject
>>>>>>>>>>> line
>>>>>>>>>>> you should tell what is different from the original version.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I ask what are the steps
>>>>>>>>>> I provide 6 steps and then ask what are the next steps.
>>>>>>>>>> I provide all of the steps.
>>>>>>>>>
>>>>>>>>> In which version?
>>>>>>>>>
>>>>>>>>
>>>>>>>> *This is the simplest possible version*
>>>>>>>>
>>>>>>>> void DDD()
>>>>>>>> {
>>>>>>>> H0(DDD);
>>>>>>>> }
>>>>>>>>
>>>>>>>> After six steps of DDD are correctly emulated by H0
>>>>>>>> what machine address of DDD would it be at?
>>>>>>>>
>>>>>>>> _DDD()
>>>>>>>> [00001fd2] 55 push ebp ; housekeeping
>>>>>>>> [00001fd3] 8bec mov ebp,esp ; housekeeping
>>>>>>>> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
>>>>>>>> [00001fda] e8f3f9ffff call 000019d2 ; call H0
>>>>>>>> [00001fdf] 83c404 add esp,+04 ; housekeeping
>>>>>>>> [00001fe2] 5d pop ebp ; housekeeping
>>>>>>>> [00001fe3] c3 ret ; return to caller
>>>>>>>> Size in bytes:(0018) [00001fe3]
>>>>>>>
>>>>>>> So how is this a difference between the original version and V2
>>>>>>> and V3?
>>>>>>>
>>>>>>
>>>>>> No params thus easier to see that it pushes its own machine address.
>>>>>
>>>>> My question is still unanswered.
>>>>>
>>>>
>>>> *The simplest possible case*
>>>> void DDD()
>>>> {
>>>> H0(DDD);
>>>> }
>>>>
>>>> *The next simplest case*
>>>> typedef void (*ptr)();
>>>> void DDD(ptr x)
>>>> {
>>>> HH(x, x);
>>>> }
>>>>
>>>> *The conventional case*
>>>> typedef int (*ptr2)();
>>>> int P(ptr2 x)
>>>> {
>>>> int Halt_Status = H(x, x);
>>>> if (Halt_Status)
>>>> HERE: goto HERE;
>>>> return Halt_Status;
>>>> }
>>>>
>>>> I had to keep dumbing it down to make it more
>>>> difficult to reject out-of-hand without review.
>>>
>>> No, this is not the simplest case. You are making it unnecessary
>>> complex. The simplest case is:
>>>
>>> int main()
>>> {
>>> return H(main, 0);
>>> }
>>>
>>> No D, DD, or DDD is needed.
>>> For this case you proved that main halts, whereas H reports
>>> non-halting, i.e. a false negative.
>>> This shows that in your more complex (but equivalent) cases there is
>>> also a false negative.
>>> Of course, you prefer the more complex cases, because there you can
>>> play your invalid claim that the direct execution and the simulation
>>> of DDD(DDD) show different behaviour., but the simplest case shows
>>> that it is not true. It is just a false negative.
>>
>> _DDD()
>> [000020a2] 55 push ebp ; housekeeping
>> [000020a3] 8bec mov ebp,esp ; housekeeping
>> [000020a5] 68a2200000 push 000020a2 ; push DDD
>> [000020aa] e8f3f9ffff call 00001aa2 ; call H0
>> [000020af] 83c404 add esp,+04 ; housekeeping
>> [000020b2] 5d pop ebp ; housekeeping
>> [000020b3] c3 ret ; never gets here
>> Size in bytes:(0018) [000020b3]
>>
>> Exactly which step of DDD emulated by H0 was emulated
>> incorrectly such that this emulation would be complete?
>> AKA DDD emulated by H0 reaches machine address [000020b3]
>>
>>
>
> That has been pointed out to you so many times.
When falsehoods are pointed out an unlimited number of times
they still remain falsehoods.
> It seems really to
> difficult for you. So, you prefer to forget or ignore it.
> The 'call' instruction at 000020aa is incorrectly simulated.
As a matter of fact it is not incorrectly simulated.
I am showing this with HH0 instead of H0 because
the trace provided by HH0 is easier to understand.
void DDD()
{
HH0(DDD);
}
int main()
{
HH0(DDD);
}
_DDD()
[00002093] 55 push ebp
[00002094] 8bec mov ebp,esp
[00002096] 6893200000 push 00002093 ; push DDD
[0000209b] e853f4ffff call 000014f3 ; call HH0
[000020a0] 83c404 add esp,+04
[000020a3] 5d pop ebp
[000020a4] c3 ret
Size in bytes:(0018) [000020a4]
_main()
[000020b3] 55 push ebp
[000020b4] 8bec mov ebp,esp
[000020b6] 6893200000 push 00002093 ; push DDD
[000020bb] e833f4ffff call 000014f3 ; call HH0
[000020c0] 83c404 add esp,+04
[000020c3] eb04 jmp 000020c9
[000020c5] 33c0 xor eax,eax
[000020c7] eb02 jmp 000020cb
[000020c9] 33c0 xor eax,eax
[000020cb] 5d pop ebp
[000020cc] c3 ret
Size in bytes:(0026) [000020cc]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[000020b3][00103680][00000000] 55 push ebp ; begin main
[000020b4][00103680][00000000] 8bec mov ebp,esp
[000020b6][0010367c][00002093] 6893200000 push 00002093 ; push DDD
[000020bb][00103678][000020c0] e833f4ffff call 000014f3 ; call HH0
New slave_stack at:103724
Begin Local Halt Decider Simulation Execution Trace Stored at:11372c
[00002093][0011371c][00113720] 55 push ebp ; begin DDD
[00002094][0011371c][00113720] 8bec mov ebp,esp
[00002096][00113718][00002093] 6893200000 push 00002093 ; push DDD
[0000209b][00113714][000020a0] e853f4ffff call 000014f3 ; call HH0
New slave_stack at:14e14c
[00002093][0015e144][0015e148] 55 push ebp ; begin DDD
[00002094][0015e144][0015e148] 8bec mov ebp,esp
[00002096][0015e140][00002093] 6893200000 push 00002093 ; push DDD
[0000209b][0015e13c][000020a0] e853f4ffff call 000014f3 ; call HH0
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
[000020c0][00103680][00000000] 83c404 add esp,+04 ; return to main
[000020c3][00103680][00000000] eb04 jmp 000020c9
[000020c9][00103680][00000000] 33c0 xor eax,eax
[000020cb][00103684][00000018] 5d pop ebp
[000020cc][00103688][00000000] c3 ret ; end main
Number of Instructions Executed(10067) == 150 Pages
> H0 is
> required to halt, i.e. to return, but your simulation does not show the
> 'ret' instruction of H0.
Yes it does not show this yet HH0 does simulate itself simulating DDD.
If the eight lines of DDD correctly simulated by HH0 were mixed in
with the 150 pages of HH0 simulating itself it would be too difficult
to see the behavior of DDD. The reader would have to carefully search
for the machine addresses of DDD that only occur every 19 pages.
I will adapt HH0 so that it does show HH0 simulating itself
simulating DDD.
> It seems you are so confused that you do not understand it. Therefore,
> you think it is a change of subject or gibberish. Showing that it is
> over your head.
> Instead of fixing the problem, you just repeat the claim without any new
> argument.
> The simulation fails, because it is aborted one cycle too soon, before
> the simulated H0 would reach its 'ret' instruction. A correct simulation
> would see this. Unfortunately, H0 is unable to correctly simulate itself.
Because the executed HH0 always has at least one more execution trace
than any of its simulated instances unless it aborts the simulation
after a fixed number of repeating states, none of them do. If this
is permanently over-your-head then we need to stop talking.
--
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-19 17:39 +0200 |
| Message-ID | <v4uu3k$1vtc8$4@dont-email.me> |
| In reply to | #107437 |
Op 19.jun.2024 om 16:55 schreef olcott:
> On 6/19/2024 8:46 AM, Fred. Zwarts wrote:
>> Op 19.jun.2024 om 14:58 schreef olcott:
>>> On 6/19/2024 2:58 AM, Fred. Zwarts wrote:
>>>> Op 18.jun.2024 om 21:04 schreef olcott:
>>>>> On 6/18/2024 11:05 AM, Mikko wrote:
>>>>>> On 2024-06-18 12:57:21 +0000, olcott said:
>>>>>>
>>>>>>> On 6/18/2024 3:03 AM, Mikko wrote:
>>>>>>>> On 2024-06-17 13:03:56 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 6/17/2024 2:20 AM, Mikko wrote:
>>>>>>>>>> On 2024-06-16 12:47:09 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 6/16/2024 2:53 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-06-15 16:22:09 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 6/13/2024 8:24 PM, Richard Damon wrote:
>>>>>>>>>>>>> > On 6/13/24 11:32 AM, olcott wrote:
>>>>>>>>>>>>> >>
>>>>>>>>>>>>> >> It is contingent upon you to show the exact steps of
>>>>>>>>>>>>> how H computes
>>>>>>>>>>>>> >> the mapping from the x86 machine language finite string
>>>>>>>>>>>>> input to
>>>>>>>>>>>>> >> H(D,D) using the finite string transformation rules
>>>>>>>>>>>>> specified by
>>>>>>>>>>>>> >> the semantics of the x86 programming language that
>>>>>>>>>>>>> reaches the
>>>>>>>>>>>>> >> behavior of the directly executed D(D)
>>>>>>>>>>>>> >>
>>>>>>>>>>>>> >
>>>>>>>>>>>>> > Why? I don't claim it can.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The first six steps of this mapping are when instructions
>>>>>>>>>>>>> at the machine address range of [00000cfc] to [00000d06]
>>>>>>>>>>>>> are simulated/executed.
>>>>>>>>>>>>>
>>>>>>>>>>>>> After that the behavior of D correctly simulated by H diverges
>>>>>>>>>>>>> from the behavior of D(D) because the call to H(D,D) by D
>>>>>>>>>>>>> correctly simulated by H cannot possibly return to D.
>>>>>>>>>>>>>
>>>>>>>>>>>>> _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]
>>>>>>>>>>>>
>>>>>>>>>>>> When you put "V2" or "V3" or something similar on the
>>>>>>>>>>>> subject line
>>>>>>>>>>>> you should tell what is different from the original version.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I ask what are the steps
>>>>>>>>>>> I provide 6 steps and then ask what are the next steps.
>>>>>>>>>>> I provide all of the steps.
>>>>>>>>>>
>>>>>>>>>> In which version?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *This is the simplest possible version*
>>>>>>>>>
>>>>>>>>> void DDD()
>>>>>>>>> {
>>>>>>>>> H0(DDD);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> After six steps of DDD are correctly emulated by H0
>>>>>>>>> what machine address of DDD would it be at?
>>>>>>>>>
>>>>>>>>> _DDD()
>>>>>>>>> [00001fd2] 55 push ebp ; housekeeping
>>>>>>>>> [00001fd3] 8bec mov ebp,esp ; housekeeping
>>>>>>>>> [00001fd5] 68d21f0000 push 00001fd2 ; push DDD
>>>>>>>>> [00001fda] e8f3f9ffff call 000019d2 ; call H0
>>>>>>>>> [00001fdf] 83c404 add esp,+04 ; housekeeping
>>>>>>>>> [00001fe2] 5d pop ebp ; housekeeping
>>>>>>>>> [00001fe3] c3 ret ; return to caller
>>>>>>>>> Size in bytes:(0018) [00001fe3]
>>>>>>>>
>>>>>>>> So how is this a difference between the original version and V2
>>>>>>>> and V3?
>>>>>>>>
>>>>>>>
>>>>>>> No params thus easier to see that it pushes its own machine address.
>>>>>>
>>>>>> My question is still unanswered.
>>>>>>
>>>>>
>>>>> *The simplest possible case*
>>>>> void DDD()
>>>>> {
>>>>> H0(DDD);
>>>>> }
>>>>>
>>>>> *The next simplest case*
>>>>> typedef void (*ptr)();
>>>>> void DDD(ptr x)
>>>>> {
>>>>> HH(x, x);
>>>>> }
>>>>>
>>>>> *The conventional case*
>>>>> typedef int (*ptr2)();
>>>>> int P(ptr2 x)
>>>>> {
>>>>> int Halt_Status = H(x, x);
>>>>> if (Halt_Status)
>>>>> HERE: goto HERE;
>>>>> return Halt_Status;
>>>>> }
>>>>>
>>>>> I had to keep dumbing it down to make it more
>>>>> difficult to reject out-of-hand without review.
>>>>
>>>> No, this is not the simplest case. You are making it unnecessary
>>>> complex. The simplest case is:
>>>>
>>>> int main()
>>>> {
>>>> return H(main, 0);
>>>> }
>>>>
>>>> No D, DD, or DDD is needed.
>>>> For this case you proved that main halts, whereas H reports
>>>> non-halting, i.e. a false negative.
>>>> This shows that in your more complex (but equivalent) cases there is
>>>> also a false negative.
>>>> Of course, you prefer the more complex cases, because there you can
>>>> play your invalid claim that the direct execution and the simulation
>>>> of DDD(DDD) show different behaviour., but the simplest case shows
>>>> that it is not true. It is just a false negative.
>>>
>>> _DDD()
>>> [000020a2] 55 push ebp ; housekeeping
>>> [000020a3] 8bec mov ebp,esp ; housekeeping
>>> [000020a5] 68a2200000 push 000020a2 ; push DDD
>>> [000020aa] e8f3f9ffff call 00001aa2 ; call H0
>>> [000020af] 83c404 add esp,+04 ; housekeeping
>>> [000020b2] 5d pop ebp ; housekeeping
>>> [000020b3] c3 ret ; never gets here
>>> Size in bytes:(0018) [000020b3]
>>>
>>> Exactly which step of DDD emulated by H0 was emulated
>>> incorrectly such that this emulation would be complete?
>>> AKA DDD emulated by H0 reaches machine address [000020b3]
>>>
>>>
>>
>> That has been pointed out to you so many times.
>
> When falsehoods are pointed out an unlimited number of times
> they still remain falsehoods.
>
>> It seems really to difficult for you. So, you prefer to forget or
>> ignore it.
>> The 'call' instruction at 000020aa is incorrectly simulated.
>
> As a matter of fact it is not incorrectly simulated.
> I am showing this with HH0 instead of H0 because
> the trace provided by HH0 is easier to understand.
>
> void DDD()
> {
> HH0(DDD);
> }
>
> int main()
> {
> HH0(DDD);
> }
>
> _DDD()
> [00002093] 55 push ebp
> [00002094] 8bec mov ebp,esp
> [00002096] 6893200000 push 00002093 ; push DDD
> [0000209b] e853f4ffff call 000014f3 ; call HH0
> [000020a0] 83c404 add esp,+04
> [000020a3] 5d pop ebp
> [000020a4] c3 ret
> Size in bytes:(0018) [000020a4]
>
> _main()
> [000020b3] 55 push ebp
> [000020b4] 8bec mov ebp,esp
> [000020b6] 6893200000 push 00002093 ; push DDD
> [000020bb] e833f4ffff call 000014f3 ; call HH0
> [000020c0] 83c404 add esp,+04
> [000020c3] eb04 jmp 000020c9
> [000020c5] 33c0 xor eax,eax
> [000020c7] eb02 jmp 000020cb
> [000020c9] 33c0 xor eax,eax
> [000020cb] 5d pop ebp
> [000020cc] c3 ret
> Size in bytes:(0026) [000020cc]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> [000020b3][00103680][00000000] 55 push ebp ; begin main
> [000020b4][00103680][00000000] 8bec mov ebp,esp
> [000020b6][0010367c][00002093] 6893200000 push 00002093 ; push DDD
> [000020bb][00103678][000020c0] e833f4ffff call 000014f3 ; call HH0
> New slave_stack at:103724
>
> Begin Local Halt Decider Simulation Execution Trace Stored at:11372c
> [00002093][0011371c][00113720] 55 push ebp ; begin DDD
> [00002094][0011371c][00113720] 8bec mov ebp,esp
> [00002096][00113718][00002093] 6893200000 push 00002093 ; push DDD
> [0000209b][00113714][000020a0] e853f4ffff call 000014f3 ; call HH0
> New slave_stack at:14e14c
> [00002093][0015e144][0015e148] 55 push ebp ; begin DDD
> [00002094][0015e144][0015e148] 8bec mov ebp,esp
> [00002096][0015e140][00002093] 6893200000 push 00002093 ; push DDD
> [0000209b][0015e13c][000020a0] e853f4ffff call 000014f3 ; call HH0
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> [000020c0][00103680][00000000] 83c404 add esp,+04 ; return to main
> [000020c3][00103680][00000000] eb04 jmp 000020c9
> [000020c9][00103680][00000000] 33c0 xor eax,eax
> [000020cb][00103684][00000018] 5d pop ebp
> [000020cc][00103688][00000000] c3 ret ; end main
> Number of Instructions Executed(10067) == 150 Pages
>
>
>> H0 is required to halt, i.e. to return, but your simulation does not
>> show the 'ret' instruction of H0.
>
> Yes it does not show this yet HH0 does simulate itself simulating DDD.
>
> If the eight lines of DDD correctly simulated by HH0 were mixed in
> with the 150 pages of HH0 simulating itself it would be too difficult
> to see the behavior of DDD. The reader would have to carefully search
> for the machine addresses of DDD that only occur every 19 pages.
>
> I will adapt HH0 so that it does show HH0 simulating itself
> simulating DDD.
>
>> It seems you are so confused that you do not understand it. Therefore,
>> you think it is a change of subject or gibberish. Showing that it is
>> over your head.
>> Instead of fixing the problem, you just repeat the claim without any
>> new argument.
>> The simulation fails, because it is aborted one cycle too soon, before
>> the simulated H0 would reach its 'ret' instruction. A correct
>> simulation would see this. Unfortunately, H0 is unable to correctly
>> simulate itself.
>
> Because the executed HH0 always has at least one more execution trace
> than any of its simulated instances unless it aborts the simulation
> after a fixed number of repeating states, none of them do.
What is your problem:
1) You say: 'HH0 always has at least one more execution trace than any
of its simulated instances'. That is correct. That is true even if it
does abort. Is that over your head?
2) If it aborts, it misses the fact that the simulation of itself would
also abort one execution trace later. Is that over your head?
3) If it misses the fact that its simulation of itself would halt one
execution trace later, it is incorrect to report non-halting. Is that
over your head?
What is your problem: 1, 2, or 3.
If you do not even understand it, you better stop talking about it.
[toc] | [prev] | [next] | [standalone]
Page 2 of 3 — ← Prev page 1 [2] 3 Next page →
Back to top | Article view | comp.theory
csiph-web