Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #107679 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2024-06-23 08:40 -0500 |
| Last post | 2024-06-26 19:47 -0400 |
| Articles | 20 on this page of 106 — 3 participants |
Back to article view | Back to comp.theory
DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 08:40 -0500
Re: DDD correctly emulated by H0 --- Why Lie? (typo corrected) olcott <polcott333@gmail.com> - 2024-06-23 09:00 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 14:20 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 16:41 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 17:49 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 17:04 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 18:35 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 17:45 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 18:58 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 18:34 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 19:44 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 19:08 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 20:24 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 20:00 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 21:13 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 20:20 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 21:30 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 20:36 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 22:00 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 21:09 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 22:16 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 21:27 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 22:31 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 21:38 -0500
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 21:52 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 23:11 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 22:26 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-24 07:02 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-24 08:39 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-24 19:17 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-24 18:38 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-24 19:57 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-24 08:42 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-24 19:19 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-24 18:43 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-24 19:59 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 19:02 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 20:06 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 19:34 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 20:54 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 20:05 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 21:13 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 20:22 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 21:24 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure (typo) olcott <polcott333@gmail.com> - 2024-06-24 20:07 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure (typo) Richard Damon <richard@damon-family.org> - 2024-06-24 21:22 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 20:32 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 21:51 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 20:55 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 22:02 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 21:17 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 22:25 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 21:21 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 22:26 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 21:38 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 22:48 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 21:52 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-25 06:59 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 22:13 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-25 07:04 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-25 08:02 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-25 21:47 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-25 20:59 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-25 22:17 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-25 21:21 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-25 22:54 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-25 22:25 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-25 23:32 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-25 22:37 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 06:58 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 08:33 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 19:41 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 18:50 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 19:52 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 19:19 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 20:38 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 19:24 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 20:40 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 20:12 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 21:21 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 21:10 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 22:38 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 21:46 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 23:16 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 22:37 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-27 07:34 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-27 08:21 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-27 19:57 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-27 22:25 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-28 07:44 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-28 07:28 -0500
Re: Why Lie? -- Repeat until Closure joes <noreply@example.com> - 2024-06-28 12:58 +0000
Re: Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-28 09:33 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-28 23:49 -0400
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 23:09 -0400
Re: DDD correctly emulated by H0 --- Why Lie? joes <noreply@example.com> - 2024-06-25 09:14 +0000
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 20:33 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 22:03 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 21:13 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 22:28 -0400
Re: DDD correctly emulated by H0 --- Why Lie? joes <noreply@example.com> - 2024-06-24 19:44 +0000
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-24 15:05 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-24 19:19 -0400
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-26 07:02 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-26 08:48 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-26 19:47 -0400
Page 4 of 6 — ← Prev page 1 2 3 [4] 5 6 Next page →
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-25 08:02 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5ef4n$1ihbr$1@dont-email.me> |
| In reply to | #107783 |
On 6/25/2024 6:04 AM, Richard Damon wrote: > On 6/24/24 11:13 PM, olcott wrote: >> On 6/24/2024 9:48 PM, Richard Damon wrote: >>> On 6/24/24 10:38 PM, olcott wrote: >>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>> >>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>> >>>>>>> You still haven't shown where I lied, on where you don't like >>>>>>> what I say. >>>>>>> >>>>>>>> >>>>>>>> You said that D correctly simulated by H must >>>>>>>> have the behavior of the directly executed D(D). >>>>>>> >>>>>>> Right, the steps that H sees are IDENTIAL to the steps of the >>>>>>> directly executed D(D) until H stops its simulation, >>>>>>> >>>>>>> NOT ONE DIFFERENCE. >>>>>>> >>>>>> >>>>>> Honest mistake or liar? >>>>>> >>>>>> The directly executed D(D) has identical behavior to >>>>>> D correctly simulated by H1 >>>>>> *the call from D to H(D,D) returns* >>>>>> >>>>>> This is not the same behavior as >>>>>> D correctly simulated by H >>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>> >>>>> >>>>> And what instruction did H's simulation differ from the direct >>>>> executions trace? >>>>> >>>> >>>> D correctly simulated by H >>>> *the call from D to H(D,D) DOES NOT return* >>> >>> Which isn't "Behavior of the input" >>> >>> The "not happening" of something that could have happened except that >>> the processing was stoped is NOT behavior. >>> >>>> >>>> D correctly simulated by H1 --- Identical to D(D) >>>> *the call from D to H(D,D) returns* >>>> >>> >>> Right, and it contains ALL of the behavior of the correct simulation >>> of D by H, plus more. >>> >>> H doesn't see DIFFERENT behavior, just LESS, and that differnce isn't >>> due to the input, but due to H. >> >> *These are not the same behaviors* >> >> (Assuming unlimited memory) >> When 1 to a googolplex of steps of D are correctly simulated by H >> *the call from D to H(D,D) NEVER RETURNS* > > Correction, 1 to a googleplex of steps if DIFFERENT Ds, each paired with > a DIFFERENT H, when simulated by that H, the DIFFFERENT routines called > by those DIFFERENT Ds to that DIFFERENT H(D,D) is never simulated to an > end. > _P() [000020e2] 55 push ebp ; housekeeping [000020e3] 8bec mov ebp,esp ; housekeeping [000020e5] 51 push ecx ; housekeeping [000020e6] 8b4508 mov eax,[ebp+08] ; parameter [000020e9] 50 push eax ; push parameter [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter [000020ed] 51 push ecx ; push parameter [000020ee] e82ff3ffff call 00001422 ; call H(P,P) [000020f3] 83c408 add esp,+08 [000020f6] 8945fc mov [ebp-04],eax [000020f9] 837dfc00 cmp dword [ebp-04],+00 [000020fd] 7402 jz 00002101 [000020ff] ebfe jmp 000020ff [00002101] 8b45fc mov eax,[ebp-04] [00002104] 8be5 mov esp,ebp [00002106] 5d pop ebp [00002107] c3 ret Size in bytes:(0038) [00002107] The call from D to H(D,D) cannot possibly return when D is correctly simulated by any H that can possibly exist. Unless you say yes you are correct we cannot move on to the next point. -- 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-25 21:47 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5frvi$14bcm$4@i2pn2.org> |
| In reply to | #107786 |
On 6/25/24 9:02 AM, olcott wrote: > On 6/25/2024 6:04 AM, Richard Damon wrote: >> On 6/24/24 11:13 PM, olcott wrote: >>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>> On 6/24/24 10:38 PM, olcott wrote: >>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>> >>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>> >>>>>>>> You still haven't shown where I lied, on where you don't like >>>>>>>> what I say. >>>>>>>> >>>>>>>>> >>>>>>>>> You said that D correctly simulated by H must >>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>> >>>>>>>> Right, the steps that H sees are IDENTIAL to the steps of the >>>>>>>> directly executed D(D) until H stops its simulation, >>>>>>>> >>>>>>>> NOT ONE DIFFERENCE. >>>>>>>> >>>>>>> >>>>>>> Honest mistake or liar? >>>>>>> >>>>>>> The directly executed D(D) has identical behavior to >>>>>>> D correctly simulated by H1 >>>>>>> *the call from D to H(D,D) returns* >>>>>>> >>>>>>> This is not the same behavior as >>>>>>> D correctly simulated by H >>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>> >>>>>> >>>>>> And what instruction did H's simulation differ from the direct >>>>>> executions trace? >>>>>> >>>>> >>>>> D correctly simulated by H >>>>> *the call from D to H(D,D) DOES NOT return* >>>> >>>> Which isn't "Behavior of the input" >>>> >>>> The "not happening" of something that could have happened except >>>> that the processing was stoped is NOT behavior. >>>> >>>>> >>>>> D correctly simulated by H1 --- Identical to D(D) >>>>> *the call from D to H(D,D) returns* >>>>> >>>> >>>> Right, and it contains ALL of the behavior of the correct simulation >>>> of D by H, plus more. >>>> >>>> H doesn't see DIFFERENT behavior, just LESS, and that differnce >>>> isn't due to the input, but due to H. >>> >>> *These are not the same behaviors* >>> >>> (Assuming unlimited memory) >>> When 1 to a googolplex of steps of D are correctly simulated by H >>> *the call from D to H(D,D) NEVER RETURNS* >> >> Correction, 1 to a googleplex of steps if DIFFERENT Ds, each paired >> with a DIFFERENT H, when simulated by that H, the DIFFFERENT routines >> called by those DIFFERENT Ds to that DIFFERENT H(D,D) is never >> simulated to an end. >> > > _P() > [000020e2] 55 push ebp ; housekeeping > [000020e3] 8bec mov ebp,esp ; housekeeping > [000020e5] 51 push ecx ; housekeeping > [000020e6] 8b4508 mov eax,[ebp+08] ; parameter > [000020e9] 50 push eax ; push parameter > [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter > [000020ed] 51 push ecx ; push parameter > [000020ee] e82ff3ffff call 00001422 ; call H(P,P) > [000020f3] 83c408 add esp,+08 > [000020f6] 8945fc mov [ebp-04],eax > [000020f9] 837dfc00 cmp dword [ebp-04],+00 > [000020fd] 7402 jz 00002101 > [000020ff] ebfe jmp 000020ff > [00002101] 8b45fc mov eax,[ebp-04] > [00002104] 8be5 mov esp,ebp > [00002106] 5d pop ebp > [00002107] c3 ret > Size in bytes:(0038) [00002107] > > The call from D to H(D,D) cannot possibly return when D > is correctly simulated by any H that can possibly exist. > > Unless you say yes you are correct we cannot move on to > the next point. > No, the call most definitinely DOES return, but that return is after the simulation ended. Your problem is that, strictly, by your definition of "Correct Simulation", every instruction simulated, that isn't a HALT instruction, or the ret instruction for the implied call to the routine really needs to be followed by the simualation of the following instruction, as that is actually part of the definition of the behavior of that instruction you simulated. Yes, you can modify your definition slightly to allow the decider to abort its simulation at a point that it chooses, but then you have an admitted PARTIAL simulaiton, and one key aspect of a partial simulation is that it gives no indication (by itself) of anything that happens after the point of the interruption. So, you can't that the call will not have a return, only that it didn't have a return to the point of the simulation, or that there was no such return in the duration of the simulation. And, you comment about "any H" is just an invalid statement about THIS input, as each H has a different input, and it is most definitely true that if we give THIS input, bound to THIS H, there is another alternate H (H') that simulates long enough that it WILL see that return. And, your logic requires that you be this sort of sloppy, as it is clear that you intend to wiggle you definitions as you go to claim things that are just not true, so you NEED to be precise in your words to get an agreement from me. ALso, if you want to be able to say you have PROVED this, you need to actually present a actual proof, not just a claim that you can build a proof, based on a baseless claim that no one can come up with a counter example. The lack of a found counter example is NOT proof that no such counter example can exist, so isn't a piece of a valid logical arguement. You need to actually produce such a proof to make the claim that it is proven, and such a proof will, by necessity, firm up your definition of exactly what you mean, which may be one reason you can't come up with one, as you know it will box you in a corner.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-25 20:59 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5fslr$1uc3o$1@dont-email.me> |
| In reply to | #107821 |
On 6/25/2024 8:47 PM, Richard Damon wrote: > On 6/25/24 9:02 AM, olcott wrote: >> On 6/25/2024 6:04 AM, Richard Damon wrote: >>> On 6/24/24 11:13 PM, olcott wrote: >>>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>>> On 6/24/24 10:38 PM, olcott wrote: >>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>>> >>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>> >>>>>>>>> You still haven't shown where I lied, on where you don't like >>>>>>>>> what I say. >>>>>>>>> >>>>>>>>>> >>>>>>>>>> You said that D correctly simulated by H must >>>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>>> >>>>>>>>> Right, the steps that H sees are IDENTIAL to the steps of the >>>>>>>>> directly executed D(D) until H stops its simulation, >>>>>>>>> >>>>>>>>> NOT ONE DIFFERENCE. >>>>>>>>> >>>>>>>> >>>>>>>> Honest mistake or liar? >>>>>>>> >>>>>>>> The directly executed D(D) has identical behavior to >>>>>>>> D correctly simulated by H1 >>>>>>>> *the call from D to H(D,D) returns* >>>>>>>> >>>>>>>> This is not the same behavior as >>>>>>>> D correctly simulated by H >>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>> >>>>>>> >>>>>>> And what instruction did H's simulation differ from the direct >>>>>>> executions trace? >>>>>>> >>>>>> >>>>>> D correctly simulated by H >>>>>> *the call from D to H(D,D) DOES NOT return* >>>>> >>>>> Which isn't "Behavior of the input" >>>>> >>>>> The "not happening" of something that could have happened except >>>>> that the processing was stoped is NOT behavior. >>>>> >>>>>> >>>>>> D correctly simulated by H1 --- Identical to D(D) >>>>>> *the call from D to H(D,D) returns* >>>>>> >>>>> >>>>> Right, and it contains ALL of the behavior of the correct >>>>> simulation of D by H, plus more. >>>>> >>>>> H doesn't see DIFFERENT behavior, just LESS, and that differnce >>>>> isn't due to the input, but due to H. >>>> >>>> *These are not the same behaviors* >>>> >>>> (Assuming unlimited memory) >>>> When 1 to a googolplex of steps of D are correctly simulated by H >>>> *the call from D to H(D,D) NEVER RETURNS* >>> >>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, each paired >>> with a DIFFERENT H, when simulated by that H, the DIFFFERENT routines >>> called by those DIFFERENT Ds to that DIFFERENT H(D,D) is never >>> simulated to an end. >>> >> >> _P() >> [000020e2] 55 push ebp ; housekeeping >> [000020e3] 8bec mov ebp,esp ; housekeeping >> [000020e5] 51 push ecx ; housekeeping >> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter >> [000020e9] 50 push eax ; push parameter >> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter >> [000020ed] 51 push ecx ; push parameter >> [000020ee] e82ff3ffff call 00001422 ; call H(P,P) >> [000020f3] 83c408 add esp,+08 >> [000020f6] 8945fc mov [ebp-04],eax >> [000020f9] 837dfc00 cmp dword [ebp-04],+00 >> [000020fd] 7402 jz 00002101 >> [000020ff] ebfe jmp 000020ff >> [00002101] 8b45fc mov eax,[ebp-04] >> [00002104] 8be5 mov esp,ebp >> [00002106] 5d pop ebp >> [00002107] c3 ret >> Size in bytes:(0038) [00002107] >> >> The call from D to H(D,D) cannot possibly return when D >> is correctly simulated by any H that can possibly exist. >> >> Unless you say yes you are correct we cannot move on to >> the next point. >> > > No, the call most definitinely DOES return, but that return is after the > simulation ended. > Maybe the real problem is that you have insufficient technical competence. > Your problem is that, strictly, by your definition of "Correct > Simulation", The semantics of the x86 language objectively proves that I am correct. Have you been faking your technical competence? Can you do better with this simpler example? _DDD() [00002172] 55 push ebp ; housekeeping [00002173] 8bec mov ebp,esp ; housekeeping [00002175] 6872210000 push 00002172 ; push DDD [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) [0000217f] 83c404 add esp,+04 [00002182] 5d pop ebp [00002183] c3 ret Size in bytes:(0018) [00002183] The call from DDD to H0(DDD) when DDD is correctly emulated by H0 cannot possibly return. -- 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-25 22:17 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5fto2$14bcm$9@i2pn2.org> |
| In reply to | #107826 |
On 6/25/24 9:59 PM, olcott wrote:
> On 6/25/2024 8:47 PM, Richard Damon wrote:
>> On 6/25/24 9:02 AM, olcott wrote:
>>> On 6/25/2024 6:04 AM, Richard Damon wrote:
>>>> On 6/24/24 11:13 PM, olcott wrote:
>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote:
>>>>>> On 6/24/24 10:38 PM, olcott wrote:
>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote:
>>>>>>>> On 6/24/24 10:21 PM, olcott wrote:
>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote:
>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>> *We can get to that as soon as you reverse your lie*
>>>>>>>>>>> *We can get to that as soon as you reverse your lie*
>>>>>>>>>>> *We can get to that as soon as you reverse your lie*
>>>>>>>>>>
>>>>>>>>>> You still haven't shown where I lied, on where you don't like
>>>>>>>>>> what I say.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You said that D correctly simulated by H must
>>>>>>>>>>> have the behavior of the directly executed D(D).
>>>>>>>>>>
>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the steps of the
>>>>>>>>>> directly executed D(D) until H stops its simulation,
>>>>>>>>>>
>>>>>>>>>> NOT ONE DIFFERENCE.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Honest mistake or liar?
>>>>>>>>>
>>>>>>>>> The directly executed D(D) has identical behavior to
>>>>>>>>> D correctly simulated by H1
>>>>>>>>> *the call from D to H(D,D) returns*
>>>>>>>>>
>>>>>>>>> This is not the same behavior as
>>>>>>>>> D correctly simulated by H
>>>>>>>>> *the call from D to H(D,D) DOES NOT return*
>>>>>>>>>
>>>>>>>>
>>>>>>>> And what instruction did H's simulation differ from the direct
>>>>>>>> executions trace?
>>>>>>>>
>>>>>>>
>>>>>>> D correctly simulated by H
>>>>>>> *the call from D to H(D,D) DOES NOT return*
>>>>>>
>>>>>> Which isn't "Behavior of the input"
>>>>>>
>>>>>> The "not happening" of something that could have happened except
>>>>>> that the processing was stoped is NOT behavior.
>>>>>>
>>>>>>>
>>>>>>> D correctly simulated by H1 --- Identical to D(D)
>>>>>>> *the call from D to H(D,D) returns*
>>>>>>>
>>>>>>
>>>>>> Right, and it contains ALL of the behavior of the correct
>>>>>> simulation of D by H, plus more.
>>>>>>
>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that differnce
>>>>>> isn't due to the input, but due to H.
>>>>>
>>>>> *These are not the same behaviors*
>>>>>
>>>>> (Assuming unlimited memory)
>>>>> When 1 to a googolplex of steps of D are correctly simulated by H
>>>>> *the call from D to H(D,D) NEVER RETURNS*
>>>>
>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, each paired
>>>> with a DIFFERENT H, when simulated by that H, the DIFFFERENT
>>>> routines called by those DIFFERENT Ds to that DIFFERENT H(D,D) is
>>>> never simulated to an end.
>>>>
>>>
>>> _P()
>>> [000020e2] 55 push ebp ; housekeeping
>>> [000020e3] 8bec mov ebp,esp ; housekeeping
>>> [000020e5] 51 push ecx ; housekeeping
>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter
>>> [000020e9] 50 push eax ; push parameter
>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter
>>> [000020ed] 51 push ecx ; push parameter
>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P)
>>> [000020f3] 83c408 add esp,+08
>>> [000020f6] 8945fc mov [ebp-04],eax
>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00
>>> [000020fd] 7402 jz 00002101
>>> [000020ff] ebfe jmp 000020ff
>>> [00002101] 8b45fc mov eax,[ebp-04]
>>> [00002104] 8be5 mov esp,ebp
>>> [00002106] 5d pop ebp
>>> [00002107] c3 ret
>>> Size in bytes:(0038) [00002107]
>>>
>>> The call from D to H(D,D) cannot possibly return when D
>>> is correctly simulated by any H that can possibly exist.
>>>
>>> Unless you say yes you are correct we cannot move on to
>>> the next point.
>>>
>>
>> No, the call most definitinely DOES return, but that return is after
>> the simulation ended.
>>
>
> Maybe the real problem is that you have insufficient technical competence.
Nope, that isn't the problem. I KNOW what I am talking about, as opposed
to you who can't even write a simple Turing Machine.
>
>> Your problem is that, strictly, by your definition of "Correct
>> Simulation",
>
> The semantics of the x86 language objectively proves that I am correct.
> Have you been faking your technical competence?
Nope.
>
> Can you do better with this simpler example?
>
> _DDD()
> [00002172] 55 push ebp ; housekeeping
> [00002173] 8bec mov ebp,esp ; housekeeping
> [00002175] 6872210000 push 00002172 ; push DDD
> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
> [0000217f] 83c404 add esp,+04
> [00002182] 5d pop ebp
> [00002183] c3 ret
> Size in bytes:(0018) [00002183]
>
> The call from DDD to H0(DDD) when DDD is correctly emulated
> by H0 cannot possibly return.
>
>
But the call will, just not in the simulation that your H0 does.
After all, you still haven't learned to define you terms,
Just put:
int H0(ptr x) {
static int flag = 0;
if (flag) return 0;
flag = 1
...
at the begining of your H.
You haven't learned to define it properly, and if you want to claim we
need to remember what you said, then H0 is a Halt Decider, and thus the
only definition of the behavior of its input is the behavior of the
machine represented by it, so we need to look at the direct execution.
You are just showing yourself to be incompetent at your arguments.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-25 21:21 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5fu06$1umhr$1@dont-email.me> |
| In reply to | #107829 |
On 6/25/2024 9:17 PM, Richard Damon wrote: > On 6/25/24 9:59 PM, olcott wrote: >> On 6/25/2024 8:47 PM, Richard Damon wrote: >>> On 6/25/24 9:02 AM, olcott wrote: >>>> On 6/25/2024 6:04 AM, Richard Damon wrote: >>>>> On 6/24/24 11:13 PM, olcott wrote: >>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>>>>> On 6/24/24 10:38 PM, olcott wrote: >>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>>>>> >>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>> >>>>>>>>>>> You still haven't shown where I lied, on where you don't like >>>>>>>>>>> what I say. >>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> You said that D correctly simulated by H must >>>>>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>>>>> >>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the steps of the >>>>>>>>>>> directly executed D(D) until H stops its simulation, >>>>>>>>>>> >>>>>>>>>>> NOT ONE DIFFERENCE. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> Honest mistake or liar? >>>>>>>>>> >>>>>>>>>> The directly executed D(D) has identical behavior to >>>>>>>>>> D correctly simulated by H1 >>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>> >>>>>>>>>> This is not the same behavior as >>>>>>>>>> D correctly simulated by H >>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>> >>>>>>>>> >>>>>>>>> And what instruction did H's simulation differ from the direct >>>>>>>>> executions trace? >>>>>>>>> >>>>>>>> >>>>>>>> D correctly simulated by H >>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>> >>>>>>> Which isn't "Behavior of the input" >>>>>>> >>>>>>> The "not happening" of something that could have happened except >>>>>>> that the processing was stoped is NOT behavior. >>>>>>> >>>>>>>> >>>>>>>> D correctly simulated by H1 --- Identical to D(D) >>>>>>>> *the call from D to H(D,D) returns* >>>>>>>> >>>>>>> >>>>>>> Right, and it contains ALL of the behavior of the correct >>>>>>> simulation of D by H, plus more. >>>>>>> >>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that differnce >>>>>>> isn't due to the input, but due to H. >>>>>> >>>>>> *These are not the same behaviors* >>>>>> >>>>>> (Assuming unlimited memory) >>>>>> When 1 to a googolplex of steps of D are correctly simulated by H >>>>>> *the call from D to H(D,D) NEVER RETURNS* >>>>> >>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, each paired >>>>> with a DIFFERENT H, when simulated by that H, the DIFFFERENT >>>>> routines called by those DIFFERENT Ds to that DIFFERENT H(D,D) is >>>>> never simulated to an end. >>>>> >>>> >>>> _P() >>>> [000020e2] 55 push ebp ; housekeeping >>>> [000020e3] 8bec mov ebp,esp ; housekeeping >>>> [000020e5] 51 push ecx ; housekeeping >>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter >>>> [000020e9] 50 push eax ; push parameter >>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter >>>> [000020ed] 51 push ecx ; push parameter >>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P) >>>> [000020f3] 83c408 add esp,+08 >>>> [000020f6] 8945fc mov [ebp-04],eax >>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00 >>>> [000020fd] 7402 jz 00002101 >>>> [000020ff] ebfe jmp 000020ff >>>> [00002101] 8b45fc mov eax,[ebp-04] >>>> [00002104] 8be5 mov esp,ebp >>>> [00002106] 5d pop ebp >>>> [00002107] c3 ret >>>> Size in bytes:(0038) [00002107] >>>> >>>> The call from D to H(D,D) cannot possibly return when D >>>> is correctly simulated by any H that can possibly exist. >>>> >>>> Unless you say yes you are correct we cannot move on to >>>> the next point. >>>> >>> >>> No, the call most definitinely DOES return, but that return is after >>> the simulation ended. >>> >> >> Maybe the real problem is that you have insufficient technical >> competence. > > Nope, that isn't the problem. I KNOW what I am talking about, as opposed > to you who can't even write a simple Turing Machine. > >> >>> Your problem is that, strictly, by your definition of "Correct >>> Simulation", >> >> The semantics of the x86 language objectively proves that I am correct. >> Have you been faking your technical competence? > > Nope. > >> >> Can you do better with this simpler example? >> >> _DDD() >> [00002172] 55 push ebp ; housekeeping >> [00002173] 8bec mov ebp,esp ; housekeeping >> [00002175] 6872210000 push 00002172 ; push DDD >> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >> [0000217f] 83c404 add esp,+04 >> [00002182] 5d pop ebp >> [00002183] c3 ret >> Size in bytes:(0018) [00002183] >> >> The call from DDD to H0(DDD) when DDD is correctly emulated >> by H0 cannot possibly return. >> >> > > But the call will, just not in the simulation that your H0 does. > OK so we are back to you being a freaking liar trying to get away with contradicting the semantics of the x86 language. -- 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-25 22:54 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5fvtf$14bcn$3@i2pn2.org> |
| In reply to | #107831 |
On 6/25/24 10:21 PM, olcott wrote: > On 6/25/2024 9:17 PM, Richard Damon wrote: >> On 6/25/24 9:59 PM, olcott wrote: >>> On 6/25/2024 8:47 PM, Richard Damon wrote: >>>> On 6/25/24 9:02 AM, olcott wrote: >>>>> On 6/25/2024 6:04 AM, Richard Damon wrote: >>>>>> On 6/24/24 11:13 PM, olcott wrote: >>>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>>>>>> On 6/24/24 10:38 PM, olcott wrote: >>>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>>>>>> >>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>> >>>>>>>>>>>> You still haven't shown where I lied, on where you don't >>>>>>>>>>>> like what I say. >>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> You said that D correctly simulated by H must >>>>>>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>>>>>> >>>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the steps of >>>>>>>>>>>> the directly executed D(D) until H stops its simulation, >>>>>>>>>>>> >>>>>>>>>>>> NOT ONE DIFFERENCE. >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> Honest mistake or liar? >>>>>>>>>>> >>>>>>>>>>> The directly executed D(D) has identical behavior to >>>>>>>>>>> D correctly simulated by H1 >>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>> >>>>>>>>>>> This is not the same behavior as >>>>>>>>>>> D correctly simulated by H >>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> And what instruction did H's simulation differ from the direct >>>>>>>>>> executions trace? >>>>>>>>>> >>>>>>>>> >>>>>>>>> D correctly simulated by H >>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>> >>>>>>>> Which isn't "Behavior of the input" >>>>>>>> >>>>>>>> The "not happening" of something that could have happened except >>>>>>>> that the processing was stoped is NOT behavior. >>>>>>>> >>>>>>>>> >>>>>>>>> D correctly simulated by H1 --- Identical to D(D) >>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>> >>>>>>>> >>>>>>>> Right, and it contains ALL of the behavior of the correct >>>>>>>> simulation of D by H, plus more. >>>>>>>> >>>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that differnce >>>>>>>> isn't due to the input, but due to H. >>>>>>> >>>>>>> *These are not the same behaviors* >>>>>>> >>>>>>> (Assuming unlimited memory) >>>>>>> When 1 to a googolplex of steps of D are correctly simulated by H >>>>>>> *the call from D to H(D,D) NEVER RETURNS* >>>>>> >>>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, each >>>>>> paired with a DIFFERENT H, when simulated by that H, the >>>>>> DIFFFERENT routines called by those DIFFERENT Ds to that DIFFERENT >>>>>> H(D,D) is never simulated to an end. >>>>>> >>>>> >>>>> _P() >>>>> [000020e2] 55 push ebp ; housekeeping >>>>> [000020e3] 8bec mov ebp,esp ; housekeeping >>>>> [000020e5] 51 push ecx ; housekeeping >>>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter >>>>> [000020e9] 50 push eax ; push parameter >>>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter >>>>> [000020ed] 51 push ecx ; push parameter >>>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P) >>>>> [000020f3] 83c408 add esp,+08 >>>>> [000020f6] 8945fc mov [ebp-04],eax >>>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00 >>>>> [000020fd] 7402 jz 00002101 >>>>> [000020ff] ebfe jmp 000020ff >>>>> [00002101] 8b45fc mov eax,[ebp-04] >>>>> [00002104] 8be5 mov esp,ebp >>>>> [00002106] 5d pop ebp >>>>> [00002107] c3 ret >>>>> Size in bytes:(0038) [00002107] >>>>> >>>>> The call from D to H(D,D) cannot possibly return when D >>>>> is correctly simulated by any H that can possibly exist. >>>>> >>>>> Unless you say yes you are correct we cannot move on to >>>>> the next point. >>>>> >>>> >>>> No, the call most definitinely DOES return, but that return is after >>>> the simulation ended. >>>> >>> >>> Maybe the real problem is that you have insufficient technical >>> competence. >> >> Nope, that isn't the problem. I KNOW what I am talking about, as >> opposed to you who can't even write a simple Turing Machine. >> >>> >>>> Your problem is that, strictly, by your definition of "Correct >>>> Simulation", >>> >>> The semantics of the x86 language objectively proves that I am correct. >>> Have you been faking your technical competence? >> >> Nope. >> >>> >>> Can you do better with this simpler example? >>> >>> _DDD() >>> [00002172] 55 push ebp ; housekeeping >>> [00002173] 8bec mov ebp,esp ; housekeeping >>> [00002175] 6872210000 push 00002172 ; push DDD >>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >>> [0000217f] 83c404 add esp,+04 >>> [00002182] 5d pop ebp >>> [00002183] c3 ret >>> Size in bytes:(0018) [00002183] >>> >>> The call from DDD to H0(DDD) when DDD is correctly emulated >>> by H0 cannot possibly return. >>> >>> >> >> But the call will, just not in the simulation that your H0 does. >> > > OK so we are back to you being a freaking liar trying to get > away with contradicting the semantics of the x86 language. > How does that contradictthe semantics of the x86 languge? If H0 is a decider, it will ALWAYS return an answer in finite time, and thus the call H0 in DDD will result in, eventually, being returned. Remember, the semanitc of the x86 language says every instruction WILL BE followed by the execution of the next instruction in the exectution sequence until we reach a halt instruction, or we leave the proggram by it returning to the presumed call to it. What is wrong with that. Aborted simulation just don't tell us about what happens after the aborting, so you can't say will never return, just didn't return YET. So, either you admit that H0 doesn't actualy correctly emulate the input, or H0 never returns an answer about DDD, EVER (not even when H0 is called by main), or that you question is just invalid. And we still have the option of the non-pure H0 just breaking your claim right off the bat.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-25 22:25 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5g1nr$1v8bm$1@dont-email.me> |
| In reply to | #107834 |
On 6/25/2024 9:54 PM, Richard Damon wrote: > On 6/25/24 10:21 PM, olcott wrote: >> On 6/25/2024 9:17 PM, Richard Damon wrote: >>> On 6/25/24 9:59 PM, olcott wrote: >>>> On 6/25/2024 8:47 PM, Richard Damon wrote: >>>>> On 6/25/24 9:02 AM, olcott wrote: >>>>>> On 6/25/2024 6:04 AM, Richard Damon wrote: >>>>>>> On 6/24/24 11:13 PM, olcott wrote: >>>>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>>>>>>> On 6/24/24 10:38 PM, olcott wrote: >>>>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>>>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>>>>>>> >>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>> >>>>>>>>>>>>> You still haven't shown where I lied, on where you don't >>>>>>>>>>>>> like what I say. >>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> You said that D correctly simulated by H must >>>>>>>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>>>>>>> >>>>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the steps of >>>>>>>>>>>>> the directly executed D(D) until H stops its simulation, >>>>>>>>>>>>> >>>>>>>>>>>>> NOT ONE DIFFERENCE. >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> Honest mistake or liar? >>>>>>>>>>>> >>>>>>>>>>>> The directly executed D(D) has identical behavior to >>>>>>>>>>>> D correctly simulated by H1 >>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>> >>>>>>>>>>>> This is not the same behavior as >>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> And what instruction did H's simulation differ from the >>>>>>>>>>> direct executions trace? >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> D correctly simulated by H >>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>> >>>>>>>>> Which isn't "Behavior of the input" >>>>>>>>> >>>>>>>>> The "not happening" of something that could have happened >>>>>>>>> except that the processing was stoped is NOT behavior. >>>>>>>>> >>>>>>>>>> >>>>>>>>>> D correctly simulated by H1 --- Identical to D(D) >>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>> >>>>>>>>> >>>>>>>>> Right, and it contains ALL of the behavior of the correct >>>>>>>>> simulation of D by H, plus more. >>>>>>>>> >>>>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that differnce >>>>>>>>> isn't due to the input, but due to H. >>>>>>>> >>>>>>>> *These are not the same behaviors* >>>>>>>> >>>>>>>> (Assuming unlimited memory) >>>>>>>> When 1 to a googolplex of steps of D are correctly simulated by H >>>>>>>> *the call from D to H(D,D) NEVER RETURNS* >>>>>>> >>>>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, each >>>>>>> paired with a DIFFERENT H, when simulated by that H, the >>>>>>> DIFFFERENT routines called by those DIFFERENT Ds to that >>>>>>> DIFFERENT H(D,D) is never simulated to an end. >>>>>>> >>>>>> >>>>>> _P() >>>>>> [000020e2] 55 push ebp ; housekeeping >>>>>> [000020e3] 8bec mov ebp,esp ; housekeeping >>>>>> [000020e5] 51 push ecx ; housekeeping >>>>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter >>>>>> [000020e9] 50 push eax ; push parameter >>>>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter >>>>>> [000020ed] 51 push ecx ; push parameter >>>>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P) >>>>>> [000020f3] 83c408 add esp,+08 >>>>>> [000020f6] 8945fc mov [ebp-04],eax >>>>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00 >>>>>> [000020fd] 7402 jz 00002101 >>>>>> [000020ff] ebfe jmp 000020ff >>>>>> [00002101] 8b45fc mov eax,[ebp-04] >>>>>> [00002104] 8be5 mov esp,ebp >>>>>> [00002106] 5d pop ebp >>>>>> [00002107] c3 ret >>>>>> Size in bytes:(0038) [00002107] >>>>>> >>>>>> The call from D to H(D,D) cannot possibly return when D >>>>>> is correctly simulated by any H that can possibly exist. >>>>>> >>>>>> Unless you say yes you are correct we cannot move on to >>>>>> the next point. >>>>>> >>>>> >>>>> No, the call most definitinely DOES return, but that return is >>>>> after the simulation ended. >>>>> >>>> >>>> Maybe the real problem is that you have insufficient technical >>>> competence. >>> >>> Nope, that isn't the problem. I KNOW what I am talking about, as >>> opposed to you who can't even write a simple Turing Machine. >>> >>>> >>>>> Your problem is that, strictly, by your definition of "Correct >>>>> Simulation", >>>> >>>> The semantics of the x86 language objectively proves that I am correct. >>>> Have you been faking your technical competence? >>> >>> Nope. >>> >>>> >>>> Can you do better with this simpler example? >>>> >>>> _DDD() >>>> [00002172] 55 push ebp ; housekeeping >>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>> [00002175] 6872210000 push 00002172 ; push DDD >>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >>>> [0000217f] 83c404 add esp,+04 >>>> [00002182] 5d pop ebp >>>> [00002183] c3 ret >>>> Size in bytes:(0018) [00002183] >>>> >>>> The call from DDD to H0(DDD) when DDD is correctly emulated >>>> by H0 cannot possibly return. >>>> >>>> >>> >>> But the call will, just not in the simulation that your H0 does. >>> >> >> OK so we are back to you being a freaking liar trying to get >> away with contradicting the semantics of the x86 language. >> > > How does that contradictthe semantics of the x86 languge? > > If H0 is a decider, it will ALWAYS return an answer in finite time H0 is not even a decider yet. When you leap ahead you diverge from the point at hand. -- 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-25 23:32 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5g24k$14bcm$10@i2pn2.org> |
| In reply to | #107836 |
On 6/25/24 11:25 PM, olcott wrote: > On 6/25/2024 9:54 PM, Richard Damon wrote: >> On 6/25/24 10:21 PM, olcott wrote: >>> On 6/25/2024 9:17 PM, Richard Damon wrote: >>>> On 6/25/24 9:59 PM, olcott wrote: >>>>> On 6/25/2024 8:47 PM, Richard Damon wrote: >>>>>> On 6/25/24 9:02 AM, olcott wrote: >>>>>>> On 6/25/2024 6:04 AM, Richard Damon wrote: >>>>>>>> On 6/24/24 11:13 PM, olcott wrote: >>>>>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>>>>>>>> On 6/24/24 10:38 PM, olcott wrote: >>>>>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>>>>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>> >>>>>>>>>>>>>> You still haven't shown where I lied, on where you don't >>>>>>>>>>>>>> like what I say. >>>>>>>>>>>>>> >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> You said that D correctly simulated by H must >>>>>>>>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>>>>>>>> >>>>>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the steps of >>>>>>>>>>>>>> the directly executed D(D) until H stops its simulation, >>>>>>>>>>>>>> >>>>>>>>>>>>>> NOT ONE DIFFERENCE. >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> Honest mistake or liar? >>>>>>>>>>>>> >>>>>>>>>>>>> The directly executed D(D) has identical behavior to >>>>>>>>>>>>> D correctly simulated by H1 >>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>> >>>>>>>>>>>>> This is not the same behavior as >>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> And what instruction did H's simulation differ from the >>>>>>>>>>>> direct executions trace? >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> D correctly simulated by H >>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>> >>>>>>>>>> Which isn't "Behavior of the input" >>>>>>>>>> >>>>>>>>>> The "not happening" of something that could have happened >>>>>>>>>> except that the processing was stoped is NOT behavior. >>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> D correctly simulated by H1 --- Identical to D(D) >>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> Right, and it contains ALL of the behavior of the correct >>>>>>>>>> simulation of D by H, plus more. >>>>>>>>>> >>>>>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that >>>>>>>>>> differnce isn't due to the input, but due to H. >>>>>>>>> >>>>>>>>> *These are not the same behaviors* >>>>>>>>> >>>>>>>>> (Assuming unlimited memory) >>>>>>>>> When 1 to a googolplex of steps of D are correctly simulated by H >>>>>>>>> *the call from D to H(D,D) NEVER RETURNS* >>>>>>>> >>>>>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, each >>>>>>>> paired with a DIFFERENT H, when simulated by that H, the >>>>>>>> DIFFFERENT routines called by those DIFFERENT Ds to that >>>>>>>> DIFFERENT H(D,D) is never simulated to an end. >>>>>>>> >>>>>>> >>>>>>> _P() >>>>>>> [000020e2] 55 push ebp ; housekeeping >>>>>>> [000020e3] 8bec mov ebp,esp ; housekeeping >>>>>>> [000020e5] 51 push ecx ; housekeeping >>>>>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter >>>>>>> [000020e9] 50 push eax ; push parameter >>>>>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter >>>>>>> [000020ed] 51 push ecx ; push parameter >>>>>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P) >>>>>>> [000020f3] 83c408 add esp,+08 >>>>>>> [000020f6] 8945fc mov [ebp-04],eax >>>>>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00 >>>>>>> [000020fd] 7402 jz 00002101 >>>>>>> [000020ff] ebfe jmp 000020ff >>>>>>> [00002101] 8b45fc mov eax,[ebp-04] >>>>>>> [00002104] 8be5 mov esp,ebp >>>>>>> [00002106] 5d pop ebp >>>>>>> [00002107] c3 ret >>>>>>> Size in bytes:(0038) [00002107] >>>>>>> >>>>>>> The call from D to H(D,D) cannot possibly return when D >>>>>>> is correctly simulated by any H that can possibly exist. >>>>>>> >>>>>>> Unless you say yes you are correct we cannot move on to >>>>>>> the next point. >>>>>>> >>>>>> >>>>>> No, the call most definitinely DOES return, but that return is >>>>>> after the simulation ended. >>>>>> >>>>> >>>>> Maybe the real problem is that you have insufficient technical >>>>> competence. >>>> >>>> Nope, that isn't the problem. I KNOW what I am talking about, as >>>> opposed to you who can't even write a simple Turing Machine. >>>> >>>>> >>>>>> Your problem is that, strictly, by your definition of "Correct >>>>>> Simulation", >>>>> >>>>> The semantics of the x86 language objectively proves that I am >>>>> correct. >>>>> Have you been faking your technical competence? >>>> >>>> Nope. >>>> >>>>> >>>>> Can you do better with this simpler example? >>>>> >>>>> _DDD() >>>>> [00002172] 55 push ebp ; housekeeping >>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >>>>> [0000217f] 83c404 add esp,+04 >>>>> [00002182] 5d pop ebp >>>>> [00002183] c3 ret >>>>> Size in bytes:(0018) [00002183] >>>>> >>>>> The call from DDD to H0(DDD) when DDD is correctly emulated >>>>> by H0 cannot possibly return. >>>>> >>>>> >>>> >>>> But the call will, just not in the simulation that your H0 does. >>>> >>> >>> OK so we are back to you being a freaking liar trying to get >>> away with contradicting the semantics of the x86 language. >>> >> >> How does that contradictthe semantics of the x86 languge? >> >> If H0 is a decider, it will ALWAYS return an answer in finite time > > H0 is not even a decider yet. When you leap ahead you > diverge from the point at hand. > THen it is allowed to be the impure function , so you r claim is proven false. You can't use double speak and claim you ment that, but not that H0 isn't a decider. So, your FAIL. And, by the definition of "Correct Simulation" per the STRICT x86 definition, it CAN'T be a decider, as it isn't allowed to "abort" since the actual x86 code doesn't abort.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-25 22:37 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5g2ds$1v8bm$3@dont-email.me> |
| In reply to | #107838 |
On 6/25/2024 10:32 PM, Richard Damon wrote: > On 6/25/24 11:25 PM, olcott wrote: >> On 6/25/2024 9:54 PM, Richard Damon wrote: >>> On 6/25/24 10:21 PM, olcott wrote: >>>> On 6/25/2024 9:17 PM, Richard Damon wrote: >>>>> On 6/25/24 9:59 PM, olcott wrote: >>>>>> On 6/25/2024 8:47 PM, Richard Damon wrote: >>>>>>> On 6/25/24 9:02 AM, olcott wrote: >>>>>>>> On 6/25/2024 6:04 AM, Richard Damon wrote: >>>>>>>>> On 6/24/24 11:13 PM, olcott wrote: >>>>>>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>>>>>>>>> On 6/24/24 10:38 PM, olcott wrote: >>>>>>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>>>>>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> You still haven't shown where I lied, on where you don't >>>>>>>>>>>>>>> like what I say. >>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> You said that D correctly simulated by H must >>>>>>>>>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the steps of >>>>>>>>>>>>>>> the directly executed D(D) until H stops its simulation, >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> NOT ONE DIFFERENCE. >>>>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> Honest mistake or liar? >>>>>>>>>>>>>> >>>>>>>>>>>>>> The directly executed D(D) has identical behavior to >>>>>>>>>>>>>> D correctly simulated by H1 >>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>> >>>>>>>>>>>>>> This is not the same behavior as >>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> And what instruction did H's simulation differ from the >>>>>>>>>>>>> direct executions trace? >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>> >>>>>>>>>>> Which isn't "Behavior of the input" >>>>>>>>>>> >>>>>>>>>>> The "not happening" of something that could have happened >>>>>>>>>>> except that the processing was stoped is NOT behavior. >>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> D correctly simulated by H1 --- Identical to D(D) >>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> Right, and it contains ALL of the behavior of the correct >>>>>>>>>>> simulation of D by H, plus more. >>>>>>>>>>> >>>>>>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that >>>>>>>>>>> differnce isn't due to the input, but due to H. >>>>>>>>>> >>>>>>>>>> *These are not the same behaviors* >>>>>>>>>> >>>>>>>>>> (Assuming unlimited memory) >>>>>>>>>> When 1 to a googolplex of steps of D are correctly simulated by H >>>>>>>>>> *the call from D to H(D,D) NEVER RETURNS* >>>>>>>>> >>>>>>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, each >>>>>>>>> paired with a DIFFERENT H, when simulated by that H, the >>>>>>>>> DIFFFERENT routines called by those DIFFERENT Ds to that >>>>>>>>> DIFFERENT H(D,D) is never simulated to an end. >>>>>>>>> >>>>>>>> >>>>>>>> _P() >>>>>>>> [000020e2] 55 push ebp ; housekeeping >>>>>>>> [000020e3] 8bec mov ebp,esp ; housekeeping >>>>>>>> [000020e5] 51 push ecx ; housekeeping >>>>>>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter >>>>>>>> [000020e9] 50 push eax ; push parameter >>>>>>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter >>>>>>>> [000020ed] 51 push ecx ; push parameter >>>>>>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P) >>>>>>>> [000020f3] 83c408 add esp,+08 >>>>>>>> [000020f6] 8945fc mov [ebp-04],eax >>>>>>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00 >>>>>>>> [000020fd] 7402 jz 00002101 >>>>>>>> [000020ff] ebfe jmp 000020ff >>>>>>>> [00002101] 8b45fc mov eax,[ebp-04] >>>>>>>> [00002104] 8be5 mov esp,ebp >>>>>>>> [00002106] 5d pop ebp >>>>>>>> [00002107] c3 ret >>>>>>>> Size in bytes:(0038) [00002107] >>>>>>>> >>>>>>>> The call from D to H(D,D) cannot possibly return when D >>>>>>>> is correctly simulated by any H that can possibly exist. >>>>>>>> >>>>>>>> Unless you say yes you are correct we cannot move on to >>>>>>>> the next point. >>>>>>>> >>>>>>> >>>>>>> No, the call most definitinely DOES return, but that return is >>>>>>> after the simulation ended. >>>>>>> >>>>>> >>>>>> Maybe the real problem is that you have insufficient technical >>>>>> competence. >>>>> >>>>> Nope, that isn't the problem. I KNOW what I am talking about, as >>>>> opposed to you who can't even write a simple Turing Machine. >>>>> >>>>>> >>>>>>> Your problem is that, strictly, by your definition of "Correct >>>>>>> Simulation", >>>>>> >>>>>> The semantics of the x86 language objectively proves that I am >>>>>> correct. >>>>>> Have you been faking your technical competence? >>>>> >>>>> Nope. >>>>> >>>>>> >>>>>> Can you do better with this simpler example? >>>>>> >>>>>> _DDD() >>>>>> [00002172] 55 push ebp ; housekeeping >>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >>>>>> [0000217f] 83c404 add esp,+04 >>>>>> [00002182] 5d pop ebp >>>>>> [00002183] c3 ret >>>>>> Size in bytes:(0018) [00002183] >>>>>> >>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated >>>>>> by H0 cannot possibly return. >>>>>> >>>>>> >>>>> >>>>> But the call will, just not in the simulation that your H0 does. >>>>> >>>> >>>> OK so we are back to you being a freaking liar trying to get >>>> away with contradicting the semantics of the x86 language. >>>> >>> >>> How does that contradictthe semantics of the x86 languge? >>> >>> If H0 is a decider, it will ALWAYS return an answer in finite time >> >> H0 is not even a decider yet. When you leap ahead you >> diverge from the point at hand. >> > > THen it is allowed to be the impure function , so you r claim is proven > false. > We have not even gotten that far yet. We ARE ONLY TALKING ABOUT the behavior of DDD correctly simulated by H0. AKA software engineering and NOT computer science. -- 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-26 06:58 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5gs85$15l89$1@i2pn2.org> |
| In reply to | #107840 |
On 6/25/24 11:37 PM, olcott wrote:
> On 6/25/2024 10:32 PM, Richard Damon wrote:
>> On 6/25/24 11:25 PM, olcott wrote:
>>> On 6/25/2024 9:54 PM, Richard Damon wrote:
>>>> On 6/25/24 10:21 PM, olcott wrote:
>>>>> On 6/25/2024 9:17 PM, Richard Damon wrote:
>>>>>> On 6/25/24 9:59 PM, olcott wrote:
>>>>>>> On 6/25/2024 8:47 PM, Richard Damon wrote:
>>>>>>>> On 6/25/24 9:02 AM, olcott wrote:
>>>>>>>>> On 6/25/2024 6:04 AM, Richard Damon wrote:
>>>>>>>>>> On 6/24/24 11:13 PM, olcott wrote:
>>>>>>>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/24/24 10:38 PM, olcott wrote:
>>>>>>>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/24/24 10:21 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie*
>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie*
>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You still haven't shown where I lied, on where you don't
>>>>>>>>>>>>>>>> like what I say.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You said that D correctly simulated by H must
>>>>>>>>>>>>>>>>> have the behavior of the directly executed D(D).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the steps
>>>>>>>>>>>>>>>> of the directly executed D(D) until H stops its simulation,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> NOT ONE DIFFERENCE.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Honest mistake or liar?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The directly executed D(D) has identical behavior to
>>>>>>>>>>>>>>> D correctly simulated by H1
>>>>>>>>>>>>>>> *the call from D to H(D,D) returns*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This is not the same behavior as
>>>>>>>>>>>>>>> D correctly simulated by H
>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And what instruction did H's simulation differ from the
>>>>>>>>>>>>>> direct executions trace?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> D correctly simulated by H
>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return*
>>>>>>>>>>>>
>>>>>>>>>>>> Which isn't "Behavior of the input"
>>>>>>>>>>>>
>>>>>>>>>>>> The "not happening" of something that could have happened
>>>>>>>>>>>> except that the processing was stoped is NOT behavior.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> D correctly simulated by H1 --- Identical to D(D)
>>>>>>>>>>>>> *the call from D to H(D,D) returns*
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Right, and it contains ALL of the behavior of the correct
>>>>>>>>>>>> simulation of D by H, plus more.
>>>>>>>>>>>>
>>>>>>>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that
>>>>>>>>>>>> differnce isn't due to the input, but due to H.
>>>>>>>>>>>
>>>>>>>>>>> *These are not the same behaviors*
>>>>>>>>>>>
>>>>>>>>>>> (Assuming unlimited memory)
>>>>>>>>>>> When 1 to a googolplex of steps of D are correctly simulated
>>>>>>>>>>> by H
>>>>>>>>>>> *the call from D to H(D,D) NEVER RETURNS*
>>>>>>>>>>
>>>>>>>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, each
>>>>>>>>>> paired with a DIFFERENT H, when simulated by that H, the
>>>>>>>>>> DIFFFERENT routines called by those DIFFERENT Ds to that
>>>>>>>>>> DIFFERENT H(D,D) is never simulated to an end.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> _P()
>>>>>>>>> [000020e2] 55 push ebp ; housekeeping
>>>>>>>>> [000020e3] 8bec mov ebp,esp ; housekeeping
>>>>>>>>> [000020e5] 51 push ecx ; housekeeping
>>>>>>>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter
>>>>>>>>> [000020e9] 50 push eax ; push parameter
>>>>>>>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter
>>>>>>>>> [000020ed] 51 push ecx ; push parameter
>>>>>>>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P)
>>>>>>>>> [000020f3] 83c408 add esp,+08
>>>>>>>>> [000020f6] 8945fc mov [ebp-04],eax
>>>>>>>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00
>>>>>>>>> [000020fd] 7402 jz 00002101
>>>>>>>>> [000020ff] ebfe jmp 000020ff
>>>>>>>>> [00002101] 8b45fc mov eax,[ebp-04]
>>>>>>>>> [00002104] 8be5 mov esp,ebp
>>>>>>>>> [00002106] 5d pop ebp
>>>>>>>>> [00002107] c3 ret
>>>>>>>>> Size in bytes:(0038) [00002107]
>>>>>>>>>
>>>>>>>>> The call from D to H(D,D) cannot possibly return when D
>>>>>>>>> is correctly simulated by any H that can possibly exist.
>>>>>>>>>
>>>>>>>>> Unless you say yes you are correct we cannot move on to
>>>>>>>>> the next point.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, the call most definitinely DOES return, but that return is
>>>>>>>> after the simulation ended.
>>>>>>>>
>>>>>>>
>>>>>>> Maybe the real problem is that you have insufficient technical
>>>>>>> competence.
>>>>>>
>>>>>> Nope, that isn't the problem. I KNOW what I am talking about, as
>>>>>> opposed to you who can't even write a simple Turing Machine.
>>>>>>
>>>>>>>
>>>>>>>> Your problem is that, strictly, by your definition of "Correct
>>>>>>>> Simulation",
>>>>>>>
>>>>>>> The semantics of the x86 language objectively proves that I am
>>>>>>> correct.
>>>>>>> Have you been faking your technical competence?
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>>>
>>>>>>> Can you do better with this simpler example?
>>>>>>>
>>>>>>> _DDD()
>>>>>>> [00002172] 55 push ebp ; housekeeping
>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>>>>> [0000217f] 83c404 add esp,+04
>>>>>>> [00002182] 5d pop ebp
>>>>>>> [00002183] c3 ret
>>>>>>> Size in bytes:(0018) [00002183]
>>>>>>>
>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>>>> by H0 cannot possibly return.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> But the call will, just not in the simulation that your H0 does.
>>>>>>
>>>>>
>>>>> OK so we are back to you being a freaking liar trying to get
>>>>> away with contradicting the semantics of the x86 language.
>>>>>
>>>>
>>>> How does that contradictthe semantics of the x86 languge?
>>>>
>>>> If H0 is a decider, it will ALWAYS return an answer in finite time
>>>
>>> H0 is not even a decider yet. When you leap ahead you
>>> diverge from the point at hand.
>>>
>>
>> THen it is allowed to be the impure function , so you r claim is
>> proven false.
>>
>
> We have not even gotten that far yet.
> We ARE ONLY TALKING ABOUT the behavior of DDD correctly
> simulated by H0. AKA software engineering and NOT computer
> science.
>
So, you have no grounds to exclude my version of H0, so your claim is
just proven false.
int H0(ptr x) {
static int flag = 0;
if (flag) return 0;
flag = 1;
...
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 08:33 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5h5c4$24jbd$9@dont-email.me> |
| In reply to | #107850 |
On 6/26/2024 5:58 AM, Richard Damon wrote: > On 6/25/24 11:37 PM, olcott wrote: >> On 6/25/2024 10:32 PM, Richard Damon wrote: >>> On 6/25/24 11:25 PM, olcott wrote: >>>> On 6/25/2024 9:54 PM, Richard Damon wrote: >>>>> On 6/25/24 10:21 PM, olcott wrote: >>>>>> On 6/25/2024 9:17 PM, Richard Damon wrote: >>>>>>> On 6/25/24 9:59 PM, olcott wrote: >>>>>>>> On 6/25/2024 8:47 PM, Richard Damon wrote: >>>>>>>>> On 6/25/24 9:02 AM, olcott wrote: >>>>>>>>>> On 6/25/2024 6:04 AM, Richard Damon wrote: >>>>>>>>>>> On 6/24/24 11:13 PM, olcott wrote: >>>>>>>>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>>>>>>>>>>> On 6/24/24 10:38 PM, olcott wrote: >>>>>>>>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>>>>>>>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>>>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> You still haven't shown where I lied, on where you >>>>>>>>>>>>>>>>> don't like what I say. >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> You said that D correctly simulated by H must >>>>>>>>>>>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the steps >>>>>>>>>>>>>>>>> of the directly executed D(D) until H stops its >>>>>>>>>>>>>>>>> simulation, >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> NOT ONE DIFFERENCE. >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> Honest mistake or liar? >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> The directly executed D(D) has identical behavior to >>>>>>>>>>>>>>>> D correctly simulated by H1 >>>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> This is not the same behavior as >>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> And what instruction did H's simulation differ from the >>>>>>>>>>>>>>> direct executions trace? >>>>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>> >>>>>>>>>>>>> Which isn't "Behavior of the input" >>>>>>>>>>>>> >>>>>>>>>>>>> The "not happening" of something that could have happened >>>>>>>>>>>>> except that the processing was stoped is NOT behavior. >>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> D correctly simulated by H1 --- Identical to D(D) >>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> Right, and it contains ALL of the behavior of the correct >>>>>>>>>>>>> simulation of D by H, plus more. >>>>>>>>>>>>> >>>>>>>>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that >>>>>>>>>>>>> differnce isn't due to the input, but due to H. >>>>>>>>>>>> >>>>>>>>>>>> *These are not the same behaviors* >>>>>>>>>>>> >>>>>>>>>>>> (Assuming unlimited memory) >>>>>>>>>>>> When 1 to a googolplex of steps of D are correctly simulated >>>>>>>>>>>> by H >>>>>>>>>>>> *the call from D to H(D,D) NEVER RETURNS* >>>>>>>>>>> >>>>>>>>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, each >>>>>>>>>>> paired with a DIFFERENT H, when simulated by that H, the >>>>>>>>>>> DIFFFERENT routines called by those DIFFERENT Ds to that >>>>>>>>>>> DIFFERENT H(D,D) is never simulated to an end. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> _P() >>>>>>>>>> [000020e2] 55 push ebp ; housekeeping >>>>>>>>>> [000020e3] 8bec mov ebp,esp ; housekeeping >>>>>>>>>> [000020e5] 51 push ecx ; housekeeping >>>>>>>>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter >>>>>>>>>> [000020e9] 50 push eax ; push parameter >>>>>>>>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter >>>>>>>>>> [000020ed] 51 push ecx ; push parameter >>>>>>>>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P) >>>>>>>>>> [000020f3] 83c408 add esp,+08 >>>>>>>>>> [000020f6] 8945fc mov [ebp-04],eax >>>>>>>>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00 >>>>>>>>>> [000020fd] 7402 jz 00002101 >>>>>>>>>> [000020ff] ebfe jmp 000020ff >>>>>>>>>> [00002101] 8b45fc mov eax,[ebp-04] >>>>>>>>>> [00002104] 8be5 mov esp,ebp >>>>>>>>>> [00002106] 5d pop ebp >>>>>>>>>> [00002107] c3 ret >>>>>>>>>> Size in bytes:(0038) [00002107] >>>>>>>>>> >>>>>>>>>> The call from D to H(D,D) cannot possibly return when D >>>>>>>>>> is correctly simulated by any H that can possibly exist. >>>>>>>>>> >>>>>>>>>> Unless you say yes you are correct we cannot move on to >>>>>>>>>> the next point. >>>>>>>>>> >>>>>>>>> >>>>>>>>> No, the call most definitinely DOES return, but that return is >>>>>>>>> after the simulation ended. >>>>>>>>> >>>>>>>> >>>>>>>> Maybe the real problem is that you have insufficient technical >>>>>>>> competence. >>>>>>> >>>>>>> Nope, that isn't the problem. I KNOW what I am talking about, as >>>>>>> opposed to you who can't even write a simple Turing Machine. >>>>>>> >>>>>>>> >>>>>>>>> Your problem is that, strictly, by your definition of "Correct >>>>>>>>> Simulation", >>>>>>>> >>>>>>>> The semantics of the x86 language objectively proves that I am >>>>>>>> correct. >>>>>>>> Have you been faking your technical competence? >>>>>>> >>>>>>> Nope. >>>>>>> >>>>>>>> >>>>>>>> Can you do better with this simpler example? >>>>>>>> >>>>>>>> _DDD() >>>>>>>> [00002172] 55 push ebp ; housekeeping >>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>> [00002182] 5d pop ebp >>>>>>>> [00002183] c3 ret >>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>> >>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated >>>>>>>> by H0 cannot possibly return. >>>>>>>> >>>>>>>> >>>>>>> >>>>>>> But the call will, just not in the simulation that your H0 does. >>>>>>> >>>>>> >>>>>> OK so we are back to you being a freaking liar trying to get >>>>>> away with contradicting the semantics of the x86 language. >>>>>> >>>>> >>>>> How does that contradictthe semantics of the x86 languge? >>>>> >>>>> If H0 is a decider, it will ALWAYS return an answer in finite time >>>> >>>> H0 is not even a decider yet. When you leap ahead you >>>> diverge from the point at hand. >>>> >>> >>> THen it is allowed to be the impure function , so you r claim is >>> proven false. >>> >> >> We have not even gotten that far yet. >> We ARE ONLY TALKING ABOUT the behavior of DDD correctly >> simulated by H0. AKA software engineering and NOT computer >> science. >> > > So, you have no grounds to exclude my version of H0, so your claim is > just proven false. > As soon as you quit lying we can move on to the next point. -- 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-26 19:41 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5i8vg$17ej1$3@i2pn2.org> |
| In reply to | #107861 |
On 6/26/24 9:33 AM, olcott wrote: > On 6/26/2024 5:58 AM, Richard Damon wrote: >> On 6/25/24 11:37 PM, olcott wrote: >>> On 6/25/2024 10:32 PM, Richard Damon wrote: >>>> On 6/25/24 11:25 PM, olcott wrote: >>>>> On 6/25/2024 9:54 PM, Richard Damon wrote: >>>>>> On 6/25/24 10:21 PM, olcott wrote: >>>>>>> On 6/25/2024 9:17 PM, Richard Damon wrote: >>>>>>>> On 6/25/24 9:59 PM, olcott wrote: >>>>>>>>> On 6/25/2024 8:47 PM, Richard Damon wrote: >>>>>>>>>> On 6/25/24 9:02 AM, olcott wrote: >>>>>>>>>>> On 6/25/2024 6:04 AM, Richard Damon wrote: >>>>>>>>>>>> On 6/24/24 11:13 PM, olcott wrote: >>>>>>>>>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>>>>>>>>>>>> On 6/24/24 10:38 PM, olcott wrote: >>>>>>>>>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>>>>>>>>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>>>>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> You still haven't shown where I lied, on where you >>>>>>>>>>>>>>>>>> don't like what I say. >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> You said that D correctly simulated by H must >>>>>>>>>>>>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the steps >>>>>>>>>>>>>>>>>> of the directly executed D(D) until H stops its >>>>>>>>>>>>>>>>>> simulation, >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> NOT ONE DIFFERENCE. >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> Honest mistake or liar? >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> The directly executed D(D) has identical behavior to >>>>>>>>>>>>>>>>> D correctly simulated by H1 >>>>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> This is not the same behavior as >>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> And what instruction did H's simulation differ from the >>>>>>>>>>>>>>>> direct executions trace? >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>> >>>>>>>>>>>>>> Which isn't "Behavior of the input" >>>>>>>>>>>>>> >>>>>>>>>>>>>> The "not happening" of something that could have happened >>>>>>>>>>>>>> except that the processing was stoped is NOT behavior. >>>>>>>>>>>>>> >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> D correctly simulated by H1 --- Identical to D(D) >>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> Right, and it contains ALL of the behavior of the correct >>>>>>>>>>>>>> simulation of D by H, plus more. >>>>>>>>>>>>>> >>>>>>>>>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that >>>>>>>>>>>>>> differnce isn't due to the input, but due to H. >>>>>>>>>>>>> >>>>>>>>>>>>> *These are not the same behaviors* >>>>>>>>>>>>> >>>>>>>>>>>>> (Assuming unlimited memory) >>>>>>>>>>>>> When 1 to a googolplex of steps of D are correctly >>>>>>>>>>>>> simulated by H >>>>>>>>>>>>> *the call from D to H(D,D) NEVER RETURNS* >>>>>>>>>>>> >>>>>>>>>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, each >>>>>>>>>>>> paired with a DIFFERENT H, when simulated by that H, the >>>>>>>>>>>> DIFFFERENT routines called by those DIFFERENT Ds to that >>>>>>>>>>>> DIFFERENT H(D,D) is never simulated to an end. >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> _P() >>>>>>>>>>> [000020e2] 55 push ebp ; housekeeping >>>>>>>>>>> [000020e3] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [000020e5] 51 push ecx ; housekeeping >>>>>>>>>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter >>>>>>>>>>> [000020e9] 50 push eax ; push parameter >>>>>>>>>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter >>>>>>>>>>> [000020ed] 51 push ecx ; push parameter >>>>>>>>>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P) >>>>>>>>>>> [000020f3] 83c408 add esp,+08 >>>>>>>>>>> [000020f6] 8945fc mov [ebp-04],eax >>>>>>>>>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00 >>>>>>>>>>> [000020fd] 7402 jz 00002101 >>>>>>>>>>> [000020ff] ebfe jmp 000020ff >>>>>>>>>>> [00002101] 8b45fc mov eax,[ebp-04] >>>>>>>>>>> [00002104] 8be5 mov esp,ebp >>>>>>>>>>> [00002106] 5d pop ebp >>>>>>>>>>> [00002107] c3 ret >>>>>>>>>>> Size in bytes:(0038) [00002107] >>>>>>>>>>> >>>>>>>>>>> The call from D to H(D,D) cannot possibly return when D >>>>>>>>>>> is correctly simulated by any H that can possibly exist. >>>>>>>>>>> >>>>>>>>>>> Unless you say yes you are correct we cannot move on to >>>>>>>>>>> the next point. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> No, the call most definitinely DOES return, but that return is >>>>>>>>>> after the simulation ended. >>>>>>>>>> >>>>>>>>> >>>>>>>>> Maybe the real problem is that you have insufficient technical >>>>>>>>> competence. >>>>>>>> >>>>>>>> Nope, that isn't the problem. I KNOW what I am talking about, as >>>>>>>> opposed to you who can't even write a simple Turing Machine. >>>>>>>> >>>>>>>>> >>>>>>>>>> Your problem is that, strictly, by your definition of "Correct >>>>>>>>>> Simulation", >>>>>>>>> >>>>>>>>> The semantics of the x86 language objectively proves that I am >>>>>>>>> correct. >>>>>>>>> Have you been faking your technical competence? >>>>>>>> >>>>>>>> Nope. >>>>>>>> >>>>>>>>> >>>>>>>>> Can you do better with this simpler example? >>>>>>>>> >>>>>>>>> _DDD() >>>>>>>>> [00002172] 55 push ebp ; housekeeping >>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >>>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>>> [00002182] 5d pop ebp >>>>>>>>> [00002183] c3 ret >>>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>>> >>>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated >>>>>>>>> by H0 cannot possibly return. >>>>>>>>> >>>>>>>>> >>>>>>>> >>>>>>>> But the call will, just not in the simulation that your H0 does. >>>>>>>> >>>>>>> >>>>>>> OK so we are back to you being a freaking liar trying to get >>>>>>> away with contradicting the semantics of the x86 language. >>>>>>> >>>>>> >>>>>> How does that contradictthe semantics of the x86 languge? >>>>>> >>>>>> If H0 is a decider, it will ALWAYS return an answer in finite time >>>>> >>>>> H0 is not even a decider yet. When you leap ahead you >>>>> diverge from the point at hand. >>>>> >>>> >>>> THen it is allowed to be the impure function , so you r claim is >>>> proven false. >>>> >>> >>> We have not even gotten that far yet. >>> We ARE ONLY TALKING ABOUT the behavior of DDD correctly >>> simulated by H0. AKA software engineering and NOT computer >>> science. >>> >> >> So, you have no grounds to exclude my version of H0, so your claim is >> just proven false. >> > > As soon as you quit lying we can move on to the next point. > BUt YOU ARE the one that is caught in the lie. You said you through away all your old assumptions, and never added back in the one about H) needing to be pure, so you claim is just false. Also, the behavior as defined by the semantics of the x86 machine language only describe unaborted executions/emulations, so if H0 aborts its emulation, it isn't "correct" by the strict definition you have stipulatd. Sorry, you just don't understand what you are talking about and have gotten yourself into a corner.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 18:50 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5i9fh$2cko8$2@dont-email.me> |
| In reply to | #107876 |
On 6/26/2024 6:41 PM, Richard Damon wrote: > On 6/26/24 9:33 AM, olcott wrote: >> On 6/26/2024 5:58 AM, Richard Damon wrote: >>> On 6/25/24 11:37 PM, olcott wrote: >>>> On 6/25/2024 10:32 PM, Richard Damon wrote: >>>>> On 6/25/24 11:25 PM, olcott wrote: >>>>>> On 6/25/2024 9:54 PM, Richard Damon wrote: >>>>>>> On 6/25/24 10:21 PM, olcott wrote: >>>>>>>> On 6/25/2024 9:17 PM, Richard Damon wrote: >>>>>>>>> On 6/25/24 9:59 PM, olcott wrote: >>>>>>>>>> On 6/25/2024 8:47 PM, Richard Damon wrote: >>>>>>>>>>> On 6/25/24 9:02 AM, olcott wrote: >>>>>>>>>>>> On 6/25/2024 6:04 AM, Richard Damon wrote: >>>>>>>>>>>>> On 6/24/24 11:13 PM, olcott wrote: >>>>>>>>>>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>> On 6/24/24 10:38 PM, olcott wrote: >>>>>>>>>>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>>>>>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> You still haven't shown where I lied, on where you >>>>>>>>>>>>>>>>>>> don't like what I say. >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> You said that D correctly simulated by H must >>>>>>>>>>>>>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the >>>>>>>>>>>>>>>>>>> steps of the directly executed D(D) until H stops its >>>>>>>>>>>>>>>>>>> simulation, >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> NOT ONE DIFFERENCE. >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> Honest mistake or liar? >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> The directly executed D(D) has identical behavior to >>>>>>>>>>>>>>>>>> D correctly simulated by H1 >>>>>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> This is not the same behavior as >>>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> And what instruction did H's simulation differ from the >>>>>>>>>>>>>>>>> direct executions trace? >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> Which isn't "Behavior of the input" >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> The "not happening" of something that could have happened >>>>>>>>>>>>>>> except that the processing was stoped is NOT behavior. >>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> D correctly simulated by H1 --- Identical to D(D) >>>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> Right, and it contains ALL of the behavior of the correct >>>>>>>>>>>>>>> simulation of D by H, plus more. >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that >>>>>>>>>>>>>>> differnce isn't due to the input, but due to H. >>>>>>>>>>>>>> >>>>>>>>>>>>>> *These are not the same behaviors* >>>>>>>>>>>>>> >>>>>>>>>>>>>> (Assuming unlimited memory) >>>>>>>>>>>>>> When 1 to a googolplex of steps of D are correctly >>>>>>>>>>>>>> simulated by H >>>>>>>>>>>>>> *the call from D to H(D,D) NEVER RETURNS* >>>>>>>>>>>>> >>>>>>>>>>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, >>>>>>>>>>>>> each paired with a DIFFERENT H, when simulated by that H, >>>>>>>>>>>>> the DIFFFERENT routines called by those DIFFERENT Ds to >>>>>>>>>>>>> that DIFFERENT H(D,D) is never simulated to an end. >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> _P() >>>>>>>>>>>> [000020e2] 55 push ebp ; housekeeping >>>>>>>>>>>> [000020e3] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>> [000020e5] 51 push ecx ; housekeeping >>>>>>>>>>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter >>>>>>>>>>>> [000020e9] 50 push eax ; push parameter >>>>>>>>>>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter >>>>>>>>>>>> [000020ed] 51 push ecx ; push parameter >>>>>>>>>>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P) >>>>>>>>>>>> [000020f3] 83c408 add esp,+08 >>>>>>>>>>>> [000020f6] 8945fc mov [ebp-04],eax >>>>>>>>>>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00 >>>>>>>>>>>> [000020fd] 7402 jz 00002101 >>>>>>>>>>>> [000020ff] ebfe jmp 000020ff >>>>>>>>>>>> [00002101] 8b45fc mov eax,[ebp-04] >>>>>>>>>>>> [00002104] 8be5 mov esp,ebp >>>>>>>>>>>> [00002106] 5d pop ebp >>>>>>>>>>>> [00002107] c3 ret >>>>>>>>>>>> Size in bytes:(0038) [00002107] >>>>>>>>>>>> >>>>>>>>>>>> The call from D to H(D,D) cannot possibly return when D >>>>>>>>>>>> is correctly simulated by any H that can possibly exist. >>>>>>>>>>>> >>>>>>>>>>>> Unless you say yes you are correct we cannot move on to >>>>>>>>>>>> the next point. >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> No, the call most definitinely DOES return, but that return >>>>>>>>>>> is after the simulation ended. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> Maybe the real problem is that you have insufficient technical >>>>>>>>>> competence. >>>>>>>>> >>>>>>>>> Nope, that isn't the problem. I KNOW what I am talking about, >>>>>>>>> as opposed to you who can't even write a simple Turing Machine. >>>>>>>>> >>>>>>>>>> >>>>>>>>>>> Your problem is that, strictly, by your definition of >>>>>>>>>>> "Correct Simulation", >>>>>>>>>> >>>>>>>>>> The semantics of the x86 language objectively proves that I am >>>>>>>>>> correct. >>>>>>>>>> Have you been faking your technical competence? >>>>>>>>> >>>>>>>>> Nope. >>>>>>>>> >>>>>>>>>> >>>>>>>>>> Can you do better with this simpler example? >>>>>>>>>> >>>>>>>>>> _DDD() >>>>>>>>>> [00002172] 55 push ebp ; housekeeping >>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >>>>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>> [00002183] c3 ret >>>>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>>>> >>>>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated >>>>>>>>>> by H0 cannot possibly return. >>>>>>>>>> >>>>>>>>>> >>>>>>>>> >>>>>>>>> But the call will, just not in the simulation that your H0 does. >>>>>>>>> >>>>>>>> >>>>>>>> OK so we are back to you being a freaking liar trying to get >>>>>>>> away with contradicting the semantics of the x86 language. >>>>>>>> >>>>>>> >>>>>>> How does that contradictthe semantics of the x86 languge? >>>>>>> >>>>>>> If H0 is a decider, it will ALWAYS return an answer in finite time >>>>>> >>>>>> H0 is not even a decider yet. When you leap ahead you >>>>>> diverge from the point at hand. >>>>>> >>>>> >>>>> THen it is allowed to be the impure function , so you r claim is >>>>> proven false. >>>>> >>>> >>>> We have not even gotten that far yet. >>>> We ARE ONLY TALKING ABOUT the behavior of DDD correctly >>>> simulated by H0. AKA software engineering and NOT computer >>>> science. >>>> >>> >>> So, you have no grounds to exclude my version of H0, so your claim is >>> just proven false. >>> >> >> As soon as you quit lying we can move on to the next point. >> > > BUt YOU ARE the one that is caught in the lie. > You know that using static local variable to change the behavior is cheating so now you are a liar and a cheater. -- 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-26 19:52 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5i9j2$17ej0$2@i2pn2.org> |
| In reply to | #107881 |
On 6/26/24 7:50 PM, olcott wrote: > On 6/26/2024 6:41 PM, Richard Damon wrote: >> On 6/26/24 9:33 AM, olcott wrote: >>> On 6/26/2024 5:58 AM, Richard Damon wrote: >>>> On 6/25/24 11:37 PM, olcott wrote: >>>>> On 6/25/2024 10:32 PM, Richard Damon wrote: >>>>>> On 6/25/24 11:25 PM, olcott wrote: >>>>>>> On 6/25/2024 9:54 PM, Richard Damon wrote: >>>>>>>> On 6/25/24 10:21 PM, olcott wrote: >>>>>>>>> On 6/25/2024 9:17 PM, Richard Damon wrote: >>>>>>>>>> On 6/25/24 9:59 PM, olcott wrote: >>>>>>>>>>> On 6/25/2024 8:47 PM, Richard Damon wrote: >>>>>>>>>>>> On 6/25/24 9:02 AM, olcott wrote: >>>>>>>>>>>>> On 6/25/2024 6:04 AM, Richard Damon wrote: >>>>>>>>>>>>>> On 6/24/24 11:13 PM, olcott wrote: >>>>>>>>>>>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>> On 6/24/24 10:38 PM, olcott wrote: >>>>>>>>>>>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>>>>>>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> You still haven't shown where I lied, on where you >>>>>>>>>>>>>>>>>>>> don't like what I say. >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> You said that D correctly simulated by H must >>>>>>>>>>>>>>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the >>>>>>>>>>>>>>>>>>>> steps of the directly executed D(D) until H stops >>>>>>>>>>>>>>>>>>>> its simulation, >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> NOT ONE DIFFERENCE. >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> Honest mistake or liar? >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> The directly executed D(D) has identical behavior to >>>>>>>>>>>>>>>>>>> D correctly simulated by H1 >>>>>>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> This is not the same behavior as >>>>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> And what instruction did H's simulation differ from >>>>>>>>>>>>>>>>>> the direct executions trace? >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> Which isn't "Behavior of the input" >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> The "not happening" of something that could have >>>>>>>>>>>>>>>> happened except that the processing was stoped is NOT >>>>>>>>>>>>>>>> behavior. >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> D correctly simulated by H1 --- Identical to D(D) >>>>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> Right, and it contains ALL of the behavior of the >>>>>>>>>>>>>>>> correct simulation of D by H, plus more. >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that >>>>>>>>>>>>>>>> differnce isn't due to the input, but due to H. >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> *These are not the same behaviors* >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> (Assuming unlimited memory) >>>>>>>>>>>>>>> When 1 to a googolplex of steps of D are correctly >>>>>>>>>>>>>>> simulated by H >>>>>>>>>>>>>>> *the call from D to H(D,D) NEVER RETURNS* >>>>>>>>>>>>>> >>>>>>>>>>>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, >>>>>>>>>>>>>> each paired with a DIFFERENT H, when simulated by that H, >>>>>>>>>>>>>> the DIFFFERENT routines called by those DIFFERENT Ds to >>>>>>>>>>>>>> that DIFFERENT H(D,D) is never simulated to an end. >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> _P() >>>>>>>>>>>>> [000020e2] 55 push ebp ; housekeeping >>>>>>>>>>>>> [000020e3] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>> [000020e5] 51 push ecx ; housekeeping >>>>>>>>>>>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter >>>>>>>>>>>>> [000020e9] 50 push eax ; push parameter >>>>>>>>>>>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter >>>>>>>>>>>>> [000020ed] 51 push ecx ; push parameter >>>>>>>>>>>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P) >>>>>>>>>>>>> [000020f3] 83c408 add esp,+08 >>>>>>>>>>>>> [000020f6] 8945fc mov [ebp-04],eax >>>>>>>>>>>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00 >>>>>>>>>>>>> [000020fd] 7402 jz 00002101 >>>>>>>>>>>>> [000020ff] ebfe jmp 000020ff >>>>>>>>>>>>> [00002101] 8b45fc mov eax,[ebp-04] >>>>>>>>>>>>> [00002104] 8be5 mov esp,ebp >>>>>>>>>>>>> [00002106] 5d pop ebp >>>>>>>>>>>>> [00002107] c3 ret >>>>>>>>>>>>> Size in bytes:(0038) [00002107] >>>>>>>>>>>>> >>>>>>>>>>>>> The call from D to H(D,D) cannot possibly return when D >>>>>>>>>>>>> is correctly simulated by any H that can possibly exist. >>>>>>>>>>>>> >>>>>>>>>>>>> Unless you say yes you are correct we cannot move on to >>>>>>>>>>>>> the next point. >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> No, the call most definitinely DOES return, but that return >>>>>>>>>>>> is after the simulation ended. >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> Maybe the real problem is that you have insufficient >>>>>>>>>>> technical competence. >>>>>>>>>> >>>>>>>>>> Nope, that isn't the problem. I KNOW what I am talking about, >>>>>>>>>> as opposed to you who can't even write a simple Turing Machine. >>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>>> Your problem is that, strictly, by your definition of >>>>>>>>>>>> "Correct Simulation", >>>>>>>>>>> >>>>>>>>>>> The semantics of the x86 language objectively proves that I >>>>>>>>>>> am correct. >>>>>>>>>>> Have you been faking your technical competence? >>>>>>>>>> >>>>>>>>>> Nope. >>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> Can you do better with this simpler example? >>>>>>>>>>> >>>>>>>>>>> _DDD() >>>>>>>>>>> [00002172] 55 push ebp ; housekeeping >>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >>>>>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>> [00002183] c3 ret >>>>>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>>>>> >>>>>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated >>>>>>>>>>> by H0 cannot possibly return. >>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> But the call will, just not in the simulation that your H0 does. >>>>>>>>>> >>>>>>>>> >>>>>>>>> OK so we are back to you being a freaking liar trying to get >>>>>>>>> away with contradicting the semantics of the x86 language. >>>>>>>>> >>>>>>>> >>>>>>>> How does that contradictthe semantics of the x86 languge? >>>>>>>> >>>>>>>> If H0 is a decider, it will ALWAYS return an answer in finite time >>>>>>> >>>>>>> H0 is not even a decider yet. When you leap ahead you >>>>>>> diverge from the point at hand. >>>>>>> >>>>>> >>>>>> THen it is allowed to be the impure function , so you r claim is >>>>>> proven false. >>>>>> >>>>> >>>>> We have not even gotten that far yet. >>>>> We ARE ONLY TALKING ABOUT the behavior of DDD correctly >>>>> simulated by H0. AKA software engineering and NOT computer >>>>> science. >>>>> >>>> >>>> So, you have no grounds to exclude my version of H0, so your claim >>>> is just proven false. >>>> >>> >>> As soon as you quit lying we can move on to the next point. >>> >> >> BUt YOU ARE the one that is caught in the lie. >> > > You know that using static local variable to change the behavior > is cheating so now you are a liar and a cheater. > Where is the rule it broke? You didn't state it, and said that this was a total fresh thread as we couldn't use the fact that you are going to call H0 a Halt Decider.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 19:19 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5ib68$2cko8$3@dont-email.me> |
| In reply to | #107882 |
On 6/26/2024 6:52 PM, Richard Damon wrote: > On 6/26/24 7:50 PM, olcott wrote: >> On 6/26/2024 6:41 PM, Richard Damon wrote: >>> On 6/26/24 9:33 AM, olcott wrote: >>>> On 6/26/2024 5:58 AM, Richard Damon wrote: >>>>> On 6/25/24 11:37 PM, olcott wrote: >>>>>> On 6/25/2024 10:32 PM, Richard Damon wrote: >>>>>>> On 6/25/24 11:25 PM, olcott wrote: >>>>>>>> On 6/25/2024 9:54 PM, Richard Damon wrote: >>>>>>>>> On 6/25/24 10:21 PM, olcott wrote: >>>>>>>>>> On 6/25/2024 9:17 PM, Richard Damon wrote: >>>>>>>>>>> On 6/25/24 9:59 PM, olcott wrote: >>>>>>>>>>>> On 6/25/2024 8:47 PM, Richard Damon wrote: >>>>>>>>>>>>> On 6/25/24 9:02 AM, olcott wrote: >>>>>>>>>>>>>> On 6/25/2024 6:04 AM, Richard Damon wrote: >>>>>>>>>>>>>>> On 6/24/24 11:13 PM, olcott wrote: >>>>>>>>>>>>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>> On 6/24/24 10:38 PM, olcott wrote: >>>>>>>>>>>>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> You still haven't shown where I lied, on where you >>>>>>>>>>>>>>>>>>>>> don't like what I say. >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>> You said that D correctly simulated by H must >>>>>>>>>>>>>>>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the >>>>>>>>>>>>>>>>>>>>> steps of the directly executed D(D) until H stops >>>>>>>>>>>>>>>>>>>>> its simulation, >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> NOT ONE DIFFERENCE. >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> Honest mistake or liar? >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> The directly executed D(D) has identical behavior to >>>>>>>>>>>>>>>>>>>> D correctly simulated by H1 >>>>>>>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> This is not the same behavior as >>>>>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> And what instruction did H's simulation differ from >>>>>>>>>>>>>>>>>>> the direct executions trace? >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> Which isn't "Behavior of the input" >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> The "not happening" of something that could have >>>>>>>>>>>>>>>>> happened except that the processing was stoped is NOT >>>>>>>>>>>>>>>>> behavior. >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> D correctly simulated by H1 --- Identical to D(D) >>>>>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> Right, and it contains ALL of the behavior of the >>>>>>>>>>>>>>>>> correct simulation of D by H, plus more. >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that >>>>>>>>>>>>>>>>> differnce isn't due to the input, but due to H. >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> *These are not the same behaviors* >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> (Assuming unlimited memory) >>>>>>>>>>>>>>>> When 1 to a googolplex of steps of D are correctly >>>>>>>>>>>>>>>> simulated by H >>>>>>>>>>>>>>>> *the call from D to H(D,D) NEVER RETURNS* >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, >>>>>>>>>>>>>>> each paired with a DIFFERENT H, when simulated by that H, >>>>>>>>>>>>>>> the DIFFFERENT routines called by those DIFFERENT Ds to >>>>>>>>>>>>>>> that DIFFERENT H(D,D) is never simulated to an end. >>>>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> _P() >>>>>>>>>>>>>> [000020e2] 55 push ebp ; housekeeping >>>>>>>>>>>>>> [000020e3] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>>> [000020e5] 51 push ecx ; housekeeping >>>>>>>>>>>>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter >>>>>>>>>>>>>> [000020e9] 50 push eax ; push parameter >>>>>>>>>>>>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter >>>>>>>>>>>>>> [000020ed] 51 push ecx ; push parameter >>>>>>>>>>>>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P) >>>>>>>>>>>>>> [000020f3] 83c408 add esp,+08 >>>>>>>>>>>>>> [000020f6] 8945fc mov [ebp-04],eax >>>>>>>>>>>>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00 >>>>>>>>>>>>>> [000020fd] 7402 jz 00002101 >>>>>>>>>>>>>> [000020ff] ebfe jmp 000020ff >>>>>>>>>>>>>> [00002101] 8b45fc mov eax,[ebp-04] >>>>>>>>>>>>>> [00002104] 8be5 mov esp,ebp >>>>>>>>>>>>>> [00002106] 5d pop ebp >>>>>>>>>>>>>> [00002107] c3 ret >>>>>>>>>>>>>> Size in bytes:(0038) [00002107] >>>>>>>>>>>>>> >>>>>>>>>>>>>> The call from D to H(D,D) cannot possibly return when D >>>>>>>>>>>>>> is correctly simulated by any H that can possibly exist. >>>>>>>>>>>>>> >>>>>>>>>>>>>> Unless you say yes you are correct we cannot move on to >>>>>>>>>>>>>> the next point. >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> No, the call most definitinely DOES return, but that return >>>>>>>>>>>>> is after the simulation ended. >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> Maybe the real problem is that you have insufficient >>>>>>>>>>>> technical competence. >>>>>>>>>>> >>>>>>>>>>> Nope, that isn't the problem. I KNOW what I am talking about, >>>>>>>>>>> as opposed to you who can't even write a simple Turing Machine. >>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>>> Your problem is that, strictly, by your definition of >>>>>>>>>>>>> "Correct Simulation", >>>>>>>>>>>> >>>>>>>>>>>> The semantics of the x86 language objectively proves that I >>>>>>>>>>>> am correct. >>>>>>>>>>>> Have you been faking your technical competence? >>>>>>>>>>> >>>>>>>>>>> Nope. >>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> Can you do better with this simpler example? >>>>>>>>>>>> >>>>>>>>>>>> _DDD() >>>>>>>>>>>> [00002172] 55 push ebp ; housekeeping >>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >>>>>>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>>> [00002183] c3 ret >>>>>>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>>>>>> >>>>>>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated >>>>>>>>>>>> by H0 cannot possibly return. >>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> But the call will, just not in the simulation that your H0 does. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> OK so we are back to you being a freaking liar trying to get >>>>>>>>>> away with contradicting the semantics of the x86 language. >>>>>>>>>> >>>>>>>>> >>>>>>>>> How does that contradictthe semantics of the x86 languge? >>>>>>>>> >>>>>>>>> If H0 is a decider, it will ALWAYS return an answer in finite time >>>>>>>> >>>>>>>> H0 is not even a decider yet. When you leap ahead you >>>>>>>> diverge from the point at hand. >>>>>>>> >>>>>>> >>>>>>> THen it is allowed to be the impure function , so you r claim is >>>>>>> proven false. >>>>>>> >>>>>> >>>>>> We have not even gotten that far yet. >>>>>> We ARE ONLY TALKING ABOUT the behavior of DDD correctly >>>>>> simulated by H0. AKA software engineering and NOT computer >>>>>> science. >>>>>> >>>>> >>>>> So, you have no grounds to exclude my version of H0, so your claim >>>>> is just proven false. >>>>> >>>> >>>> As soon as you quit lying we can move on to the next point. >>>> >>> >>> BUt YOU ARE the one that is caught in the lie. >>> >> >> You know that using static local variable to change the behavior >> is cheating so now you are a liar and a cheater. >> > > Where is the rule it broke? > > You didn't state it, and said that this was a total fresh thread as we > couldn't use the fact that you are going to call H0 a Halt Decider. We have already been over this. Just quit your lying and cheating. -- 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-26 20:38 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5ic9i$17ej1$6@i2pn2.org> |
| In reply to | #107884 |
On 6/26/24 8:19 PM, olcott wrote: > On 6/26/2024 6:52 PM, Richard Damon wrote: >> On 6/26/24 7:50 PM, olcott wrote: >>> On 6/26/2024 6:41 PM, Richard Damon wrote: >>>> On 6/26/24 9:33 AM, olcott wrote: >>>>> On 6/26/2024 5:58 AM, Richard Damon wrote: >>>>>> On 6/25/24 11:37 PM, olcott wrote: >>>>>>> On 6/25/2024 10:32 PM, Richard Damon wrote: >>>>>>>> On 6/25/24 11:25 PM, olcott wrote: >>>>>>>>> On 6/25/2024 9:54 PM, Richard Damon wrote: >>>>>>>>>> On 6/25/24 10:21 PM, olcott wrote: >>>>>>>>>>> On 6/25/2024 9:17 PM, Richard Damon wrote: >>>>>>>>>>>> On 6/25/24 9:59 PM, olcott wrote: >>>>>>>>>>>>> On 6/25/2024 8:47 PM, Richard Damon wrote: >>>>>>>>>>>>>> On 6/25/24 9:02 AM, olcott wrote: >>>>>>>>>>>>>>> On 6/25/2024 6:04 AM, Richard Damon wrote: >>>>>>>>>>>>>>>> On 6/24/24 11:13 PM, olcott wrote: >>>>>>>>>>>>>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 6/24/24 10:38 PM, olcott wrote: >>>>>>>>>>>>>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>> You still haven't shown where I lied, on where you >>>>>>>>>>>>>>>>>>>>>> don't like what I say. >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>> You said that D correctly simulated by H must >>>>>>>>>>>>>>>>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the >>>>>>>>>>>>>>>>>>>>>> steps of the directly executed D(D) until H stops >>>>>>>>>>>>>>>>>>>>>> its simulation, >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>> NOT ONE DIFFERENCE. >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> Honest mistake or liar? >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> The directly executed D(D) has identical behavior to >>>>>>>>>>>>>>>>>>>>> D correctly simulated by H1 >>>>>>>>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> This is not the same behavior as >>>>>>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> And what instruction did H's simulation differ from >>>>>>>>>>>>>>>>>>>> the direct executions trace? >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> Which isn't "Behavior of the input" >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> The "not happening" of something that could have >>>>>>>>>>>>>>>>>> happened except that the processing was stoped is NOT >>>>>>>>>>>>>>>>>> behavior. >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> D correctly simulated by H1 --- Identical to D(D) >>>>>>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> Right, and it contains ALL of the behavior of the >>>>>>>>>>>>>>>>>> correct simulation of D by H, plus more. >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that >>>>>>>>>>>>>>>>>> differnce isn't due to the input, but due to H. >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> *These are not the same behaviors* >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> (Assuming unlimited memory) >>>>>>>>>>>>>>>>> When 1 to a googolplex of steps of D are correctly >>>>>>>>>>>>>>>>> simulated by H >>>>>>>>>>>>>>>>> *the call from D to H(D,D) NEVER RETURNS* >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, >>>>>>>>>>>>>>>> each paired with a DIFFERENT H, when simulated by that >>>>>>>>>>>>>>>> H, the DIFFFERENT routines called by those DIFFERENT Ds >>>>>>>>>>>>>>>> to that DIFFERENT H(D,D) is never simulated to an end. >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> _P() >>>>>>>>>>>>>>> [000020e2] 55 push ebp ; housekeeping >>>>>>>>>>>>>>> [000020e3] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>>>> [000020e5] 51 push ecx ; housekeeping >>>>>>>>>>>>>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter >>>>>>>>>>>>>>> [000020e9] 50 push eax ; push >>>>>>>>>>>>>>> parameter >>>>>>>>>>>>>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter >>>>>>>>>>>>>>> [000020ed] 51 push ecx ; push >>>>>>>>>>>>>>> parameter >>>>>>>>>>>>>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P) >>>>>>>>>>>>>>> [000020f3] 83c408 add esp,+08 >>>>>>>>>>>>>>> [000020f6] 8945fc mov [ebp-04],eax >>>>>>>>>>>>>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00 >>>>>>>>>>>>>>> [000020fd] 7402 jz 00002101 >>>>>>>>>>>>>>> [000020ff] ebfe jmp 000020ff >>>>>>>>>>>>>>> [00002101] 8b45fc mov eax,[ebp-04] >>>>>>>>>>>>>>> [00002104] 8be5 mov esp,ebp >>>>>>>>>>>>>>> [00002106] 5d pop ebp >>>>>>>>>>>>>>> [00002107] c3 ret >>>>>>>>>>>>>>> Size in bytes:(0038) [00002107] >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> The call from D to H(D,D) cannot possibly return when D >>>>>>>>>>>>>>> is correctly simulated by any H that can possibly exist. >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> Unless you say yes you are correct we cannot move on to >>>>>>>>>>>>>>> the next point. >>>>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> No, the call most definitinely DOES return, but that >>>>>>>>>>>>>> return is after the simulation ended. >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> Maybe the real problem is that you have insufficient >>>>>>>>>>>>> technical competence. >>>>>>>>>>>> >>>>>>>>>>>> Nope, that isn't the problem. I KNOW what I am talking >>>>>>>>>>>> about, as opposed to you who can't even write a simple >>>>>>>>>>>> Turing Machine. >>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>>> Your problem is that, strictly, by your definition of >>>>>>>>>>>>>> "Correct Simulation", >>>>>>>>>>>>> >>>>>>>>>>>>> The semantics of the x86 language objectively proves that I >>>>>>>>>>>>> am correct. >>>>>>>>>>>>> Have you been faking your technical competence? >>>>>>>>>>>> >>>>>>>>>>>> Nope. >>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> Can you do better with this simpler example? >>>>>>>>>>>>> >>>>>>>>>>>>> _DDD() >>>>>>>>>>>>> [00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >>>>>>>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>>>> [00002183] c3 ret >>>>>>>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>>>>>>> >>>>>>>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated >>>>>>>>>>>>> by H0 cannot possibly return. >>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> But the call will, just not in the simulation that your H0 >>>>>>>>>>>> does. >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> OK so we are back to you being a freaking liar trying to get >>>>>>>>>>> away with contradicting the semantics of the x86 language. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> How does that contradictthe semantics of the x86 languge? >>>>>>>>>> >>>>>>>>>> If H0 is a decider, it will ALWAYS return an answer in finite >>>>>>>>>> time >>>>>>>>> >>>>>>>>> H0 is not even a decider yet. When you leap ahead you >>>>>>>>> diverge from the point at hand. >>>>>>>>> >>>>>>>> >>>>>>>> THen it is allowed to be the impure function , so you r claim is >>>>>>>> proven false. >>>>>>>> >>>>>>> >>>>>>> We have not even gotten that far yet. >>>>>>> We ARE ONLY TALKING ABOUT the behavior of DDD correctly >>>>>>> simulated by H0. AKA software engineering and NOT computer >>>>>>> science. >>>>>>> >>>>>> >>>>>> So, you have no grounds to exclude my version of H0, so your claim >>>>>> is just proven false. >>>>>> >>>>> >>>>> As soon as you quit lying we can move on to the next point. >>>>> >>>> >>>> BUt YOU ARE the one that is caught in the lie. >>>> >>> >>> You know that using static local variable to change the behavior >>> is cheating so now you are a liar and a cheater. >>> >> >> Where is the rule it broke? >> >> You didn't state it, and said that this was a total fresh thread as we >> couldn't use the fact that you are going to call H0 a Halt Decider. > > We have already been over this. Just quit your lying and cheating. > And you canceled that by saying you were starting fresh, and we couldn't bring up your description of it as a Halt Decider. And, if you impose that requirement, then the decider "correct emulation" of the call instruction MUST be compatible with the behavior of the direct execuiton of the call to the decider, so if the decider returns to main, it CAN NOT CORRECTLY conclude that the emulated call can not return. PERIOD. You can't have it both ways. One follows from the other. You ignore that truth at your own peril, of being logically incorrect, and for becoming a damined liar.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 19:24 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5ibfc$2cko8$5@dont-email.me> |
| In reply to | #107882 |
On 6/26/2024 6:52 PM, Richard Damon wrote: > On 6/26/24 7:50 PM, olcott wrote: >> On 6/26/2024 6:41 PM, Richard Damon wrote: >>> On 6/26/24 9:33 AM, olcott wrote: >>>> On 6/26/2024 5:58 AM, Richard Damon wrote: >>>>> On 6/25/24 11:37 PM, olcott wrote: >>>>>> On 6/25/2024 10:32 PM, Richard Damon wrote: >>>>>>> On 6/25/24 11:25 PM, olcott wrote: >>>>>>>> On 6/25/2024 9:54 PM, Richard Damon wrote: >>>>>>>>> On 6/25/24 10:21 PM, olcott wrote: >>>>>>>>>> On 6/25/2024 9:17 PM, Richard Damon wrote: >>>>>>>>>>> On 6/25/24 9:59 PM, olcott wrote: >>>>>>>>>>>> On 6/25/2024 8:47 PM, Richard Damon wrote: >>>>>>>>>>>>> On 6/25/24 9:02 AM, olcott wrote: >>>>>>>>>>>>>> On 6/25/2024 6:04 AM, Richard Damon wrote: >>>>>>>>>>>>>>> On 6/24/24 11:13 PM, olcott wrote: >>>>>>>>>>>>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>> On 6/24/24 10:38 PM, olcott wrote: >>>>>>>>>>>>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> You still haven't shown where I lied, on where you >>>>>>>>>>>>>>>>>>>>> don't like what I say. >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>> You said that D correctly simulated by H must >>>>>>>>>>>>>>>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the >>>>>>>>>>>>>>>>>>>>> steps of the directly executed D(D) until H stops >>>>>>>>>>>>>>>>>>>>> its simulation, >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> NOT ONE DIFFERENCE. >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> Honest mistake or liar? >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> The directly executed D(D) has identical behavior to >>>>>>>>>>>>>>>>>>>> D correctly simulated by H1 >>>>>>>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> This is not the same behavior as >>>>>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> And what instruction did H's simulation differ from >>>>>>>>>>>>>>>>>>> the direct executions trace? >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> Which isn't "Behavior of the input" >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> The "not happening" of something that could have >>>>>>>>>>>>>>>>> happened except that the processing was stoped is NOT >>>>>>>>>>>>>>>>> behavior. >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> D correctly simulated by H1 --- Identical to D(D) >>>>>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> Right, and it contains ALL of the behavior of the >>>>>>>>>>>>>>>>> correct simulation of D by H, plus more. >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that >>>>>>>>>>>>>>>>> differnce isn't due to the input, but due to H. >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> *These are not the same behaviors* >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> (Assuming unlimited memory) >>>>>>>>>>>>>>>> When 1 to a googolplex of steps of D are correctly >>>>>>>>>>>>>>>> simulated by H >>>>>>>>>>>>>>>> *the call from D to H(D,D) NEVER RETURNS* >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, >>>>>>>>>>>>>>> each paired with a DIFFERENT H, when simulated by that H, >>>>>>>>>>>>>>> the DIFFFERENT routines called by those DIFFERENT Ds to >>>>>>>>>>>>>>> that DIFFERENT H(D,D) is never simulated to an end. >>>>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> _P() >>>>>>>>>>>>>> [000020e2] 55 push ebp ; housekeeping >>>>>>>>>>>>>> [000020e3] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>>> [000020e5] 51 push ecx ; housekeeping >>>>>>>>>>>>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter >>>>>>>>>>>>>> [000020e9] 50 push eax ; push parameter >>>>>>>>>>>>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter >>>>>>>>>>>>>> [000020ed] 51 push ecx ; push parameter >>>>>>>>>>>>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P) >>>>>>>>>>>>>> [000020f3] 83c408 add esp,+08 >>>>>>>>>>>>>> [000020f6] 8945fc mov [ebp-04],eax >>>>>>>>>>>>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00 >>>>>>>>>>>>>> [000020fd] 7402 jz 00002101 >>>>>>>>>>>>>> [000020ff] ebfe jmp 000020ff >>>>>>>>>>>>>> [00002101] 8b45fc mov eax,[ebp-04] >>>>>>>>>>>>>> [00002104] 8be5 mov esp,ebp >>>>>>>>>>>>>> [00002106] 5d pop ebp >>>>>>>>>>>>>> [00002107] c3 ret >>>>>>>>>>>>>> Size in bytes:(0038) [00002107] >>>>>>>>>>>>>> >>>>>>>>>>>>>> The call from D to H(D,D) cannot possibly return when D >>>>>>>>>>>>>> is correctly simulated by any H that can possibly exist. >>>>>>>>>>>>>> >>>>>>>>>>>>>> Unless you say yes you are correct we cannot move on to >>>>>>>>>>>>>> the next point. >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> No, the call most definitinely DOES return, but that return >>>>>>>>>>>>> is after the simulation ended. >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> Maybe the real problem is that you have insufficient >>>>>>>>>>>> technical competence. >>>>>>>>>>> >>>>>>>>>>> Nope, that isn't the problem. I KNOW what I am talking about, >>>>>>>>>>> as opposed to you who can't even write a simple Turing Machine. >>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>>> Your problem is that, strictly, by your definition of >>>>>>>>>>>>> "Correct Simulation", >>>>>>>>>>>> >>>>>>>>>>>> The semantics of the x86 language objectively proves that I >>>>>>>>>>>> am correct. >>>>>>>>>>>> Have you been faking your technical competence? >>>>>>>>>>> >>>>>>>>>>> Nope. >>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> Can you do better with this simpler example? >>>>>>>>>>>> >>>>>>>>>>>> _DDD() >>>>>>>>>>>> [00002172] 55 push ebp ; housekeeping >>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >>>>>>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>>> [00002183] c3 ret >>>>>>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>>>>>> >>>>>>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated >>>>>>>>>>>> by H0 cannot possibly return. >>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> But the call will, just not in the simulation that your H0 does. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> OK so we are back to you being a freaking liar trying to get >>>>>>>>>> away with contradicting the semantics of the x86 language. >>>>>>>>>> >>>>>>>>> >>>>>>>>> How does that contradictthe semantics of the x86 languge? >>>>>>>>> >>>>>>>>> If H0 is a decider, it will ALWAYS return an answer in finite time >>>>>>>> >>>>>>>> H0 is not even a decider yet. When you leap ahead you >>>>>>>> diverge from the point at hand. >>>>>>>> >>>>>>> >>>>>>> THen it is allowed to be the impure function , so you r claim is >>>>>>> proven false. >>>>>>> >>>>>> >>>>>> We have not even gotten that far yet. >>>>>> We ARE ONLY TALKING ABOUT the behavior of DDD correctly >>>>>> simulated by H0. AKA software engineering and NOT computer >>>>>> science. >>>>>> >>>>> >>>>> So, you have no grounds to exclude my version of H0, so your claim >>>>> is just proven false. >>>>> >>>> >>>> As soon as you quit lying we can move on to the next point. >>>> >>> >>> BUt YOU ARE the one that is caught in the lie. >>> >> >> You know that using static local variable to change the behavior >> is cheating so now you are a liar and a cheater. >> > > Where is the rule it broke? > > You didn't state it, and said that this was a total fresh thread as we > couldn't use the fact that you are going to call H0 a Halt Decider. Mike understands how your use of static variables is cheating. Others here will be baffled and confused. -- 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-26 20:40 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5icdm$17ej1$7@i2pn2.org> |
| In reply to | #107886 |
On 6/26/24 8:24 PM, olcott wrote: > On 6/26/2024 6:52 PM, Richard Damon wrote: >> On 6/26/24 7:50 PM, olcott wrote: >>> On 6/26/2024 6:41 PM, Richard Damon wrote: >>>> On 6/26/24 9:33 AM, olcott wrote: >>>>> On 6/26/2024 5:58 AM, Richard Damon wrote: >>>>>> On 6/25/24 11:37 PM, olcott wrote: >>>>>>> On 6/25/2024 10:32 PM, Richard Damon wrote: >>>>>>>> On 6/25/24 11:25 PM, olcott wrote: >>>>>>>>> On 6/25/2024 9:54 PM, Richard Damon wrote: >>>>>>>>>> On 6/25/24 10:21 PM, olcott wrote: >>>>>>>>>>> On 6/25/2024 9:17 PM, Richard Damon wrote: >>>>>>>>>>>> On 6/25/24 9:59 PM, olcott wrote: >>>>>>>>>>>>> On 6/25/2024 8:47 PM, Richard Damon wrote: >>>>>>>>>>>>>> On 6/25/24 9:02 AM, olcott wrote: >>>>>>>>>>>>>>> On 6/25/2024 6:04 AM, Richard Damon wrote: >>>>>>>>>>>>>>>> On 6/24/24 11:13 PM, olcott wrote: >>>>>>>>>>>>>>>>> On 6/24/2024 9:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 6/24/24 10:38 PM, olcott wrote: >>>>>>>>>>>>>>>>>>> On 6/24/2024 9:26 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 6/24/24 10:21 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>> On 6/24/2024 9:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/24/24 9:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>>>>> *We can get to that as soon as you reverse your lie* >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>> You still haven't shown where I lied, on where you >>>>>>>>>>>>>>>>>>>>>> don't like what I say. >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>> You said that D correctly simulated by H must >>>>>>>>>>>>>>>>>>>>>>> have the behavior of the directly executed D(D). >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>> Right, the steps that H sees are IDENTIAL to the >>>>>>>>>>>>>>>>>>>>>> steps of the directly executed D(D) until H stops >>>>>>>>>>>>>>>>>>>>>> its simulation, >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>> NOT ONE DIFFERENCE. >>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> Honest mistake or liar? >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> The directly executed D(D) has identical behavior to >>>>>>>>>>>>>>>>>>>>> D correctly simulated by H1 >>>>>>>>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> This is not the same behavior as >>>>>>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>> And what instruction did H's simulation differ from >>>>>>>>>>>>>>>>>>>> the direct executions trace? >>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>>>> *the call from D to H(D,D) DOES NOT return* >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> Which isn't "Behavior of the input" >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> The "not happening" of something that could have >>>>>>>>>>>>>>>>>> happened except that the processing was stoped is NOT >>>>>>>>>>>>>>>>>> behavior. >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>> D correctly simulated by H1 --- Identical to D(D) >>>>>>>>>>>>>>>>>>> *the call from D to H(D,D) returns* >>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> Right, and it contains ALL of the behavior of the >>>>>>>>>>>>>>>>>> correct simulation of D by H, plus more. >>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>> H doesn't see DIFFERENT behavior, just LESS, and that >>>>>>>>>>>>>>>>>> differnce isn't due to the input, but due to H. >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> *These are not the same behaviors* >>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>> (Assuming unlimited memory) >>>>>>>>>>>>>>>>> When 1 to a googolplex of steps of D are correctly >>>>>>>>>>>>>>>>> simulated by H >>>>>>>>>>>>>>>>> *the call from D to H(D,D) NEVER RETURNS* >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> Correction, 1 to a googleplex of steps if DIFFERENT Ds, >>>>>>>>>>>>>>>> each paired with a DIFFERENT H, when simulated by that >>>>>>>>>>>>>>>> H, the DIFFFERENT routines called by those DIFFERENT Ds >>>>>>>>>>>>>>>> to that DIFFERENT H(D,D) is never simulated to an end. >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> _P() >>>>>>>>>>>>>>> [000020e2] 55 push ebp ; housekeeping >>>>>>>>>>>>>>> [000020e3] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>>>> [000020e5] 51 push ecx ; housekeeping >>>>>>>>>>>>>>> [000020e6] 8b4508 mov eax,[ebp+08] ; parameter >>>>>>>>>>>>>>> [000020e9] 50 push eax ; push >>>>>>>>>>>>>>> parameter >>>>>>>>>>>>>>> [000020ea] 8b4d08 mov ecx,[ebp+08] ; parameter >>>>>>>>>>>>>>> [000020ed] 51 push ecx ; push >>>>>>>>>>>>>>> parameter >>>>>>>>>>>>>>> [000020ee] e82ff3ffff call 00001422 ; call H(P,P) >>>>>>>>>>>>>>> [000020f3] 83c408 add esp,+08 >>>>>>>>>>>>>>> [000020f6] 8945fc mov [ebp-04],eax >>>>>>>>>>>>>>> [000020f9] 837dfc00 cmp dword [ebp-04],+00 >>>>>>>>>>>>>>> [000020fd] 7402 jz 00002101 >>>>>>>>>>>>>>> [000020ff] ebfe jmp 000020ff >>>>>>>>>>>>>>> [00002101] 8b45fc mov eax,[ebp-04] >>>>>>>>>>>>>>> [00002104] 8be5 mov esp,ebp >>>>>>>>>>>>>>> [00002106] 5d pop ebp >>>>>>>>>>>>>>> [00002107] c3 ret >>>>>>>>>>>>>>> Size in bytes:(0038) [00002107] >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> The call from D to H(D,D) cannot possibly return when D >>>>>>>>>>>>>>> is correctly simulated by any H that can possibly exist. >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> Unless you say yes you are correct we cannot move on to >>>>>>>>>>>>>>> the next point. >>>>>>>>>>>>>>> >>>>>>>>>>>>>> >>>>>>>>>>>>>> No, the call most definitinely DOES return, but that >>>>>>>>>>>>>> return is after the simulation ended. >>>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> Maybe the real problem is that you have insufficient >>>>>>>>>>>>> technical competence. >>>>>>>>>>>> >>>>>>>>>>>> Nope, that isn't the problem. I KNOW what I am talking >>>>>>>>>>>> about, as opposed to you who can't even write a simple >>>>>>>>>>>> Turing Machine. >>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>>> Your problem is that, strictly, by your definition of >>>>>>>>>>>>>> "Correct Simulation", >>>>>>>>>>>>> >>>>>>>>>>>>> The semantics of the x86 language objectively proves that I >>>>>>>>>>>>> am correct. >>>>>>>>>>>>> Have you been faking your technical competence? >>>>>>>>>>>> >>>>>>>>>>>> Nope. >>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>>> Can you do better with this simpler example? >>>>>>>>>>>>> >>>>>>>>>>>>> _DDD() >>>>>>>>>>>>> [00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) >>>>>>>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>>>> [00002183] c3 ret >>>>>>>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>>>>>>> >>>>>>>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated >>>>>>>>>>>>> by H0 cannot possibly return. >>>>>>>>>>>>> >>>>>>>>>>>>> >>>>>>>>>>>> >>>>>>>>>>>> But the call will, just not in the simulation that your H0 >>>>>>>>>>>> does. >>>>>>>>>>>> >>>>>>>>>>> >>>>>>>>>>> OK so we are back to you being a freaking liar trying to get >>>>>>>>>>> away with contradicting the semantics of the x86 language. >>>>>>>>>>> >>>>>>>>>> >>>>>>>>>> How does that contradictthe semantics of the x86 languge? >>>>>>>>>> >>>>>>>>>> If H0 is a decider, it will ALWAYS return an answer in finite >>>>>>>>>> time >>>>>>>>> >>>>>>>>> H0 is not even a decider yet. When you leap ahead you >>>>>>>>> diverge from the point at hand. >>>>>>>>> >>>>>>>> >>>>>>>> THen it is allowed to be the impure function , so you r claim is >>>>>>>> proven false. >>>>>>>> >>>>>>> >>>>>>> We have not even gotten that far yet. >>>>>>> We ARE ONLY TALKING ABOUT the behavior of DDD correctly >>>>>>> simulated by H0. AKA software engineering and NOT computer >>>>>>> science. >>>>>>> >>>>>> >>>>>> So, you have no grounds to exclude my version of H0, so your claim >>>>>> is just proven false. >>>>>> >>>>> >>>>> As soon as you quit lying we can move on to the next point. >>>>> >>>> >>>> BUt YOU ARE the one that is caught in the lie. >>>> >>> >>> You know that using static local variable to change the behavior >>> is cheating so now you are a liar and a cheater. >>> >> >> Where is the rule it broke? >> >> You didn't state it, and said that this was a total fresh thread as we >> couldn't use the fact that you are going to call H0 a Halt Decider. > > Mike understands how your use of static variables is cheating. > Others here will be baffled and confused. > But the rules are the rules, and you can't create rules you didn't state. Remember, if the decider is a pure function, then the emulated call must do the same thing as the direct call, so one can not return and the other not. So, all you are doing is admitting that the ddciders emulation is just incorect (if you claim the emulation shows that) or its logic is incorrect.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 20:12 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5ie9f$2dcfs$1@dont-email.me> |
| In reply to | #107888 |
On 6/26/2024 7:40 PM, Richard Damon wrote: > On 6/26/24 8:24 PM, olcott wrote: >> On 6/26/2024 6:52 PM, Richard Damon wrote: >> >> Mike understands how your use of static variables is cheating. >> Others here will be baffled and confused. >> > > But the rules are the rules, and you can't create rules you didn't state. > If you really have such brain damage that you cannot remember that we already discussed this and closed it I will start praying for you. YOU CAN'T FREAKING USE ANY STATIC LOCAL VARIABLES TO CHANGE THE BEHAVIOR AND YOU KNOW WHY YOU CAN'T USE THEM SO FREAKING QUIT IT !!! _DDD() [00002172] 55 push ebp ; housekeeping [00002173] 8bec mov ebp,esp ; housekeeping [00002175] 6872210000 push 00002172 ; push DDD [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) [0000217f] 83c404 add esp,+04 [00002182] 5d pop ebp [00002183] c3 ret Size in bytes:(0018) [00002183] The call from DDD to H0(DDD) when DDD is correctly emulated by x86 emulator H0 cannot possibly return. -- 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-26 21:21 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5ieqg$17ej0$4@i2pn2.org> |
| In reply to | #107890 |
On 6/26/24 9:12 PM, olcott wrote: > On 6/26/2024 7:40 PM, Richard Damon wrote: >> On 6/26/24 8:24 PM, olcott wrote: >>> On 6/26/2024 6:52 PM, Richard Damon wrote: >>> >>> Mike understands how your use of static variables is cheating. >>> Others here will be baffled and confused. >>> >> >> But the rules are the rules, and you can't create rules you didn't state. >> > > If you really have such brain damage that you cannot remember > that we already discussed this and closed it I will start > praying for you. And if I am allowed, or even required to remember that, then I can remember that your Hs are all designed to be Halt Deciders, and thus the only correct behavior for their input is that of the direct execution of the program the input represents. > > YOU CAN'T FREAKING USE ANY STATIC LOCAL VARIABLES TO > CHANGE THE BEHAVIOR AND YOU KNOW WHY YOU CAN'T USE > THEM SO FREAKING QUIT IT !!! > > _DDD() > [00002172] 55 push ebp ; housekeeping > [00002173] 8bec mov ebp,esp ; housekeeping > [00002175] 6872210000 push 00002172 ; push DDD > [0000217a] e853f4ffff call 000015d2 ; call H0(DDD) > [0000217f] 83c404 add esp,+04 > [00002182] 5d pop ebp > [00002183] c3 ret > Size in bytes:(0018) [00002183] > > The call from DDD to H0(DDD) when DDD is correctly emulated > by x86 emulator H0 cannot possibly return. > > But it does, it just isn't emulated by H0. The "Correct Behavior" is not limited by the PARTIAL simulation done by H0. If H0 stops simulating and returns, it does not complete the CORRECT EMULATION of the input as defined, and thus can make no comment of the future that it can not prove. And, since the complete and correct emulation of the input does return if H0 ever returns an answer, it is impossible for it to correct say it doesn't. You just don't understand the meaning of the word you are using
[toc] | [prev] | [next] | [standalone]
Page 4 of 6 — ← Prev page 1 2 3 [4] 5 6 Next page →
Back to top | Article view | comp.theory
csiph-web