Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > sci.logic > #335887 > 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 105 — 3 participants |
Back to article view | Back to sci.logic
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 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 5 of 6 — ← Prev page 1 2 3 4 [5] 6 Next page →
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 21:10 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5ihn6$2hkk4$3@dont-email.me> |
| In reply to | #336047 |
On 6/26/2024 8:21 PM, Richard Damon wrote: > 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. > NONE-THE-LESS I WILL NOT TOLERATE YOU LEAPING TO THE CONCLUSION THAT I AM INCORRECT WITHOUT GOING THROUGH EVER SINGLE STEP. *When you do this I will point out your specific deceit* >> >> 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. > THAT IS THE FREAKING DAMNED LIAR STRAW-MAN DECEPTION. When I say that there are some people that are so poor that they are starving to death and we must halt them you cannot (morally) say there is no need to help them because rich people are not starving to death. Christ taught in parables I teach in isomorphisms. -- 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 22:38 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5ijbq$17ej1$10@i2pn2.org> |
| In reply to | #336053 |
On 6/26/24 10:10 PM, olcott wrote: > On 6/26/2024 8:21 PM, Richard Damon wrote: >> 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. >> > > NONE-THE-LESS I WILL NOT TOLERATE YOU LEAPING TO THE CONCLUSION > THAT I AM INCORRECT WITHOUT GOING THROUGH EVER SINGLE STEP. > *When you do this I will point out your specific deceit* But if you don't include the restriction, it isn't there, and the fact we are so many steps ahead of you isn't grounds to say we don't know what we know. > >>> >>> 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. >> > > THAT IS THE FREAKING DAMNED LIAR STRAW-MAN DECEPTION. The "Behavior" of the input is DEFINED by the semantics of the x86 instruction set. NO instruction, other than Halt, stops the processor from continuing, thus the behavior of the input doesn't stop just because the emulator stoped processing it. > > When I say that there are some people that are so poor > that they are starving to death and we must halt them > > you cannot (morally) say there is no need to help them > because rich people are not starving to death. RED HERRING. > > Christ taught in parables I teach in isomorphisms. > But broken ones, that are just RED HERRING LIES. And, I know Christ, and you are NOT Christ, and it is almost blasphemous for you to make that comparasion, especially since you have claimed to be God in the past. THAT WILL send you to Gehenna.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 21:46 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5ijq1$2i32s$1@dont-email.me> |
| In reply to | #336059 |
On 6/26/2024 9:38 PM, Richard Damon wrote: > On 6/26/24 10:10 PM, olcott wrote: >> On 6/26/2024 8:21 PM, Richard Damon wrote: >>> 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. >>> >> >> NONE-THE-LESS I WILL NOT TOLERATE YOU LEAPING TO THE CONCLUSION >> THAT I AM INCORRECT WITHOUT GOING THROUGH EVER SINGLE STEP. >> *When you do this I will point out your specific deceit* > > But if you don't include the restriction, it isn't there, and the fact > we are so many steps ahead of you isn't grounds to say we don't know > what we know. > >> >>>> >>>> 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. >>> >> >> THAT IS THE FREAKING DAMNED LIAR STRAW-MAN DECEPTION. > > The "Behavior" of the input is DEFINED by the semantics of the x86 > instruction set. > > NO instruction, other than Halt, stops the processor from continuing, > thus the behavior of the input doesn't stop just because the emulator > stoped processing it. > >> >> When I say that there are some people that are so poor >> that they are starving to death and we must halt them >> >> you cannot (morally) say there is no need to help them >> because rich people are not starving to death. > > RED HERRING. > >> >> Christ taught in parables I teach in isomorphisms. >> > > But broken ones, that are just RED HERRING LIES. > > And, I know Christ, and you are NOT Christ, and it is almost blasphemous > for you to make that comparasion, especially since you have claimed to > be God in the past. > > THAT WILL send you to Gehenna. I am not the liar here. I think that we have gone way beyond reasonable doubt that you have told lies. Maybe you are one of those "Christians" that believes once saved always saved even if you commit genocide for fun an profit. -- 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 23:16 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5ilj0$17ej1$15@i2pn2.org> |
| In reply to | #336062 |
On 6/26/24 10:46 PM, olcott wrote: > On 6/26/2024 9:38 PM, Richard Damon wrote: >> On 6/26/24 10:10 PM, olcott wrote: >>> On 6/26/2024 8:21 PM, Richard Damon wrote: >>>> 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. >>>> >>> >>> NONE-THE-LESS I WILL NOT TOLERATE YOU LEAPING TO THE CONCLUSION >>> THAT I AM INCORRECT WITHOUT GOING THROUGH EVER SINGLE STEP. >>> *When you do this I will point out your specific deceit* >> >> But if you don't include the restriction, it isn't there, and the fact >> we are so many steps ahead of you isn't grounds to say we don't know >> what we know. >> >>> >>>>> >>>>> 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. >>>> >>> >>> THAT IS THE FREAKING DAMNED LIAR STRAW-MAN DECEPTION. >> >> The "Behavior" of the input is DEFINED by the semantics of the x86 >> instruction set. >> >> NO instruction, other than Halt, stops the processor from continuing, >> thus the behavior of the input doesn't stop just because the emulator >> stoped processing it. >> >>> >>> When I say that there are some people that are so poor >>> that they are starving to death and we must halt them >>> >>> you cannot (morally) say there is no need to help them >>> because rich people are not starving to death. >> >> RED HERRING. >> >>> >>> Christ taught in parables I teach in isomorphisms. >>> >> >> But broken ones, that are just RED HERRING LIES. >> >> And, I know Christ, and you are NOT Christ, and it is almost >> blasphemous for you to make that comparasion, especially since you >> have claimed to be God in the past. >> >> THAT WILL send you to Gehenna. > > I am not the liar here. I think that we have gone > way beyond reasonable doubt that you have told lies. Really, so what statement have I said that isn't actually true. Not just that you disagree with it, since you have been proven to be a liar, but that you can actualy preove to be untrtue. Your ignorance does not make my statements lies. > > Maybe you are one of those "Christians" that believes > once saved always saved even if you commit genocide > for fun an profit. > Nope. You don't know me well, so you are just making your typical wild guesses with no basis. That is what gets you in trouble every time.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 22:37 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5imqf$2ie27$3@dont-email.me> |
| In reply to | #336067 |
On 6/26/2024 10:16 PM, Richard Damon wrote: > On 6/26/24 10:46 PM, olcott wrote: >> On 6/26/2024 9:38 PM, Richard Damon wrote: >>> On 6/26/24 10:10 PM, olcott wrote: >>>> On 6/26/2024 8:21 PM, Richard Damon wrote: >>>>> 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. >>>>> >>>> >>>> NONE-THE-LESS I WILL NOT TOLERATE YOU LEAPING TO THE CONCLUSION >>>> THAT I AM INCORRECT WITHOUT GOING THROUGH EVER SINGLE STEP. >>>> *When you do this I will point out your specific deceit* >>> >>> But if you don't include the restriction, it isn't there, and the >>> fact we are so many steps ahead of you isn't grounds to say we don't >>> know what we know. >>> >>>> >>>>>> >>>>>> 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. >>>>> >>>> >>>> THAT IS THE FREAKING DAMNED LIAR STRAW-MAN DECEPTION. >>> >>> The "Behavior" of the input is DEFINED by the semantics of the x86 >>> instruction set. >>> >>> NO instruction, other than Halt, stops the processor from continuing, >>> thus the behavior of the input doesn't stop just because the emulator >>> stoped processing it. >>> >>>> >>>> When I say that there are some people that are so poor >>>> that they are starving to death and we must halt them >>>> >>>> you cannot (morally) say there is no need to help them >>>> because rich people are not starving to death. >>> >>> RED HERRING. >>> >>>> >>>> Christ taught in parables I teach in isomorphisms. >>>> >>> >>> But broken ones, that are just RED HERRING LIES. >>> >>> And, I know Christ, and you are NOT Christ, and it is almost >>> blasphemous for you to make that comparasion, especially since you >>> have claimed to be God in the past. >>> >>> THAT WILL send you to Gehenna. >> >> I am not the liar here. I think that we have gone >> way beyond reasonable doubt that you have told lies. > > Really, so what statement have I said that isn't actually true. > > Not just that you disagree with it, since you have been proven to be a > liar, but that you can actualy preove to be untrtue. > > Your ignorance does not make my statements lies. > >> >> Maybe you are one of those "Christians" that believes >> once saved always saved even if you commit genocide >> for fun an profit. >> > > Nope. You don't know me well, so you are just making your typical wild > guesses with no basis. > That is what gets you in trouble every time. > As ALWAYS I hypothesize possibilities. Since you neither confirmed nor denied it remains open. You know that you are doing the best that you can to disable an honest dialogue. I have backed you into a corner on some of your lies. -- 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-27 07:34 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5jink$19368$1@i2pn2.org> |
| In reply to | #336070 |
On 6/26/24 11:37 PM, olcott wrote: > On 6/26/2024 10:16 PM, Richard Damon wrote: >> On 6/26/24 10:46 PM, olcott wrote: >>> On 6/26/2024 9:38 PM, Richard Damon wrote: >>>> On 6/26/24 10:10 PM, olcott wrote: >>>>> On 6/26/2024 8:21 PM, Richard Damon wrote: >>>>>> 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. >>>>>> >>>>> >>>>> NONE-THE-LESS I WILL NOT TOLERATE YOU LEAPING TO THE CONCLUSION >>>>> THAT I AM INCORRECT WITHOUT GOING THROUGH EVER SINGLE STEP. >>>>> *When you do this I will point out your specific deceit* >>>> >>>> But if you don't include the restriction, it isn't there, and the >>>> fact we are so many steps ahead of you isn't grounds to say we don't >>>> know what we know. >>>> >>>>> >>>>>>> >>>>>>> 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. >>>>>> >>>>> >>>>> THAT IS THE FREAKING DAMNED LIAR STRAW-MAN DECEPTION. >>>> >>>> The "Behavior" of the input is DEFINED by the semantics of the x86 >>>> instruction set. >>>> >>>> NO instruction, other than Halt, stops the processor from >>>> continuing, thus the behavior of the input doesn't stop just because >>>> the emulator stoped processing it. >>>> >>>>> >>>>> When I say that there are some people that are so poor >>>>> that they are starving to death and we must halt them >>>>> >>>>> you cannot (morally) say there is no need to help them >>>>> because rich people are not starving to death. >>>> >>>> RED HERRING. >>>> >>>>> >>>>> Christ taught in parables I teach in isomorphisms. >>>>> >>>> >>>> But broken ones, that are just RED HERRING LIES. >>>> >>>> And, I know Christ, and you are NOT Christ, and it is almost >>>> blasphemous for you to make that comparasion, especially since you >>>> have claimed to be God in the past. >>>> >>>> THAT WILL send you to Gehenna. >>> >>> I am not the liar here. I think that we have gone >>> way beyond reasonable doubt that you have told lies. >> >> Really, so what statement have I said that isn't actually true. >> >> Not just that you disagree with it, since you have been proven to be a >> liar, but that you can actualy preove to be untrtue. >> >> Your ignorance does not make my statements lies. >> >>> >>> Maybe you are one of those "Christians" that believes >>> once saved always saved even if you commit genocide >>> for fun an profit. >>> >> >> Nope. You don't know me well, so you are just making your typical wild >> guesses with no basis. >> That is what gets you in trouble every time. >> > > As ALWAYS I hypothesize possibilities. No, you hypothesize thing that might be impossibe, which are just lies. > Since you neither confirmed nor denied it remains open. It is unclear what "it" refers to, as usual for you. By normal grammer, it woudl be either that you hypothesize possibiliteis, and I have shown some of your claimed immpossiblities are just impossible, or the previous comment was that I might think that "committing genocide for fun and profit" is something a saved person might do. > > You know that you are doing the best that you can to > disable an honest dialogue. > > I have backed you into a corner on some of your lies. > What lies? That seems to be one of your biggest lies, you claim others are lying to try to disquise your own lies. You can't show one thing that I have said that is FACTUALY INCORRCT (only that you disagre with them). I have shown statements of your that ARE DEFINITIONALLY INCORRECT (even if you want to use a different definition, which just isn't allowed, and thus becomes a lie).
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-27 08:21 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5jp08$2o58l$1@dont-email.me> |
| In reply to | #336073 |
On 6/27/2024 6:34 AM, Richard Damon wrote: > On 6/26/24 11:37 PM, olcott wrote: >> On 6/26/2024 10:16 PM, Richard Damon wrote: >>> On 6/26/24 10:46 PM, olcott wrote: >>>> On 6/26/2024 9:38 PM, Richard Damon wrote: >>>>> On 6/26/24 10:10 PM, olcott wrote: >>>>>> On 6/26/2024 8:21 PM, Richard Damon wrote: >>>>>>> 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. >>>>>>> >>>>>> >>>>>> NONE-THE-LESS I WILL NOT TOLERATE YOU LEAPING TO THE CONCLUSION >>>>>> THAT I AM INCORRECT WITHOUT GOING THROUGH EVER SINGLE STEP. >>>>>> *When you do this I will point out your specific deceit* >>>>> >>>>> But if you don't include the restriction, it isn't there, and the >>>>> fact we are so many steps ahead of you isn't grounds to say we >>>>> don't know what we know. >>>>> >>>>>> >>>>>>>> >>>>>>>> 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. >>>>>>> >>>>>> >>>>>> THAT IS THE FREAKING DAMNED LIAR STRAW-MAN DECEPTION. >>>>> >>>>> The "Behavior" of the input is DEFINED by the semantics of the x86 >>>>> instruction set. >>>>> >>>>> NO instruction, other than Halt, stops the processor from >>>>> continuing, thus the behavior of the input doesn't stop just >>>>> because the emulator stoped processing it. >>>>> >>>>>> >>>>>> When I say that there are some people that are so poor >>>>>> that they are starving to death and we must halt them >>>>>> >>>>>> you cannot (morally) say there is no need to help them >>>>>> because rich people are not starving to death. >>>>> >>>>> RED HERRING. >>>>> >>>>>> >>>>>> Christ taught in parables I teach in isomorphisms. >>>>>> >>>>> >>>>> But broken ones, that are just RED HERRING LIES. >>>>> >>>>> And, I know Christ, and you are NOT Christ, and it is almost >>>>> blasphemous for you to make that comparasion, especially since you >>>>> have claimed to be God in the past. >>>>> >>>>> THAT WILL send you to Gehenna. >>>> >>>> I am not the liar here. I think that we have gone >>>> way beyond reasonable doubt that you have told lies. >>> >>> Really, so what statement have I said that isn't actually true. >>> >>> Not just that you disagree with it, since you have been proven to be >>> a liar, but that you can actualy preove to be untrtue. >>> >>> Your ignorance does not make my statements lies. >>> >>>> >>>> Maybe you are one of those "Christians" that believes >>>> once saved always saved even if you commit genocide >>>> for fun an profit. >>>> >>> >>> Nope. You don't know me well, so you are just making your typical >>> wild guesses with no basis. >>> That is what gets you in trouble every time. >>> >> >> As ALWAYS I hypothesize possibilities. > > No, you hypothesize thing that might be impossibe, which are just lies. > This is merely your ignorance of how modal logic works. Modal Logic operators defined "◇" for "Possibly" and "□" for "Necessarily" ◇P ↔ ¬□¬P □P ↔¬◇¬P >> Since you neither confirmed nor denied it remains open. > > It is unclear what "it" refers to, as usual for you. > You neither affirmed nor denied whether you are a once saved always saved Christian or not. https://www.biblestudytools.com/bible-study/topical-studies/are-christians-really-once-saved-always-saved.html > > By normal grammer, it woudl be either that you hypothesize > possibiliteis, and I have shown some of your claimed immpossiblities are > just impossible, or the previous comment was that I might think that > "committing genocide for fun and profit" is something a saved person > might do. > >> >> You know that you are doing the best that you can to >> disable an honest dialogue. >> >> I have backed you into a corner on some of your lies. >> > > What lies? > > That seems to be one of your biggest lies, you claim others are lying to > try to disquise your own lies. > The most important one is that the correct simulation of DDD by Ho must ALWAYS have the same behavior as the directly executed DDD(). _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. > You can't show one thing that I have said that is FACTUALY INCORRCT > (only that you disagre with them). > It is a matter of you disagreeing with the semantics of the x86 language. This is analogous to disagreeing with arithmetic. You are already hedging your original claim because I have backed you into a corner. > I have shown statements of your that ARE DEFINITIONALLY INCORRECT (even > if you want to use a different definition, which just isn't allowed, and > thus becomes a lie). -- 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-27 19:57 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5ku94$1as00$4@i2pn2.org> |
| In reply to | #336076 |
On 6/27/24 9:21 AM, olcott wrote: > On 6/27/2024 6:34 AM, Richard Damon wrote: >> On 6/26/24 11:37 PM, olcott wrote: >>> On 6/26/2024 10:16 PM, Richard Damon wrote: >>>> On 6/26/24 10:46 PM, olcott wrote: >>>>> On 6/26/2024 9:38 PM, Richard Damon wrote: >>>>>> On 6/26/24 10:10 PM, olcott wrote: >>>>>>> On 6/26/2024 8:21 PM, Richard Damon wrote: >>>>>>>> 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. >>>>>>>> >>>>>>> >>>>>>> NONE-THE-LESS I WILL NOT TOLERATE YOU LEAPING TO THE CONCLUSION >>>>>>> THAT I AM INCORRECT WITHOUT GOING THROUGH EVER SINGLE STEP. >>>>>>> *When you do this I will point out your specific deceit* >>>>>> >>>>>> But if you don't include the restriction, it isn't there, and the >>>>>> fact we are so many steps ahead of you isn't grounds to say we >>>>>> don't know what we know. >>>>>> >>>>>>> >>>>>>>>> >>>>>>>>> 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. >>>>>>>> >>>>>>> >>>>>>> THAT IS THE FREAKING DAMNED LIAR STRAW-MAN DECEPTION. >>>>>> >>>>>> The "Behavior" of the input is DEFINED by the semantics of the x86 >>>>>> instruction set. >>>>>> >>>>>> NO instruction, other than Halt, stops the processor from >>>>>> continuing, thus the behavior of the input doesn't stop just >>>>>> because the emulator stoped processing it. >>>>>> >>>>>>> >>>>>>> When I say that there are some people that are so poor >>>>>>> that they are starving to death and we must halt them >>>>>>> >>>>>>> you cannot (morally) say there is no need to help them >>>>>>> because rich people are not starving to death. >>>>>> >>>>>> RED HERRING. >>>>>> >>>>>>> >>>>>>> Christ taught in parables I teach in isomorphisms. >>>>>>> >>>>>> >>>>>> But broken ones, that are just RED HERRING LIES. >>>>>> >>>>>> And, I know Christ, and you are NOT Christ, and it is almost >>>>>> blasphemous for you to make that comparasion, especially since you >>>>>> have claimed to be God in the past. >>>>>> >>>>>> THAT WILL send you to Gehenna. >>>>> >>>>> I am not the liar here. I think that we have gone >>>>> way beyond reasonable doubt that you have told lies. >>>> >>>> Really, so what statement have I said that isn't actually true. >>>> >>>> Not just that you disagree with it, since you have been proven to be >>>> a liar, but that you can actualy preove to be untrtue. >>>> >>>> Your ignorance does not make my statements lies. >>>> >>>>> >>>>> Maybe you are one of those "Christians" that believes >>>>> once saved always saved even if you commit genocide >>>>> for fun an profit. >>>>> >>>> >>>> Nope. You don't know me well, so you are just making your typical >>>> wild guesses with no basis. >>>> That is what gets you in trouble every time. >>>> >>> >>> As ALWAYS I hypothesize possibilities. >> >> No, you hypothesize thing that might be impossibe, which are just lies. >> > > This is merely your ignorance of how modal logic works. > Modal Logic operators defined > "◇" for "Possibly" and "□" for "Necessarily" > ◇P ↔ ¬□¬P > □P ↔¬◇¬P But you still can not say that something is "Possible" if it actually can not be. or □¬P ↔ ¬◇P > >>> Since you neither confirmed nor denied it remains open. >> >> It is unclear what "it" refers to, as usual for you. >> > > You neither affirmed nor denied whether you are > a once saved always saved Christian or not. > https://www.biblestudytools.com/bible-study/topical-studies/are-christians-really-once-saved-always-saved.html Right, because that isn't something I care to share about with you, since it is clear that you are not a true believer, and thus couldn't understand the discussion. > >> >> By normal grammer, it woudl be either that you hypothesize >> possibiliteis, and I have shown some of your claimed immpossiblities >> are just impossible, or the previous comment was that I might think >> that "committing genocide for fun and profit" is something a saved >> person might do. >> >>> >>> You know that you are doing the best that you can to >>> disable an honest dialogue. >>> >>> I have backed you into a corner on some of your lies. >>> >> >> What lies? >> >> That seems to be one of your biggest lies, you claim others are lying >> to try to disquise your own lies. >> > > The most important one is that the correct simulation > of DDD by Ho must ALWAYS have the same behavior as the > directly executed DDD(). Right, because that is the DEFINITION of "correct simulation" "Correct" is an absolute word, you are either correct or you are not. A Partial simulation is not a "Correct Simulation" in that it doesn't completely show the behavior of the thing simulated, but only a partial set of that behavior. Your attempt to define an admittedly partial simulation as being fully correct is just an error. IT is only a correct PARTIAL simulation, revealing only PART of the behavior of the input. > > _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. And H0 only completely correctly emulates its input if it never aborts, but that has been clearly NOT the H0 you are thinking of. Partial simulations do not (by themselves) reveal details about behavior past there termination, so you can not say "Never" since that word implies for all time. You can only says that H0 will never simulate the return. Note, the Partial Simulation of DDD by H0 is NOT a "property" of DDD, but of the pair of DDD and H0, so isn't valid to talk about it as a decision problem based on just the input. > >> You can't show one thing that I have said that is FACTUALY INCORRCT >> (only that you disagre with them). >> > > It is a matter of you disagreeing with the semantics of > the x86 language. This is analogous to disagreeing with > arithmetic. Nope, the x86 languge includes the semantics that the behavior of the program continues until the program itself terminates, and not just until it is terminated by some outside force. > > You are already hedging your original claim because I have > backed you into a corner. Nope. > >> I have shown statements of your that ARE DEFINITIONALLY INCORRECT >> (even if you want to use a different definition, which just isn't >> allowed, and thus becomes a lie). >
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-27 22:25 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5lafh$35a57$1@dont-email.me> |
| In reply to | #336073 |
On 6/27/2024 6:34 AM, Richard Damon wrote: > > That seems to be one of your biggest lies, you claim others are lying to > try to disquise your own lies. > > You can't show one thing that I have said that is FACTUALY INCORRCT > (only that you disagre with them). > > I have shown statements of your that ARE DEFINITIONALLY INCORRECT (even > if you want to use a different definition, which just isn't allowed, and > thus becomes a lie). _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-28 07:44 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5m7n3$1cftk$1@i2pn2.org> |
| In reply to | #336085 |
On 6/27/24 11:25 PM, olcott wrote: > On 6/27/2024 6:34 AM, Richard Damon wrote: >> >> That seems to be one of your biggest lies, you claim others are lying >> to try to disquise your own lies. >> >> You can't show one thing that I have said that is FACTUALY INCORRCT >> (only that you disagre with them). >> >> I have shown statements of your that ARE DEFINITIONALLY INCORRECT >> (even if you want to use a different definition, which just isn't >> allowed, and thus becomes a lie). > > _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. > > You are still using sloppy definition to spread your deceit. If by "Correctly Emulate" you means that H0 does a COMPLETE simulation, as the term Correctly Simulate would mean (and H0 is a pure funciton) then yes, then H0(DDD) will never return ANYWHERE. But, we know this isn't what you mean as you claim that H1(DDD) does return, and thus H0(DDD) must return and what you actually are trying to say, but being decietful about it is that H0 does a PARTIAL correct simulaition of its input, and that H0 will not reach the return in its simulation. Note, The Behavior of DDD, MUST be a property of just DDD, and not anything else, (when DDD is fully defined, which means the H0 it uses is defined, as it must be to talk about its behavior) so that must be using a NON-ABORTED version of the simulation with THIS H0 in it, and that WILL RETURN. Thus, you claim is only PARTIALLY correct, which means it is WRONG, and shows you are trying to be intentionally decietful (or are really pathologically ignorant of the topic). Emulation meens to do as something does, to copy the behavior. Adding Correct to make it Correct Emulation intensifies that to imply, especially in the field of programming (which you seem to be a novice in) implies that it is a COMPLETE emulation, exactly reproducing the results of the input. This is NOT what you seem to mean, and the adjictive you actually want is PARTIAL, allowing the emulator to decide to stop its emulation at some point, perhaps because it thinks it knows enough of the behavior. Fundamental in PARTIAL emulation, is you do not have a record of what WILL HAPPEN in the future for an actual COMPLETE and CORRECT emulation of that input (but you MAY be able to deduce it if you have seen a full cycle, which you haven't). Actual Behavior of "The Input" is by definition, only a function of that input and the rules of representation that defined it. IT CAN NOT be a function of who you ask, or your definition of behavior is just incorrect. Since how partial the partial simulation done by H0 is a function of that decider, it CAN NOT be considered the "Behavior" of the input. WIth your definition of the rule of representation being that the code is x86 assembly, the only definition of "Behavior" that applies is the complete emulation of it, and since H0 is claimed to return from H0(DDD), then the correct behavior of DDD is to return PERIOD. Note, you try to misuse the concept of "Stipulation". There are a couple of rules about it. One, you can not stipulate that something is "correct" or "true" without leaving the realm of logic, as that, with the system you are in, defines what IS Correct or True. You can stipulate that you will assume that something acts correctly, but then you need to be able (without using that stipulation or anything derived from it) that a thing like that does exist. This means you can not just stipulate that your decider just emulates until the input matches a non-halting pattern, and then assume that it will find one, you need to actually prove that such a pattern exists. Second, you can not stipulate a definition that is in conflict with the system you are claiming to be in. Thus, if you stipulate that the correct answer for a decider is ANYTHING that differs from the behavior of the directly executed machine represented by the input, your decider is NOT a Halt Decider. Thus, your use of stipulation is just showing that you really aren't working on the Halting Problem, because you just refuse to work within its confines. If you want to try to show there is something wrong about it, you need to do that with the actual definitions of the problem, and not some altered version of them (which means you actually need to learn to understand them).
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-28 07:28 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5ma9s$3b1p0$1@dont-email.me> |
| In reply to | #336088 |
On 6/28/2024 6:44 AM, Richard Damon wrote: > On 6/27/24 11:25 PM, olcott wrote: >> On 6/27/2024 6:34 AM, Richard Damon wrote: >>> >>> That seems to be one of your biggest lies, you claim others are lying >>> to try to disquise your own lies. >>> >>> You can't show one thing that I have said that is FACTUALY INCORRCT >>> (only that you disagre with them). >>> >>> I have shown statements of your that ARE DEFINITIONALLY INCORRECT >>> (even if you want to use a different definition, which just isn't >>> allowed, and thus becomes a lie). >> >> _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. >> >> > > You are still using sloppy definition to spread your deceit. > The call from DDD to H0(DDD) when N steps of DDD are correctly emulated by any pure function x86 emulator H0 cannot possibly return. The behavior of the directly executed DDD() is irrelevant because that is not the behavior of the input. Deciders compute the mapping from their actual finite string input to an output by a sequence of finite string transformations. In this case the sequence is the line-by-line execution trace of the behavior of DDD correctly emulated by H0. The behavior of this input must include and cannot ignore the recursive emulation specified by the fact that DDD is calling its own emulator. That people think they can just pretend that this is not happening is ridiculous. -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-28 09:33 -0500 |
| Subject | Re: Why Lie? -- Repeat until Closure |
| Message-ID | <v5mhjn$3cibm$1@dont-email.me> |
| In reply to | #336089 |
On 6/28/2024 7:58 AM, joes wrote: > Am Fri, 28 Jun 2024 07:28:44 -0500 schrieb olcott: > >> The call from DDD to H0(DDD) when N steps of DDD are correctly >> emulated by any pure function x86 emulator H0 cannot possibly >> return. > Yes… > Great. We now have HHH(DDD) and HHH1(DDD) as the standard names. >> The behavior of the directly executed DDD() is irrelevant >> because that is not the behavior of the input. Deciders >> compute the mapping from their actual finite string input >> to an output by a sequence of finite string transformations. > > DDD is literally the input. How can you say that is not the > behaviour? Deciders should compute the actual behaviour. > If that is not possible, we call that undecidable. > >> In this case the sequence is the line-by-line execution >> trace of the behavior of DDD correctly emulated by H0. > > The behaviour of DDD is not determined by the H0 simulating > it (although it of course depends on the return value of the > call to it). When DDD calls HHH(DDD) in recursive emulation it is ridiculously stupid to simply ignore that this is happening. -- 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-28 23:49 -0400 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure |
| Message-ID | <v5o087$1eli4$2@i2pn2.org> |
| In reply to | #336089 |
On 6/28/24 8:28 AM, olcott wrote: > On 6/28/2024 6:44 AM, Richard Damon wrote: >> On 6/27/24 11:25 PM, olcott wrote: >>> On 6/27/2024 6:34 AM, Richard Damon wrote: >>>> >>>> That seems to be one of your biggest lies, you claim others are >>>> lying to try to disquise your own lies. >>>> >>>> You can't show one thing that I have said that is FACTUALY INCORRCT >>>> (only that you disagre with them). >>>> >>>> I have shown statements of your that ARE DEFINITIONALLY INCORRECT >>>> (even if you want to use a different definition, which just isn't >>>> allowed, and thus becomes a lie). >>> >>> _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. >>> >>> >> >> You are still using sloppy definition to spread your deceit. >> > > The call from DDD to H0(DDD) when N steps of DDD are correctly > emulated by any pure function x86 emulator H0 cannot possibly > return. So? When Completely correctly emulated by an actual correct emulator it will because you have said that your H0 WILL abort it emulation and return, and thus not do an actually correct emulation by the x86 instruction semantics, since part of the semantics of every instruction is that the next instruction in sequence WILL be executed. > > The behavior of the directly executed DDD() is irrelevant > because that is not the behavior of the input. Deciders > compute the mapping from their actual finite string input > to an output by a sequence of finite string transformations. Of course it is. Why isn't it. Your N Step Emulation of the input (with N being determined by the decider) CAN'T be the "behavior" of the input, as it isn't determined by just the input itself. > > In this case the sequence is the line-by-line execution > trace of the behavior of DDD correctly emulated by H0. Which is INOCRRECT by being INCOMPLETE when the semantic that the input was defined to have requries completeness. > > The behavior of this input must include and cannot ignore > the recursive emulation specified by the fact that DDD is > calling its own emulator. That people think they can just > pretend that this is not happening is ridiculous. > Right, and as such, must go into H0, so that is part of the input, and thus can not be changed when talking about THE INPUT.; So, with THIS H0 as the input, the FULL behavior will be to reach the final state, unless you admit to lying that H1 did reach that same ending, and that H0(DDD) does return.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-23 23:09 -0400 |
| Message-ID | <v5ao21$smd4$9@i2pn2.org> |
| In reply to | #335917 |
On 6/23/24 10:38 PM, olcott wrote:
> On 6/23/2024 9:31 PM, Richard Damon wrote:
>> On 6/23/24 10:27 PM, olcott wrote:
>>> On 6/23/2024 9:16 PM, Richard Damon wrote:
>>>> On 6/23/24 10:09 PM, olcott wrote:
>>>>> On 6/23/2024 9:00 PM, Richard Damon wrote:
>>>>>> On 6/23/24 9:36 PM, olcott wrote:
>>>>>>> On 6/23/2024 8:30 PM, Richard Damon wrote:
>>>>>>>> On 6/23/24 9:20 PM, olcott wrote:
>>>>>>>>> On 6/23/2024 8:13 PM, Richard Damon wrote:
>>>>>>>>>> On 6/23/24 9:00 PM, olcott wrote:
>>>>>>>>>>> On 6/23/2024 7:24 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/23/24 8:08 PM, olcott wrote:
>>>>>>>>>>>>> On 6/23/2024 6:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/23/24 7:34 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/23/2024 5:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 6/23/24 6:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You know what the freak I was talking from prior
>>>>>>>>>>>>>>>>> discussions unless your brain is so damaged that
>>>>>>>>>>>>>>>>> you can't remember anything from one post to the next.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In the case that you affirm that your brain <is>
>>>>>>>>>>>>>>>>> this damaged then I humbly apologize.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, you don't know what you are talking about.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So you insist on lying about this verified fact?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> _DDD()
>>>>>>>>>>>>>>> [00002172] 55 push ebp
>>>>>>>>>>>>>>> [00002173] 8bec mov ebp,esp
>>>>>>>>>>>>>>> [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]
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> According to the semantics of the x86 programming language
>>>>>>>>>>>>>>> when DDD correctly emulated by H0 calls H0(DDD) this call
>>>>>>>>>>>>>>> cannot possibly return.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I won't say it can't be true, but it hasn't been proven,
>>>>>>>>>>>>>> largely because it seems you don't know how to do a formal
>>>>>>>>>>>>>> logic proof.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Liar
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Then where is the proof?
>>>>>>>>>>>>
>>>>>>>>>>>> And were is the simulation that H0 did?
>>>>>>>>>>>>
>>>>>>>>>>>> Failure to show where you ACTUALLY PROVED it just shows you
>>>>>>>>>>>> a liar.
>>>>>>>>>>>>
>>>>>>>>>>>> Remember the parts of a Formal Logic Proof:
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You could disagree that 2 + 3 = 5 on this same Jackass basis.
>>>>>>>>>>> 2 + 3 = 5 ON THE FREAKING BASIS OF THE SEMANTICS OF ARITHMETIC.
>>>>>>>>>>
>>>>>>>>>> But I seen proofs that 2 + 3 = 5
>>>>>>>>>>
>>>>>>>>>> And that is done on a proof that uses the semantics of aritmetic.
>>>>>>>>>>
>>>>>>>>>> The phrase "Semantics of Arithmetic" though, is not a proof.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> According to the semantics of the x86 programming language
>>>>>>>>>>> when DDD correctly emulated by H0 calls H0(DDD) this call
>>>>>>>>>>> cannot possibly return.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Then try to prove it.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I will not try any prove that 2 + 3 = 5, if you deny
>>>>>>>>> it then you are a liar.
>>>>>>>>
>>>>>>>> And you don't need to, as it has been done.
>>>>>>>>
>>>>>>>> Now, showing how 2 + 3 = 5 would help show you how to right an
>>>>>>>> actual proof.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Likewise for the behavior of DDD correctly simulated
>>>>>>>>> by H0. A correct x86 emulator already proved this three
>>>>>>>>> years ago and you still try and get away with lying about it.
>>>>>>>>
>>>>>>>> Nope. Just a fallacy of proof by example, which isn't a proof.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> We have gotten it down to this ONLY LIARS WILL DISAGREE
>>>>>>>>> THAT MY PROOF IS CORRECT.
>>>>>>>>
>>>>>>>> WHAT PROOF?
>>>>>>>>
>>>>>>>> No proof, just means your statement is just a LIE.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> DDD correctly emulated by H0 DOES NOT HALT.
>>>>>>>>
>>>>>>>> TYPE ERROR.
>>>>>>>>
>>>>>>>> Correct Simutation by H is not part of the definition of HALTING.
>>>>>>>>
>>>>>>>> Just proves your ignorance of what you talk about.
>>>>>>>>
>>>>>>>>
>>>>>>>>> Likewise for P correctly emulated by H.
>>>>>>>>
>>>>>>>> AGAIN TYPE ERROR.
>>>>>>>>
>>>>>>>> Correct Simutation by H is not part of the definition of HALTING.
>>>>>>>>
>>>>>>>> Just proves your ignorance of what you talk about.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> typedef int (*ptr2)();
>>>>>>>>> int H(ptr2 P, ptr2 I);
>>>>>>>>>
>>>>>>>>> int P(ptr2 x)
>>>>>>>>> {
>>>>>>>>> int Halt_Status = H(x, x);
>>>>>>>>> if (Halt_Status)
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> return Halt_Status;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> H(P,P);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> _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]
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> And, P(P) Halts since you have indicated that H(P,P) to returns 0.
>>>>>>>>
>>>>>>>> VERIFIED FACT.
>>>>>>>>
>>>>>>>
>>>>>>> A verified fact to a God damned liar.
>>>>>>
>>>>>> Nope, actual verified fact, one YOU have even proven and agreed to.
>>>>>>
>>>>>> SO, I guess you are just showing you are just a LIAR.
>>>>>>
>>>>>>
>>>>>>>
>>>>>>> The actual verified fact is that when P is correctly emulated
>>>>>>> by H according to the semantics of the x86 language that the
>>>>>>> call from P to H(P,P) CANNOT POSSIBLY RETURN.
>>>>>>>
>>>>>>
>>>>>> But that isn't halting, so saying it shows non-halting is just a
>>>>>> LIE, and proves your ignorance of the topic.
>>>>>
>>>>> So you agree that the call cannot possibly return
>>>>> or are you going to keep lying about that?
>>>>>
>>>>
>>>> No, I am saying the call WILL return in the direct execution, which
>>>> is what matters.
>>>>
>>>
>>> So finally after three years you quit lying about the
>>> behavior of P correctly simulated by H.
>>>
>>> It should not have taken that long to get you to quit
>>> being dishonest.
>>>
>>>
>>
>> When did I ever say anything like that about the correct simulation by H.
>>
>
> Many many times, dozens to hundreds of times.
> The call from P to H(P,P) cannot possibly return from P
> correctly simulated by H.
>
SHOW ONE WHERE I SAID IT DID, for the simulation by *H*
> We can stay on this single point for the next 10,000
> messages if you really want to look foolish that long.
>
So SHOW YOUR EVIDENCE.
You are just stuck in your lies.
[toc] | [prev] | [next] | [standalone]
| From | joes <noreply@example.com> |
|---|---|
| Date | 2024-06-25 09:14 +0000 |
| Message-ID | <v5e1qd$11urb$3@i2pn2.org> |
| In reply to | #335908 |
Am Sun, 23 Jun 2024 20:36:39 -0500 schrieb olcott: > On 6/23/2024 8:30 PM, Richard Damon wrote: >> On 6/23/24 9:20 PM, olcott wrote: >>> On 6/23/2024 8:13 PM, Richard Damon wrote: >>>> On 6/23/24 9:00 PM, olcott wrote: >>>>> On 6/23/2024 7:24 PM, Richard Damon wrote: >>>>>> On 6/23/24 8:08 PM, olcott wrote: >>>>>>> On 6/23/2024 6:44 PM, Richard Damon wrote: >>>>>>>> On 6/23/24 7:34 PM, olcott wrote: >>>>>>>>> On 6/23/2024 5:58 PM, Richard Damon wrote: >>>>>>>>>> On 6/23/24 6:45 PM, olcott wrote: >>> I will not try any prove that 2 + 3 = 5, if you deny it then you are a >>> liar. >> And you don't need to, as it has been done. >> Now, showing how 2 + 3 = 5 would help show you how to write an actual >> proof. >> And, P(P) Halts since you have indicated that H(P,P) to returns 0. So it doesn't need to be aborted. > The actual verified fact is that when P is correctly emulated by H > according to the semantics of the x86 language that the call from P to > H(P,P) CANNOT POSSIBLY RETURN. So H is not a decider anymore? -- Man kann mit dunklen Zahlen nicht rechnen. Für die eigentliche Mathematik sind sie vollkommen nutzlos. --Wolfgang Mückenheim
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-23 20:33 -0500 |
| Message-ID | <v5aid9$nd1b$1@dont-email.me> |
| In reply to | #335905 |
On 6/23/2024 8:20 PM, olcott wrote:
> On 6/23/2024 8:13 PM, Richard Damon wrote:
>> On 6/23/24 9:00 PM, olcott wrote:
>>> On 6/23/2024 7:24 PM, Richard Damon wrote:
>>>> On 6/23/24 8:08 PM, olcott wrote:
>>>>> On 6/23/2024 6:44 PM, Richard Damon wrote:
>>>>>> On 6/23/24 7:34 PM, olcott wrote:
>>>>>>> On 6/23/2024 5:58 PM, Richard Damon wrote:
>>>>>>>> On 6/23/24 6:45 PM, olcott wrote:
>>>>>>>>>
>>>>>>>>> You know what the freak I was talking from prior
>>>>>>>>> discussions unless your brain is so damaged that
>>>>>>>>> you can't remember anything from one post to the next.
>>>>>>>>>
>>>>>>>>> In the case that you affirm that your brain <is>
>>>>>>>>> this damaged then I humbly apologize.
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> No, you don't know what you are talking about.
>>>>>>>>
>>>>>>> So you insist on lying about this verified fact?
>>>>>>>
>>>>>>> _DDD()
>>>>>>> [00002172] 55 push ebp
>>>>>>> [00002173] 8bec mov ebp,esp
>>>>>>> [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]
>>>>>>>
>>>>>>> According to the semantics of the x86 programming language
>>>>>>> when DDD correctly emulated by H0 calls H0(DDD) this call
>>>>>>> cannot possibly return.
>>>>>>>
>>>>>>
>>>>>> I won't say it can't be true, but it hasn't been proven, largely
>>>>>> because it seems you don't know how to do a formal logic proof.
>>>>>>
>>>>>
>>>>> Liar
>>>>>
>>>>
>>>> Then where is the proof?
>>>>
>>>> And were is the simulation that H0 did?
>>>>
>>>> Failure to show where you ACTUALLY PROVED it just shows you a liar.
>>>>
>>>> Remember the parts of a Formal Logic Proof:
>>>>
>>>
>>> You could disagree that 2 + 3 = 5 on this same Jackass basis.
>>> 2 + 3 = 5 ON THE FREAKING BASIS OF THE SEMANTICS OF ARITHMETIC.
>>
>> But I seen proofs that 2 + 3 = 5
>>
>> And that is done on a proof that uses the semantics of aritmetic.
>>
>> The phrase "Semantics of Arithmetic" though, is not a proof.
>>
>>>
>>> According to the semantics of the x86 programming language
>>> when DDD correctly emulated by H0 calls H0(DDD) this call
>>> cannot possibly return.
>>>
>>
>> Then try to prove it.
>>
>
> I will not try any prove that 2 + 3 = 5, if you deny
> it then you are a liar.
>
> Likewise for the behavior of DDD correctly simulated
> by H0. A correct x86 emulator already proved this three
> years ago and you still try and get away with lying about it.
>
> We have gotten it down to this ONLY LIARS WILL DISAGREE
> THAT MY PROOF IS CORRECT.
>
> DDD correctly emulated by H0 DOES NOT HALT.
> Likewise for P correctly emulated by H.
>
> typedef int (*ptr2)();
> int H(ptr2 P, ptr2 I);
>
> int P(ptr2 x)
> {
> int Halt_Status = H(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return Halt_Status;
> }
>
> int main()
> {
> H(P,P);
> }
>
> _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]
>
>
>
It took me a couple of years to realize the key difference
between P(P) and P correctly simulated by H is that in the
latter case the call to H(P,P) 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-23 22:03 -0400 |
| Message-ID | <v5ak5n$smd4$7@i2pn2.org> |
| In reply to | #335907 |
On 6/23/24 9:33 PM, olcott wrote:
> On 6/23/2024 8:20 PM, olcott wrote:
>> On 6/23/2024 8:13 PM, Richard Damon wrote:
>>> On 6/23/24 9:00 PM, olcott wrote:
>>>> On 6/23/2024 7:24 PM, Richard Damon wrote:
>>>>> On 6/23/24 8:08 PM, olcott wrote:
>>>>>> On 6/23/2024 6:44 PM, Richard Damon wrote:
>>>>>>> On 6/23/24 7:34 PM, olcott wrote:
>>>>>>>> On 6/23/2024 5:58 PM, Richard Damon wrote:
>>>>>>>>> On 6/23/24 6:45 PM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>> You know what the freak I was talking from prior
>>>>>>>>>> discussions unless your brain is so damaged that
>>>>>>>>>> you can't remember anything from one post to the next.
>>>>>>>>>>
>>>>>>>>>> In the case that you affirm that your brain <is>
>>>>>>>>>> this damaged then I humbly apologize.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, you don't know what you are talking about.
>>>>>>>>>
>>>>>>>> So you insist on lying about this verified fact?
>>>>>>>>
>>>>>>>> _DDD()
>>>>>>>> [00002172] 55 push ebp
>>>>>>>> [00002173] 8bec mov ebp,esp
>>>>>>>> [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]
>>>>>>>>
>>>>>>>> According to the semantics of the x86 programming language
>>>>>>>> when DDD correctly emulated by H0 calls H0(DDD) this call
>>>>>>>> cannot possibly return.
>>>>>>>>
>>>>>>>
>>>>>>> I won't say it can't be true, but it hasn't been proven, largely
>>>>>>> because it seems you don't know how to do a formal logic proof.
>>>>>>>
>>>>>>
>>>>>> Liar
>>>>>>
>>>>>
>>>>> Then where is the proof?
>>>>>
>>>>> And were is the simulation that H0 did?
>>>>>
>>>>> Failure to show where you ACTUALLY PROVED it just shows you a liar.
>>>>>
>>>>> Remember the parts of a Formal Logic Proof:
>>>>>
>>>>
>>>> You could disagree that 2 + 3 = 5 on this same Jackass basis.
>>>> 2 + 3 = 5 ON THE FREAKING BASIS OF THE SEMANTICS OF ARITHMETIC.
>>>
>>> But I seen proofs that 2 + 3 = 5
>>>
>>> And that is done on a proof that uses the semantics of aritmetic.
>>>
>>> The phrase "Semantics of Arithmetic" though, is not a proof.
>>>
>>>>
>>>> According to the semantics of the x86 programming language
>>>> when DDD correctly emulated by H0 calls H0(DDD) this call
>>>> cannot possibly return.
>>>>
>>>
>>> Then try to prove it.
>>>
>>
>> I will not try any prove that 2 + 3 = 5, if you deny
>> it then you are a liar.
>>
>> Likewise for the behavior of DDD correctly simulated
>> by H0. A correct x86 emulator already proved this three
>> years ago and you still try and get away with lying about it.
>>
>> We have gotten it down to this ONLY LIARS WILL DISAGREE
>> THAT MY PROOF IS CORRECT.
>>
>> DDD correctly emulated by H0 DOES NOT HALT.
>> Likewise for P correctly emulated by H.
>>
>> typedef int (*ptr2)();
>> int H(ptr2 P, ptr2 I);
>>
>> int P(ptr2 x)
>> {
>> int Halt_Status = H(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return Halt_Status;
>> }
>>
>> int main()
>> {
>> H(P,P);
>> }
>>
>> _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]
>>
>>
>>
>
> It took me a couple of years to realize the key difference
> between P(P) and P correctly simulated by H is that in the
> latter case the call to H(P,P) cannot possibly return.
>
And no one disagrees that they are different. And that is your problem,
Halting is DEFINED as the first, not the second, so you just lie when
you say the second tells us about halting. It can prove Halting
(sometimes) if H reaches the final state. It does not tell about
non-halting by itself (but can sometimes provide data for an induction
in the cases where the direct execution doesn't halt).
The key word is SOMETIMES.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-23 21:13 -0500 |
| Message-ID | <v5akni$nr6u$2@dont-email.me> |
| In reply to | #335910 |
On 6/23/2024 9:03 PM, Richard Damon wrote:
> On 6/23/24 9:33 PM, olcott wrote:
>> On 6/23/2024 8:20 PM, olcott wrote:
>>> On 6/23/2024 8:13 PM, Richard Damon wrote:
>>>> On 6/23/24 9:00 PM, olcott wrote:
>>>>> On 6/23/2024 7:24 PM, Richard Damon wrote:
>>>>>> On 6/23/24 8:08 PM, olcott wrote:
>>>>>>> On 6/23/2024 6:44 PM, Richard Damon wrote:
>>>>>>>> On 6/23/24 7:34 PM, olcott wrote:
>>>>>>>>> On 6/23/2024 5:58 PM, Richard Damon wrote:
>>>>>>>>>> On 6/23/24 6:45 PM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>> You know what the freak I was talking from prior
>>>>>>>>>>> discussions unless your brain is so damaged that
>>>>>>>>>>> you can't remember anything from one post to the next.
>>>>>>>>>>>
>>>>>>>>>>> In the case that you affirm that your brain <is>
>>>>>>>>>>> this damaged then I humbly apologize.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, you don't know what you are talking about.
>>>>>>>>>>
>>>>>>>>> So you insist on lying about this verified fact?
>>>>>>>>>
>>>>>>>>> _DDD()
>>>>>>>>> [00002172] 55 push ebp
>>>>>>>>> [00002173] 8bec mov ebp,esp
>>>>>>>>> [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]
>>>>>>>>>
>>>>>>>>> According to the semantics of the x86 programming language
>>>>>>>>> when DDD correctly emulated by H0 calls H0(DDD) this call
>>>>>>>>> cannot possibly return.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I won't say it can't be true, but it hasn't been proven, largely
>>>>>>>> because it seems you don't know how to do a formal logic proof.
>>>>>>>>
>>>>>>>
>>>>>>> Liar
>>>>>>>
>>>>>>
>>>>>> Then where is the proof?
>>>>>>
>>>>>> And were is the simulation that H0 did?
>>>>>>
>>>>>> Failure to show where you ACTUALLY PROVED it just shows you a liar.
>>>>>>
>>>>>> Remember the parts of a Formal Logic Proof:
>>>>>>
>>>>>
>>>>> You could disagree that 2 + 3 = 5 on this same Jackass basis.
>>>>> 2 + 3 = 5 ON THE FREAKING BASIS OF THE SEMANTICS OF ARITHMETIC.
>>>>
>>>> But I seen proofs that 2 + 3 = 5
>>>>
>>>> And that is done on a proof that uses the semantics of aritmetic.
>>>>
>>>> The phrase "Semantics of Arithmetic" though, is not a proof.
>>>>
>>>>>
>>>>> According to the semantics of the x86 programming language
>>>>> when DDD correctly emulated by H0 calls H0(DDD) this call
>>>>> cannot possibly return.
>>>>>
>>>>
>>>> Then try to prove it.
>>>>
>>>
>>> I will not try any prove that 2 + 3 = 5, if you deny
>>> it then you are a liar.
>>>
>>> Likewise for the behavior of DDD correctly simulated
>>> by H0. A correct x86 emulator already proved this three
>>> years ago and you still try and get away with lying about it.
>>>
>>> We have gotten it down to this ONLY LIARS WILL DISAGREE
>>> THAT MY PROOF IS CORRECT.
>>>
>>> DDD correctly emulated by H0 DOES NOT HALT.
>>> Likewise for P correctly emulated by H.
>>>
>>> typedef int (*ptr2)();
>>> int H(ptr2 P, ptr2 I);
>>>
>>> int P(ptr2 x)
>>> {
>>> int Halt_Status = H(x, x);
>>> if (Halt_Status)
>>> HERE: goto HERE;
>>> return Halt_Status;
>>> }
>>>
>>> int main()
>>> {
>>> H(P,P);
>>> }
>>>
>>> _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]
>>>
>>>
>>>
>>
>> It took me a couple of years to realize the key difference
>> between P(P) and P correctly simulated by H is that in the
>> latter case the call to H(P,P) cannot possibly return.
>>
> And no one disagrees that they are different.
You are lying about that.
everyone has consistently disagreed
that they can possibly be different.
You tried to get away with claiming that D correctly
simulated by H must return to its caller.
Now that I boxed you into a corner you are trying
to get away with saying that you never said that.
--
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-23 22:28 -0400 |
| Message-ID | <v5aljm$smd5$9@i2pn2.org> |
| In reply to | #335912 |
On 6/23/24 10:13 PM, olcott wrote:
> On 6/23/2024 9:03 PM, Richard Damon wrote:
>> On 6/23/24 9:33 PM, olcott wrote:
>>> On 6/23/2024 8:20 PM, olcott wrote:
>>>> On 6/23/2024 8:13 PM, Richard Damon wrote:
>>>>> On 6/23/24 9:00 PM, olcott wrote:
>>>>>> On 6/23/2024 7:24 PM, Richard Damon wrote:
>>>>>>> On 6/23/24 8:08 PM, olcott wrote:
>>>>>>>> On 6/23/2024 6:44 PM, Richard Damon wrote:
>>>>>>>>> On 6/23/24 7:34 PM, olcott wrote:
>>>>>>>>>> On 6/23/2024 5:58 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/23/24 6:45 PM, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> You know what the freak I was talking from prior
>>>>>>>>>>>> discussions unless your brain is so damaged that
>>>>>>>>>>>> you can't remember anything from one post to the next.
>>>>>>>>>>>>
>>>>>>>>>>>> In the case that you affirm that your brain <is>
>>>>>>>>>>>> this damaged then I humbly apologize.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, you don't know what you are talking about.
>>>>>>>>>>>
>>>>>>>>>> So you insist on lying about this verified fact?
>>>>>>>>>>
>>>>>>>>>> _DDD()
>>>>>>>>>> [00002172] 55 push ebp
>>>>>>>>>> [00002173] 8bec mov ebp,esp
>>>>>>>>>> [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]
>>>>>>>>>>
>>>>>>>>>> According to the semantics of the x86 programming language
>>>>>>>>>> when DDD correctly emulated by H0 calls H0(DDD) this call
>>>>>>>>>> cannot possibly return.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I won't say it can't be true, but it hasn't been proven,
>>>>>>>>> largely because it seems you don't know how to do a formal
>>>>>>>>> logic proof.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Liar
>>>>>>>>
>>>>>>>
>>>>>>> Then where is the proof?
>>>>>>>
>>>>>>> And were is the simulation that H0 did?
>>>>>>>
>>>>>>> Failure to show where you ACTUALLY PROVED it just shows you a liar.
>>>>>>>
>>>>>>> Remember the parts of a Formal Logic Proof:
>>>>>>>
>>>>>>
>>>>>> You could disagree that 2 + 3 = 5 on this same Jackass basis.
>>>>>> 2 + 3 = 5 ON THE FREAKING BASIS OF THE SEMANTICS OF ARITHMETIC.
>>>>>
>>>>> But I seen proofs that 2 + 3 = 5
>>>>>
>>>>> And that is done on a proof that uses the semantics of aritmetic.
>>>>>
>>>>> The phrase "Semantics of Arithmetic" though, is not a proof.
>>>>>
>>>>>>
>>>>>> According to the semantics of the x86 programming language
>>>>>> when DDD correctly emulated by H0 calls H0(DDD) this call
>>>>>> cannot possibly return.
>>>>>>
>>>>>
>>>>> Then try to prove it.
>>>>>
>>>>
>>>> I will not try any prove that 2 + 3 = 5, if you deny
>>>> it then you are a liar.
>>>>
>>>> Likewise for the behavior of DDD correctly simulated
>>>> by H0. A correct x86 emulator already proved this three
>>>> years ago and you still try and get away with lying about it.
>>>>
>>>> We have gotten it down to this ONLY LIARS WILL DISAGREE
>>>> THAT MY PROOF IS CORRECT.
>>>>
>>>> DDD correctly emulated by H0 DOES NOT HALT.
>>>> Likewise for P correctly emulated by H.
>>>>
>>>> typedef int (*ptr2)();
>>>> int H(ptr2 P, ptr2 I);
>>>>
>>>> int P(ptr2 x)
>>>> {
>>>> int Halt_Status = H(x, x);
>>>> if (Halt_Status)
>>>> HERE: goto HERE;
>>>> return Halt_Status;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> H(P,P);
>>>> }
>>>>
>>>> _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]
>>>>
>>>>
>>>>
>>>
>>> It took me a couple of years to realize the key difference
>>> between P(P) and P correctly simulated by H is that in the
>>> latter case the call to H(P,P) cannot possibly return.
>>>
>> And no one disagrees that they are different.
>
> You are lying about that.
> everyone has consistently disagreed
> that they can possibly be different.
The STEPS that H simulates in H correctly (partially) simulating its
input must exactly match the corresponding steps of the machine
represented by the input directly executed. (and to do either, you need
to fix your input to include all the instructions of the decider that
the input uses).
What is different is the conclusion, but you run into the issue that we
need different inputs for the two problems. The "Direct Execution"
problem, needs the input to be an actual specific machine, that could be
a template instantiated on a given decider.
Your "Correctly Simulated by H" falls apart on that case, as if H is a
fixed decider, if it aborted before it reached the end, of course it
didn't simulate to the end, (but the same input, that has been
instantiated to that H, when given to an actual complete simulator, will
see it halts). Your "Correctly Simulated by H" problem only makes sense
for tempalte inputs, which are impropper for the direct execution case.
So, they end up being totally different problems as their input spaces
are just diffferent.
>
> You tried to get away with claiming that D correctly
> simulated by H must return to its caller.
WHEN?
I think you need to check your medications, as you are hallucinating.
Please show where I said that.
Not that the dirrect execution gets there, as it must if H returns 0,
but the emulated by the decider got there.
>
> Now that I boxed you into a corner you are trying
> to get away with saying that you never said that.
>
So, When did I say that D correctly simulated by H must return to the
caller?
You are just making things up because you are just a pathological liar.
I will note, you have an abismal record of showing proof of your claims,
even when you claim someone has said something.
[toc] | [prev] | [next] | [standalone]
| From | joes <noreply@example.com> |
|---|---|
| Date | 2024-06-24 19:44 +0000 |
| Message-ID | <v5cia2$10816$2@i2pn2.org> |
| In reply to | #335912 |
Am Sun, 23 Jun 2024 21:13:04 -0500 schrieb olcott: > On 6/23/2024 9:03 PM, Richard Damon wrote: >> On 6/23/24 9:33 PM, olcott wrote: >>> On 6/23/2024 8:20 PM, olcott wrote: >>>> On 6/23/2024 8:13 PM, Richard Damon wrote: >>>>> On 6/23/24 9:00 PM, olcott wrote: >>>>>> On 6/23/2024 7:24 PM, Richard Damon wrote: >>>>>>> On 6/23/24 8:08 PM, olcott wrote: >>>>>>>> On 6/23/2024 6:44 PM, Richard Damon wrote: >>>>>>>>> On 6/23/24 7:34 PM, olcott wrote: >>>>>>>>>> On 6/23/2024 5:58 PM, Richard Damon wrote: >>>>>>>>>>> On 6/23/24 6:45 PM, olcott wrote: >>>>>>> Then where is the proof? ... >>> It took me a couple of years to realize the key difference between >>> P(P) and P correctly simulated by H is that in the latter case the >>> call to H(P,P) cannot possibly return. >>> >> And no one disagrees that they are different. > > You are lying about that. > everyone has consistently disagreed that they can possibly be different. You misunderstood. Your H is different from the direct behaviour. It should not be. -- Man kann mit dunklen Zahlen nicht rechnen. Für die eigentliche Mathematik sind sie vollkommen nutzlos. --Wolfgang Mückenheim
[toc] | [prev] | [next] | [standalone]
Page 5 of 6 — ← Prev page 1 2 3 4 [5] 6 Next page →
Back to top | Article view | sci.logic
csiph-web