Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #107679 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2024-06-23 08:40 -0500 |
| Last post | 2024-06-26 19:47 -0400 |
| Articles | 20 on this page of 106 — 3 participants |
Back to article view | Back to comp.theory
DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 08:40 -0500
Re: DDD correctly emulated by H0 --- Why Lie? (typo corrected) olcott <polcott333@gmail.com> - 2024-06-23 09:00 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 14:20 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 16:41 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 17:49 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 17:04 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 18:35 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 17:45 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 18:58 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 18:34 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 19:44 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 19:08 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 20:24 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 20:00 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 21:13 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 20:20 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 21:30 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 20:36 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 22:00 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 21:09 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 22:16 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 21:27 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 22:31 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 21:38 -0500
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 21:52 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 23:11 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 22:26 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-24 07:02 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-24 08:39 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-24 19:17 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-24 18:38 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-24 19:57 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-24 08:42 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-24 19:19 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-24 18:43 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-24 19:59 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 19:02 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 20:06 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 19:34 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 20:54 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 20:05 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 21:13 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 20:22 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 21:24 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure (typo) olcott <polcott333@gmail.com> - 2024-06-24 20:07 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure (typo) Richard Damon <richard@damon-family.org> - 2024-06-24 21:22 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 20:32 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 21:51 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 20:55 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 22:02 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 21:17 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 22:25 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 21:21 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 22:26 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 21:38 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-24 22:48 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 21:52 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-25 06:59 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-24 22:13 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-25 07:04 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-25 08:02 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-25 21:47 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-25 20:59 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-25 22:17 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-25 21:21 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-25 22:54 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-25 22:25 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-25 23:32 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-25 22:37 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 06:58 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 08:33 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 19:41 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 18:50 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 19:52 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 19:19 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 20:38 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 19:24 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 20:40 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 20:12 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 21:21 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 21:10 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 22:38 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 21:46 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-26 23:16 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-26 22:37 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-27 07:34 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-27 08:21 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-27 19:57 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-27 22:25 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-28 07:44 -0400
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-28 07:28 -0500
Re: Why Lie? -- Repeat until Closure joes <noreply@example.com> - 2024-06-28 12:58 +0000
Re: Why Lie? -- Repeat until Closure olcott <polcott333@gmail.com> - 2024-06-28 09:33 -0500
Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure Richard Damon <richard@damon-family.org> - 2024-06-28 23:49 -0400
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 23:09 -0400
Re: DDD correctly emulated by H0 --- Why Lie? joes <noreply@example.com> - 2024-06-25 09:14 +0000
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 20:33 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 22:03 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-23 21:13 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-23 22:28 -0400
Re: DDD correctly emulated by H0 --- Why Lie? joes <noreply@example.com> - 2024-06-24 19:44 +0000
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-24 15:05 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-24 19:19 -0400
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-26 07:02 -0400
Re: DDD correctly emulated by H0 --- Why Lie? olcott <polcott333@gmail.com> - 2024-06-26 08:48 -0500
Re: DDD correctly emulated by H0 --- Why Lie? Richard Damon <richard@damon-family.org> - 2024-06-26 19:47 -0400
Page 1 of 6 [1] 2 3 4 5 6 Next page →
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-23 08:40 -0500 |
| Subject | DDD correctly emulated by H0 --- Why Lie? |
| Message-ID | <v598l4$c4if$1@dont-email.me> |
_DDD() [00002172] 55 push ebp [00002173] 8bec mov ebp,esp [00002175] 6872210000 push 00002172 ; push DDD [0000217a] e853f4ffff call 000015d2 ; call HHH0 [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. Likewise according to the semantics of arithmetic for decimal integers: 2 + 3 = 5. Anyone disagreeing with these two statements is WRONG. -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-23 09:00 -0500 |
| Subject | Re: DDD correctly emulated by H0 --- Why Lie? (typo corrected) |
| Message-ID | <v599pl$cc0e$1@dont-email.me> |
| In reply to | #107679 |
On 6/23/2024 8:40 AM, olcott wrote: > _DDD() > [00002172] 55 push ebp > [00002173] 8bec mov ebp,esp > [00002175] 6872210000 push 00002172 ; push DDD > [0000217a] e853f4ffff call 000015d2 ; call H0 > [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. > > Likewise according to the semantics of arithmetic for > decimal integers: 2 + 3 = 5. > > Anyone disagreeing with these two statements is WRONG. > -- 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 14:20 -0400 |
| Message-ID | <v59p13$smd5$1@i2pn2.org> |
| In reply to | #107679 |
On 6/23/24 9:40 AM, olcott wrote: > _DDD() > [00002172] 55 push ebp > [00002173] 8bec mov ebp,esp > [00002175] 6872210000 push 00002172 ; push DDD > [0000217a] e853f4ffff call 000015d2 ; call HHH0 > [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. > > Likewise according to the semantics of arithmetic for > decimal integers: 2 + 3 = 5. > > Anyone disagreeing with these two statements is WRONG. > NOw, if you REALLY mean just can H0 simulate this input to a final state, the answer is WHO CARES. But I will put out a few comments on errors in your presentation\. First, if you ONLY have the bytes presented, then the answer becomes trivial, as H0 HAS to stop emulating when it gets to the call instruction, as there is no data at address 000015d2 defined to simulate. This means you need to fix your problem statement to include the instructions of HHH0, and everything that it calls as part of the "input", or your question isn't the one you mean to be asking. Of course, this means that each HHH0 that you try, is processing a DIFFERENT input, so you can't argue from one about the behavior of a different one. Second, you forgot to specify what HHH0 has as requirements. Once you include its code, so can simulate it, the "non-pure" function tricks allow it to correctly simulate to the return instruction. Reminder, you complain when we point out assumptions made on previous statements that you didn't want to carry forward, so you can't also complain about us forgetting about requirements that you didn't bring forward. If you want to pull in the past, we can just point out that we KNOW you are talking about a Halt Decider, and that your question is the wrong question for a Halt decider. So, your statement is wrong for two logical reasons as described above, so your statement that anyone who disagrees is wrong is just wrong. You don't know how to properly state a problem. The last point to make, is that this is NOT a "proof" but just an argument claiming something should be obviously true. That may be a "proof" in the wild west of Philosophy, but it isn't in the realm of Formal Logic, which is what the field you are talking about is. So, you are making a statement, that when fixed to correct the deficits in it, becomes a statement that might be plausably true, but not proven. A proof can likely be made, but it seems that is beyond your ability since you didn't even try, Of course, without the second fix, the statement is just false, and without the first fix, the statment is meaningless, as of course you can't simulate to a return from a call that you are unable to simulate past.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-23 16:41 -0500 |
| Message-ID | <v5a4qc$h08n$1@dont-email.me> |
| In reply to | #107681 |
On 6/23/2024 1:20 PM, Richard Damon wrote: > On 6/23/24 9:40 AM, olcott wrote: >> _DDD() >> [00002172] 55 push ebp >> [00002173] 8bec mov ebp,esp >> [00002175] 6872210000 push 00002172 ; push DDD >> [0000217a] e853f4ffff call 000015d2 ; call HHH0 >> [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. >> >> Likewise according to the semantics of arithmetic for >> decimal integers: 2 + 3 = 5. >> >> Anyone disagreeing with these two statements is WRONG. >> > > NOw, if you REALLY mean just can H0 simulate this input to a final > state, the answer is WHO CARES. > > But I will put out a few comments on errors in your presentation\. > > First, if you ONLY have the bytes presented, then the answer becomes > trivial, as H0 HAS to stop emulating when it gets to the call > instruction, as there is no data at address 000015d2 defined to simulate. > What a God damned liar. https://liarparadox.org/HH0_(DDD)_Full_Trace.pdf -- 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 17:49 -0400 |
| Message-ID | <v5a5a1$smd5$6@i2pn2.org> |
| In reply to | #107685 |
On 6/23/24 5:41 PM, olcott wrote: > On 6/23/2024 1:20 PM, Richard Damon wrote: >> On 6/23/24 9:40 AM, olcott wrote: >>> _DDD() >>> [00002172] 55 push ebp >>> [00002173] 8bec mov ebp,esp >>> [00002175] 6872210000 push 00002172 ; push DDD >>> [0000217a] e853f4ffff call 000015d2 ; call HHH0 >>> [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. >>> >>> Likewise according to the semantics of arithmetic for >>> decimal integers: 2 + 3 = 5. >>> >>> Anyone disagreeing with these two statements is WRONG. >>> >> >> NOw, if you REALLY mean just can H0 simulate this input to a final >> state, the answer is WHO CARES. >> >> But I will put out a few comments on errors in your presentation\. >> >> First, if you ONLY have the bytes presented, then the answer becomes >> trivial, as H0 HAS to stop emulating when it gets to the call >> instruction, as there is no data at address 000015d2 defined to simulate. >> > > What a God damned liar. > https://liarparadox.org/HH0_(DDD)_Full_Trace.pdf > Which begins its trace at main, not DDD: From Source Listing: _main() [000020b3] 55 push ebp From the beginnig of the trace: machine stack stack machine assembly address address data code language ======== ======== ======== ========= ============= [000020b3][00103680][00000000] 55 push ebp So it isn't the trace of HHH0 correctly simulating DDD So, who is the God Damned Liar? I told you this last time you posted it. I guess reading what you are talking about is too hard for you. LIAR.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-23 17:04 -0500 |
| Message-ID | <v5a657$hgsg$1@dont-email.me> |
| In reply to | #107686 |
On 6/23/2024 4:49 PM, Richard Damon wrote: > On 6/23/24 5:41 PM, olcott wrote: >> On 6/23/2024 1:20 PM, Richard Damon wrote: >>> On 6/23/24 9:40 AM, olcott wrote: >>>> _DDD() >>>> [00002172] 55 push ebp >>>> [00002173] 8bec mov ebp,esp >>>> [00002175] 6872210000 push 00002172 ; push DDD >>>> [0000217a] e853f4ffff call 000015d2 ; call HHH0 >>>> [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. >>>> >>>> Likewise according to the semantics of arithmetic for >>>> decimal integers: 2 + 3 = 5. >>>> >>>> Anyone disagreeing with these two statements is WRONG. >>>> >>> >>> NOw, if you REALLY mean just can H0 simulate this input to a final >>> state, the answer is WHO CARES. >>> >>> But I will put out a few comments on errors in your presentation\. >>> >>> First, if you ONLY have the bytes presented, then the answer becomes >>> trivial, as H0 HAS to stop emulating when it gets to the call >>> instruction, as there is no data at address 000015d2 defined to >>> simulate. >>> >> >> What a God damned liar. >> https://liarparadox.org/HH0_(DDD)_Full_Trace.pdf >> > > Which begins its trace at main, not DDD: > You knew that there IS an HH0 and lied about it. That makes you a God damned liar. Of course C programs begin at main() Liar !!! -- 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 18:35 -0400 |
| Message-ID | <v5a7vs$smd4$2@i2pn2.org> |
| In reply to | #107687 |
On 6/23/24 6:04 PM, olcott wrote: > On 6/23/2024 4:49 PM, Richard Damon wrote: >> On 6/23/24 5:41 PM, olcott wrote: >>> On 6/23/2024 1:20 PM, Richard Damon wrote: >>>> On 6/23/24 9:40 AM, olcott wrote: >>>>> _DDD() >>>>> [00002172] 55 push ebp >>>>> [00002173] 8bec mov ebp,esp >>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH0 >>>>> [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. >>>>> >>>>> Likewise according to the semantics of arithmetic for >>>>> decimal integers: 2 + 3 = 5. >>>>> >>>>> Anyone disagreeing with these two statements is WRONG. >>>>> >>>> >>>> NOw, if you REALLY mean just can H0 simulate this input to a final >>>> state, the answer is WHO CARES. >>>> >>>> But I will put out a few comments on errors in your presentation\. >>>> >>>> First, if you ONLY have the bytes presented, then the answer becomes >>>> trivial, as H0 HAS to stop emulating when it gets to the call >>>> instruction, as there is no data at address 000015d2 defined to >>>> simulate. >>>> >>> >>> What a God damned liar. >>> https://liarparadox.org/HH0_(DDD)_Full_Trace.pdf >>> >> >> Which begins its trace at main, not DDD: >> > > You knew that there IS an HH0 and lied about it. > That makes you a God damned liar. > > Of course C programs begin at main() Liar !!! > But you weren't talking about it, so your trace isn't the claimed trace, so you are again the LIAR. You keep on talking about the decider taking as its input, the machine that calls it, and what THAT DECIDERS trace shows. That will not begin with main. THAT is the input that you NEED to show to "verify" your claim, and that you have never done. So, you are just showing that either you don't know what you are talking about, or intentionally trying to use double speak to avoid revealing your error. In the above program, if the listed bytes are all that is available, HHH0(DDD) absolutely can not trace more than 4 instructions. Thus, to make you claim, the input can't be just what you show. PERIOD. It must include all of the memory that the trace would go to, which means all of HHH0 and everything it calls, so when you change the decider, you have a different input, so can't equate them without lying.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-23 17:45 -0500 |
| Message-ID | <v5a8hi$hsjd$1@dont-email.me> |
| In reply to | #107688 |
On 6/23/2024 5:35 PM, Richard Damon wrote: > On 6/23/24 6:04 PM, olcott wrote: >> On 6/23/2024 4:49 PM, Richard Damon wrote: >>> On 6/23/24 5:41 PM, olcott wrote: >>>> On 6/23/2024 1:20 PM, Richard Damon wrote: >>>>> On 6/23/24 9:40 AM, olcott wrote: >>>>>> _DDD() >>>>>> [00002172] 55 push ebp >>>>>> [00002173] 8bec mov ebp,esp >>>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH0 >>>>>> [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. >>>>>> >>>>>> Likewise according to the semantics of arithmetic for >>>>>> decimal integers: 2 + 3 = 5. >>>>>> >>>>>> Anyone disagreeing with these two statements is WRONG. >>>>>> >>>>> >>>>> NOw, if you REALLY mean just can H0 simulate this input to a final >>>>> state, the answer is WHO CARES. >>>>> >>>>> But I will put out a few comments on errors in your presentation\. >>>>> >>>>> First, if you ONLY have the bytes presented, then the answer >>>>> becomes trivial, as H0 HAS to stop emulating when it gets to the >>>>> call instruction, as there is no data at address 000015d2 defined >>>>> to simulate. >>>>> >>>> >>>> What a God damned liar. >>>> https://liarparadox.org/HH0_(DDD)_Full_Trace.pdf >>>> >>> >>> Which begins its trace at main, not DDD: >>> >> >> You knew that there IS an HH0 and lied about it. >> That makes you a God damned liar. >> >> Of course C programs begin at main() Liar !!! >> > > But you weren't talking about it, so your trace isn't the claimed trace, > so you are again the LIAR. > > > You keep on talking about the decider taking as its input, the machine > that calls it, and what THAT DECIDERS trace shows. > > That will not begin with main. > > THAT is the input that you NEED to show to "verify" your claim, and that > you have never done. > > So, you are just showing that either you don't know what you are talking > about, or intentionally trying to use double speak to avoid revealing > your error. > > In the above program, if the listed bytes are all that is available, > HHH0(DDD) absolutely can not trace more than 4 instructions. > > Thus, to make you claim, the input can't be just what you show. PERIOD. > > It must include all of the memory that the trace would go to, which > means all of HHH0 and everything it calls, so when you change the > decider, you have a different input, so can't equate them without lying. You know what the freak I was talking from prior discussions unless your brain is so damaged that you can remember anything from one post to the next. In the case that you affirm that your brain <is> this damaged then I humbly apologize. -- 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 18:58 -0400 |
| Message-ID | <v5a9bi$smd4$3@i2pn2.org> |
| In reply to | #107689 |
On 6/23/24 6:45 PM, olcott wrote: > On 6/23/2024 5:35 PM, Richard Damon wrote: >> On 6/23/24 6:04 PM, olcott wrote: >>> On 6/23/2024 4:49 PM, Richard Damon wrote: >>>> On 6/23/24 5:41 PM, olcott wrote: >>>>> On 6/23/2024 1:20 PM, Richard Damon wrote: >>>>>> On 6/23/24 9:40 AM, olcott wrote: >>>>>>> _DDD() >>>>>>> [00002172] 55 push ebp >>>>>>> [00002173] 8bec mov ebp,esp >>>>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH0 >>>>>>> [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. >>>>>>> >>>>>>> Likewise according to the semantics of arithmetic for >>>>>>> decimal integers: 2 + 3 = 5. >>>>>>> >>>>>>> Anyone disagreeing with these two statements is WRONG. >>>>>>> >>>>>> >>>>>> NOw, if you REALLY mean just can H0 simulate this input to a final >>>>>> state, the answer is WHO CARES. >>>>>> >>>>>> But I will put out a few comments on errors in your presentation\. >>>>>> >>>>>> First, if you ONLY have the bytes presented, then the answer >>>>>> becomes trivial, as H0 HAS to stop emulating when it gets to the >>>>>> call instruction, as there is no data at address 000015d2 defined >>>>>> to simulate. >>>>>> >>>>> >>>>> What a God damned liar. >>>>> https://liarparadox.org/HH0_(DDD)_Full_Trace.pdf >>>>> >>>> >>>> Which begins its trace at main, not DDD: >>>> >>> >>> You knew that there IS an HH0 and lied about it. >>> That makes you a God damned liar. >>> >>> Of course C programs begin at main() Liar !!! >>> >> >> But you weren't talking about it, so your trace isn't the claimed >> trace, so you are again the LIAR. >> >> >> You keep on talking about the decider taking as its input, the machine >> that calls it, and what THAT DECIDERS trace shows. >> >> That will not begin with main. >> >> THAT is the input that you NEED to show to "verify" your claim, and >> that you have never done. >> >> So, you are just showing that either you don't know what you are >> talking about, or intentionally trying to use double speak to avoid >> revealing your error. >> >> In the above program, if the listed bytes are all that is available, >> HHH0(DDD) absolutely can not trace more than 4 instructions. >> >> Thus, to make you claim, the input can't be just what you show. PERIOD. >> >> It must include all of the memory that the trace would go to, which >> means all of HHH0 and everything it calls, so when you change the >> decider, you have a different input, so can't equate them without lying. > > You know what the freak I was talking from prior > discussions unless your brain is so damaged that > you can 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. I pointed out that you claim to have verified that the decider can not correctly emulate the input to the return instruciton. I point out that you have never shown such a decider correctly emulating the input past the CALL instruction. YOU HAVEN'T, and when you call me a liar, as "proof" you show a trace that doesn't show anything like what you claim. So, it is still demonstrated that the decider of the machine that calls the decider has ever been correctly emulated past the call instruction. So, you are still shown to be a LIAR.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-23 18:34 -0500 |
| Message-ID | <v5abdl$igvh$1@dont-email.me> |
| In reply to | #107690 |
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. -- 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 19:44 -0400 |
| Message-ID | <v5ac1p$smd4$4@i2pn2.org> |
| In reply to | #107691 |
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. Also, with JUST what you have said, I can prove it FALSE with an unpure H0, but I won't push that as you have previous indicated your intentions, but that also means that you have previously indicated that H0 is supposed to be a Halt Decider, so we can say you definition of its requirements are just wrong, so again it is an incorrect question. So, by that logic, you claim isn't correct (either being provably wrong or just the wrong questiion). You also haven't shown that your H0 actually DOES the required correct simulation, so you can't claim your results either, even if it is established that on partial correct emulation by any version of H0 can reach the return in H0, because we don't know if your H0 actually does a correct emulation. (If it did, you should be able to show its trace) Part of the problem, is with the input given, you can't get past the call 000015d2 instruciton as you don;t specify what is there, so we need to either assume that your problem is just an invalid one, or that we can use the implied input, which means that all of the code of H0 is included in the input, and thus any change to H0 implies a change to the input the way you do it (meaning we can't compare the results of different H0s). So, in summary, you are just showing a total lack of understanding of what you are talking about.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-23 19:08 -0500 |
| Message-ID | <v5add4$isal$1@dont-email.me> |
| In reply to | #107692 |
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 -- 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 20:24 -0400 |
| Message-ID | <v5aebe$smd4$5@i2pn2.org> |
| In reply to | #107693 |
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: 1) Statements of propositions that are currently accepted as proven by the general field. 2) Valid logical operations (of the field) on those statements to produce new statements that proven to be true by combining the accepted true statements with the valid logical operations. 3) Repeat 1) and 2) until you get to your proposition. You haven't done that for anything of significance, and I don't think you know how, you always drop into just making an argument, not a proof.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-23 20:00 -0500 |
| Message-ID | <v5aggb$jan3$1@dont-email.me> |
| In reply to | #107694 |
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. According to the semantics of the x86 programming language when DDD correctly emulated by H0 calls H0(DDD) this call 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 21:13 -0400 |
| Message-ID | <v5ah6u$smd5$7@i2pn2.org> |
| In reply to | #107695 |
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. If the Semantics actualy do show it, then a proof, using those semantic, should be possible, unless the proof becomes infinite in length. (Just like the semantics of arithmetic show that there is no number G that satisfies the specified Primative Recursive Relationship, but the issue is that in PA, the only method to show it is to test all infinity of the numbers one by one, so it isn't a proof, but is a true statement)
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-23 20:20 -0500 |
| Message-ID | <v5ahkc$jgfe$1@dont-email.me> |
| In reply to | #107696 |
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]
--
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 21:30 -0400 |
| Message-ID | <v5ai8i$smd5$8@i2pn2.org> |
| In reply to | #107697 |
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.
H may not have been able to prove that statement, but it could prove
that it doesn't halt, and basically made a wrong guess based on faulty
logic.
YOU on the other hand, are just a LIAR, as you claim your H does
something it doesn't.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-23 20:36 -0500 |
| Message-ID | <v5aij8$nd1b$2@dont-email.me> |
| In reply to | #107698 |
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.
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.
--
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:00 -0400 |
| Message-ID | <v5ajva$smd4$6@i2pn2.org> |
| In reply to | #107700 |
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.
Face it, you are just stuck with the need to lie about what halting
means because that is the only way to try to show your false ideas to
even have a chance to be true.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-23 21:09 -0500 |
| Message-ID | <v5akga$nr6u$1@dont-email.me> |
| In reply to | #107701 |
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?
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
Page 1 of 6 [1] 2 3 4 5 6 Next page →
Back to top | Article view | comp.theory
csiph-web