Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #107616 > unrolled thread
| Started by | olcott <polcott333@gmail.com> |
|---|---|
| First post | 2024-06-22 09:31 -0500 |
| Last post | 2024-06-25 08:54 +0000 |
| Articles | 20 on this page of 81 — 5 participants |
Back to article view | Back to comp.theory
Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-22 09:31 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-22 10:42 -0400
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-22 10:16 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-22 11:29 -0400
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-22 11:12 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-22 13:08 -0400
Re: Why do people here insist on denying these verified facts? joes <noreply@example.com> - 2024-06-22 16:03 +0000
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-22 11:18 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-22 13:13 -0400
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-22 12:29 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-22 14:43 -0400
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-22 13:49 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-22 14:55 -0400
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-22 14:03 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-22 15:19 -0400
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-22 14:35 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-22 15:43 -0400
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-22 14:49 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-22 16:08 -0400
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-22 18:59 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-22 20:19 -0400
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-22 22:37 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-23 07:28 -0400
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-23 08:36 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-23 14:22 -0400
Re: Why do people here insist on denying these verified facts? joes <noreply@example.com> - 2024-06-22 20:01 +0000
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-22 18:57 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-22 20:07 -0400
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-22 19:09 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-22 20:26 -0400
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-22 22:46 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-23 07:28 -0400
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-23 08:37 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-23 14:22 -0400
Re: Why do people here insist on denying these verified facts? joes <noreply@example.com> - 2024-06-25 09:20 +0000
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-23 12:50 +0300
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-23 08:25 -0500
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-24 10:31 +0300
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-24 08:52 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-24 19:20 -0400
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-25 12:42 +0300
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-25 08:29 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-25 21:47 -0400
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-26 10:41 +0300
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-26 07:25 -0500
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-27 10:02 +0300
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-27 12:18 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-27 19:57 -0400
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-28 11:55 +0300
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-28 09:54 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-28 23:49 -0400
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-29 10:44 +0300
Re: Why do people here insist on denying these verified facts? joes <noreply@example.com> - 2024-06-25 20:41 +0000
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-25 16:24 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-25 21:47 -0400
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-26 10:46 +0300
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-26 07:45 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-26 19:41 -0400
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-27 10:06 +0300
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-27 14:19 -0500
Re: Why do people here insist on denying these verified facts? joes <noreply@example.com> - 2024-06-26 08:19 +0000
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-23 12:42 +0300
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-23 08:23 -0500
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-24 10:32 +0300
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-24 08:50 -0500
Re: Why do people here insist on denying these verified facts? immibis <news@immibis.com> - 2024-06-24 16:03 +0200
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-25 12:48 +0300
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-25 08:19 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-25 21:47 -0400
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-26 10:54 +0300
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-26 07:53 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-26 19:41 -0400
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-27 10:18 +0300
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-27 14:42 -0500
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-27 19:57 -0400
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-28 12:06 +0300
Re: Why do people here insist on denying these verified facts? olcott <polcott333@gmail.com> - 2024-06-28 10:07 -0500
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-29 10:47 +0300
Re: Why do people here insist on denying these verified facts? Richard Damon <richard@damon-family.org> - 2024-06-24 19:21 -0400
Re: Why do people here insist on denying these verified facts? Mikko <mikko.levanto@iki.fi> - 2024-06-25 12:47 +0300
Re: Why do people here insist on denying these verified facts? joes <noreply@example.com> - 2024-06-25 08:54 +0000
Page 3 of 5 — ← Prev page 1 2 [3] 4 5 Next page →
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-25 12:42 +0300 |
| Message-ID | <v5e3df$1gco9$1@dont-email.me> |
| In reply to | #107725 |
On 2024-06-24 13:52:23 +0000, olcott said:
> On 6/24/2024 2:31 AM, Mikko wrote:
>> On 2024-06-23 13:25:36 +0000, olcott said:
>>
>>> On 6/23/2024 4:50 AM, Mikko wrote:
>>>> On 2024-06-22 19:03:13 +0000, olcott said:
>>>>
>>>>> On 6/22/2024 1:55 PM, Richard Damon wrote:
>>>>>> On 6/22/24 2:49 PM, olcott wrote:
>>>>>>> On 6/22/2024 1:43 PM, Richard Damon wrote:
>>>>>>>> On 6/22/24 1:29 PM, olcott wrote:
>>>>>>>>> On 6/22/2024 12:13 PM, Richard Damon wrote:
>>>>>>>>>> On 6/22/24 12:18 PM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>> void DDD()
>>>>>>>>>>> {
>>>>>>>>>>> HHH0(DDD);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> The input to HHH0(DDD) includes itself.
>>>>>>>>>>> The input to HHH1(DDD) DOES NOT include itself.
>>>>>>>>>>>
>>>>>>>>>>> It is stipulated that correct emulation is defined by the
>>>>>>>>>>> semantics of the x86 programming language and nothing else.
>>>>>>>>>>
>>>>>>>>>> And thus, your emulation traces show that your "Simulating Halt
>>>>>>>>>> Deciders" do not do a "Correct Simulation"
>>>>>>>>>
>>>>>>>>> Apparently your ADD preventing you from paying close attention
>>>>>>>>> to ALL of my words.
>>>>>>>>>
>>>>>>>>> *Function names adapted to correspond to my updated paper*
>>>>>>>>>
>>>>>>>>> void DDD()
>>>>>>>>> {
>>>>>>>>> H0(DDD);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>
>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>
>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>
>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>
>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>
>>>>>>>>> then we see that when DDD is correctly emulated by H0 that
>>>>>>>>> its call to H0(DDD) cannot possibly return.
>>>>>>>>
>>>>>>>> Since your H0 has never demonstrated that is actually DOES the correct
>>>>>>>> simulation per your stipulation,
>>>>>>>
>>>>>>> Liar
>>>>>>>
>>>>>>
>>>>>> Then where is it?
>>>>>>
>>>>> When we stipulate that the only measure of a correct emulation
>>>>> is the semantics of the x86 programming language then we see that
>>>>> when DDD is correctly emulated by H0 that its call to H0(DDD)
>>>>> cannot possibly return.
>>>>
>>>> Semantics of the x86 programming language does not specifiy emulation
>>>> or correctness of emulation.
>>>>
>>>
>>> WRONG!
>>
>> Unless you point where in Intel's documentation emulation or correctness
>> of emulation is specified you have no basis to say "WRONG".
>>
>
> Not at all. That is the same as saying that 2 + 3 = 5
> is wrong until proven by PA.
If you want to claim that 2 + 3 = 5 you must show some basis for the claim.
One obvious source of such basis is Peano Arithmetic. Likewise, if you say
"WRONG" you must show some basis for the claim. When the statement claimed
"WRONG" is about x86 programming language, an sobvious source for such basis
is Intel's documentation.
>>> Otherwise we could say that for the decimal integers
>>> 2 + 3 = 17 and the semantics of arithmetic does not disagree.
No, you can only say that you don't know any disageement between them.
Without a proof threse is a possibility of an unknown disagreement.
>> I can believe you couls but I would not.
>>
>>> The semantics of arithmetic agrees that for the decimal
>>> integers 2 + 3 = 5.
>>
>> Intel's processors seem to agree, too. But I havn't checked every one.
>
> _DDD()
> [00002172] 55 push ebp ; housekeeping
> [00002173] 8bec mov ebp,esp ; housekeeping
> [00002175] 6872210000 push 00002172 ; push DDD
> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
> [0000217f] 83c404 add esp,+04
> [00002182] 5d pop ebp
> [00002183] c3 ret
> Size in bytes:(0018) [00002183]
>
> The call from DDD to H0(DDD) when DDD is correctly emulated
> by H0 cannot possibly return.
What is shown above does not prove that the call to 15d3 does not
return, nor whether there is H0 or HHH0 or something else at that
location.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-25 08:29 -0500 |
| Message-ID | <v5egoe$1ikpr$4@dont-email.me> |
| In reply to | #107779 |
On 6/25/2024 4:42 AM, Mikko wrote:
> On 2024-06-24 13:52:23 +0000, olcott said:
>
>> On 6/24/2024 2:31 AM, Mikko wrote:
>>> On 2024-06-23 13:25:36 +0000, olcott said:
>>>
>>>> On 6/23/2024 4:50 AM, Mikko wrote:
>>>>> On 2024-06-22 19:03:13 +0000, olcott said:
>>>>>
>>>>>> On 6/22/2024 1:55 PM, Richard Damon wrote:
>>>>>>> On 6/22/24 2:49 PM, olcott wrote:
>>>>>>>> On 6/22/2024 1:43 PM, Richard Damon wrote:
>>>>>>>>> On 6/22/24 1:29 PM, olcott wrote:
>>>>>>>>>> On 6/22/2024 12:13 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/22/24 12:18 PM, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> void DDD()
>>>>>>>>>>>> {
>>>>>>>>>>>> HHH0(DDD);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> The input to HHH0(DDD) includes itself.
>>>>>>>>>>>> The input to HHH1(DDD) DOES NOT include itself.
>>>>>>>>>>>>
>>>>>>>>>>>> It is stipulated that correct emulation is defined by the
>>>>>>>>>>>> semantics of the x86 programming language and nothing else.
>>>>>>>>>>>
>>>>>>>>>>> And thus, your emulation traces show that your "Simulating
>>>>>>>>>>> Halt Deciders" do not do a "Correct Simulation"
>>>>>>>>>>
>>>>>>>>>> Apparently your ADD preventing you from paying close attention
>>>>>>>>>> to ALL of my words.
>>>>>>>>>>
>>>>>>>>>> *Function names adapted to correspond to my updated paper*
>>>>>>>>>>
>>>>>>>>>> void DDD()
>>>>>>>>>> {
>>>>>>>>>> H0(DDD);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>
>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>
>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>
>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>
>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>
>>>>>>>>>> then we see that when DDD is correctly emulated by H0 that
>>>>>>>>>> its call to H0(DDD) cannot possibly return.
>>>>>>>>>
>>>>>>>>> Since your H0 has never demonstrated that is actually DOES the
>>>>>>>>> correct simulation per your stipulation,
>>>>>>>>
>>>>>>>> Liar
>>>>>>>>
>>>>>>>
>>>>>>> Then where is it?
>>>>>>>
>>>>>> When we stipulate that the only measure of a correct emulation
>>>>>> is the semantics of the x86 programming language then we see that
>>>>>> when DDD is correctly emulated by H0 that its call to H0(DDD)
>>>>>> cannot possibly return.
>>>>>
>>>>> Semantics of the x86 programming language does not specifiy emulation
>>>>> or correctness of emulation.
>>>>>
>>>>
>>>> WRONG!
>>>
>>> Unless you point where in Intel's documentation emulation or correctness
>>> of emulation is specified you have no basis to say "WRONG".
>>>
>>
>> Not at all. That is the same as saying that 2 + 3 = 5
>> is wrong until proven by PA.
>
> If you want to claim that 2 + 3 = 5 you must show some basis for the claim.
> One obvious source of such basis is Peano Arithmetic. Likewise, if you say
> "WRONG" you must show some basis for the claim. When the statement claimed
> "WRONG" is about x86 programming language, an sobvious source for such
> basis
> is Intel's documentation.
>
>>>> Otherwise we could say that for the decimal integers
>>>> 2 + 3 = 17 and the semantics of arithmetic does not disagree.
>
> No, you can only say that you don't know any disageement between them.
> Without a proof threse is a possibility of an unknown disagreement.
>
>>> I can believe you couls but I would not.
>>>
>>>> The semantics of arithmetic agrees that for the decimal
>>>> integers 2 + 3 = 5.
>>>
>>> Intel's processors seem to agree, too. But I havn't checked every one.
>>
>> _DDD()
>> [00002172] 55 push ebp ; housekeeping
>> [00002173] 8bec mov ebp,esp ; housekeeping
>> [00002175] 6872210000 push 00002172 ; push DDD
>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>> [0000217f] 83c404 add esp,+04
>> [00002182] 5d pop ebp
>> [00002183] c3 ret
>> Size in bytes:(0018) [00002183]
>>
>> The call from DDD to H0(DDD) when DDD is correctly emulated
>> by H0 cannot possibly return.
>
> What is shown above does not prove that the call to 15d3 does not
> return, nor whether there is H0 or HHH0 or something else at that
> location.
>
It is stipulated that DDD is correctly emulated by the
H0 at machine address 000015d2.
It is stipulated the the correct simulation is ruled by
the semantics of the x86 programming language.
*This conclusively proves*
The call from DDD to H0(DDD) when DDD is correctly emulated
by H0 *CANNOT POSSIBLY RETURN*
I am unwilling to talk about anything else with you until
you agree to this.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-25 21:47 -0400 |
| Message-ID | <v5frvc$14bcm$1@i2pn2.org> |
| In reply to | #107790 |
On 6/25/24 9:29 AM, olcott wrote:
> On 6/25/2024 4:42 AM, Mikko wrote:
>> On 2024-06-24 13:52:23 +0000, olcott said:
>>
>>> On 6/24/2024 2:31 AM, Mikko wrote:
>>>> On 2024-06-23 13:25:36 +0000, olcott said:
>>>>
>>>>> On 6/23/2024 4:50 AM, Mikko wrote:
>>>>>> On 2024-06-22 19:03:13 +0000, olcott said:
>>>>>>
>>>>>>> On 6/22/2024 1:55 PM, Richard Damon wrote:
>>>>>>>> On 6/22/24 2:49 PM, olcott wrote:
>>>>>>>>> On 6/22/2024 1:43 PM, Richard Damon wrote:
>>>>>>>>>> On 6/22/24 1:29 PM, olcott wrote:
>>>>>>>>>>> On 6/22/2024 12:13 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/22/24 12:18 PM, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> HHH0(DDD);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> The input to HHH0(DDD) includes itself.
>>>>>>>>>>>>> The input to HHH1(DDD) DOES NOT include itself.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is stipulated that correct emulation is defined by the
>>>>>>>>>>>>> semantics of the x86 programming language and nothing else.
>>>>>>>>>>>>
>>>>>>>>>>>> And thus, your emulation traces show that your "Simulating
>>>>>>>>>>>> Halt Deciders" do not do a "Correct Simulation"
>>>>>>>>>>>
>>>>>>>>>>> Apparently your ADD preventing you from paying close attention
>>>>>>>>>>> to ALL of my words.
>>>>>>>>>>>
>>>>>>>>>>> *Function names adapted to correspond to my updated paper*
>>>>>>>>>>>
>>>>>>>>>>> void DDD()
>>>>>>>>>>> {
>>>>>>>>>>> H0(DDD);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>
>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>
>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>
>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>
>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>
>>>>>>>>>>> then we see that when DDD is correctly emulated by H0 that
>>>>>>>>>>> its call to H0(DDD) cannot possibly return.
>>>>>>>>>>
>>>>>>>>>> Since your H0 has never demonstrated that is actually DOES the
>>>>>>>>>> correct simulation per your stipulation,
>>>>>>>>>
>>>>>>>>> Liar
>>>>>>>>>
>>>>>>>>
>>>>>>>> Then where is it?
>>>>>>>>
>>>>>>> When we stipulate that the only measure of a correct emulation
>>>>>>> is the semantics of the x86 programming language then we see that
>>>>>>> when DDD is correctly emulated by H0 that its call to H0(DDD)
>>>>>>> cannot possibly return.
>>>>>>
>>>>>> Semantics of the x86 programming language does not specifiy emulation
>>>>>> or correctness of emulation.
>>>>>>
>>>>>
>>>>> WRONG!
>>>>
>>>> Unless you point where in Intel's documentation emulation or
>>>> correctness
>>>> of emulation is specified you have no basis to say "WRONG".
>>>>
>>>
>>> Not at all. That is the same as saying that 2 + 3 = 5
>>> is wrong until proven by PA.
>>
>> If you want to claim that 2 + 3 = 5 you must show some basis for the
>> claim.
>> One obvious source of such basis is Peano Arithmetic. Likewise, if you
>> say
>> "WRONG" you must show some basis for the claim. When the statement
>> claimed
>> "WRONG" is about x86 programming language, an sobvious source for such
>> basis
>> is Intel's documentation.
>>
>>>>> Otherwise we could say that for the decimal integers
>>>>> 2 + 3 = 17 and the semantics of arithmetic does not disagree.
>>
>> No, you can only say that you don't know any disageement between them.
>> Without a proof threse is a possibility of an unknown disagreement.
>>
>>>> I can believe you couls but I would not.
>>>>
>>>>> The semantics of arithmetic agrees that for the decimal
>>>>> integers 2 + 3 = 5.
>>>>
>>>> Intel's processors seem to agree, too. But I havn't checked every one.
>>>
>>> _DDD()
>>> [00002172] 55 push ebp ; housekeeping
>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>> [00002175] 6872210000 push 00002172 ; push DDD
>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>> [0000217f] 83c404 add esp,+04
>>> [00002182] 5d pop ebp
>>> [00002183] c3 ret
>>> Size in bytes:(0018) [00002183]
>>>
>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>> by H0 cannot possibly return.
>>
>> What is shown above does not prove that the call to 15d3 does not
>> return, nor whether there is H0 or HHH0 or something else at that
>> location.
>>
>
> It is stipulated that DDD is correctly emulated by the
> H0 at machine address 000015d2.
Not something that can be stipulated. You can not stipulate that
something IS correct.
You can state that as a condition of the argument (you then need to show
that the condition can/is meet by your H0)
>
> It is stipulated the the correct simulation is ruled by
> the semantics of the x86 programming language.
THAT is a valid stipulation,
>
> *This conclusively proves*
> The call from DDD to H0(DDD) when DDD is correctly emulated
> by H0 *CANNOT POSSIBLY RETURN*
Nope, not unless you stipulate that you H0 is an actual COMPLETE and
correct simulation that never abort.
Otherwise, we know that the ACTUAL behavior of DDD after the aborted
simulation will be to return, and if you try to limit "behavior" to what
the simulation showed, then implying behavior after the abort is
off-limits, and all you can say is that it did not return during the
simulation (if you can in fact prove that much).
Note, since you keep on forgetting to put all your requirements on H0,
then I can say your statement is just false by the example of the unpure
H0 that can see that this is a second call, and just returns.
>
> I am unwilling to talk about anything else with you until
> you agree to this.
>
And that makes arguing with you easier, as we can continue to refine the
arguments of why your claim doesn't do what you want.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-26 10:41 +0300 |
| Message-ID | <v5ggmi$21nkc$1@dont-email.me> |
| In reply to | #107790 |
On 2024-06-25 13:29:50 +0000, olcott said:
> On 6/25/2024 4:42 AM, Mikko wrote:
>> On 2024-06-24 13:52:23 +0000, olcott said:
>>
>>> On 6/24/2024 2:31 AM, Mikko wrote:
>>>> On 2024-06-23 13:25:36 +0000, olcott said:
>>>>
>>>>> On 6/23/2024 4:50 AM, Mikko wrote:
>>>>>> On 2024-06-22 19:03:13 +0000, olcott said:
>>>>>>
>>>>>>> On 6/22/2024 1:55 PM, Richard Damon wrote:
>>>>>>>> On 6/22/24 2:49 PM, olcott wrote:
>>>>>>>>> On 6/22/2024 1:43 PM, Richard Damon wrote:
>>>>>>>>>> On 6/22/24 1:29 PM, olcott wrote:
>>>>>>>>>>> On 6/22/2024 12:13 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/22/24 12:18 PM, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> HHH0(DDD);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> The input to HHH0(DDD) includes itself.
>>>>>>>>>>>>> The input to HHH1(DDD) DOES NOT include itself.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is stipulated that correct emulation is defined by the
>>>>>>>>>>>>> semantics of the x86 programming language and nothing else.
>>>>>>>>>>>>
>>>>>>>>>>>> And thus, your emulation traces show that your "Simulating Halt
>>>>>>>>>>>> Deciders" do not do a "Correct Simulation"
>>>>>>>>>>>
>>>>>>>>>>> Apparently your ADD preventing you from paying close attention
>>>>>>>>>>> to ALL of my words.
>>>>>>>>>>>
>>>>>>>>>>> *Function names adapted to correspond to my updated paper*
>>>>>>>>>>>
>>>>>>>>>>> void DDD()
>>>>>>>>>>> {
>>>>>>>>>>> H0(DDD);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>
>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>
>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>
>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>
>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>
>>>>>>>>>>> then we see that when DDD is correctly emulated by H0 that
>>>>>>>>>>> its call to H0(DDD) cannot possibly return.
>>>>>>>>>>
>>>>>>>>>> Since your H0 has never demonstrated that is actually DOES the correct
>>>>>>>>>> simulation per your stipulation,
>>>>>>>>>
>>>>>>>>> Liar
>>>>>>>>>
>>>>>>>>
>>>>>>>> Then where is it?
>>>>>>>>
>>>>>>> When we stipulate that the only measure of a correct emulation
>>>>>>> is the semantics of the x86 programming language then we see that
>>>>>>> when DDD is correctly emulated by H0 that its call to H0(DDD)
>>>>>>> cannot possibly return.
>>>>>>
>>>>>> Semantics of the x86 programming language does not specifiy emulation
>>>>>> or correctness of emulation.
>>>>>>
>>>>>
>>>>> WRONG!
>>>>
>>>> Unless you point where in Intel's documentation emulation or correctness
>>>> of emulation is specified you have no basis to say "WRONG".
>>>>
>>>
>>> Not at all. That is the same as saying that 2 + 3 = 5
>>> is wrong until proven by PA.
>>
>> If you want to claim that 2 + 3 = 5 you must show some basis for the claim.
>> One obvious source of such basis is Peano Arithmetic. Likewise, if you say
>> "WRONG" you must show some basis for the claim. When the statement claimed
>> "WRONG" is about x86 programming language, an sobvious source for such basis
>> is Intel's documentation.
>>
>>>>> Otherwise we could say that for the decimal integers
>>>>> 2 + 3 = 17 and the semantics of arithmetic does not disagree.
>>
>> No, you can only say that you don't know any disageement between them.
>> Without a proof threse is a possibility of an unknown disagreement.
>>
>>>> I can believe you couls but I would not.
>>>>
>>>>> The semantics of arithmetic agrees that for the decimal
>>>>> integers 2 + 3 = 5.
>>>>
>>>> Intel's processors seem to agree, too. But I havn't checked every one.
>>>
>>> _DDD()
>>> [00002172] 55 push ebp ; housekeeping
>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>> [00002175] 6872210000 push 00002172 ; push DDD
>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>> [0000217f] 83c404 add esp,+04
>>> [00002182] 5d pop ebp
>>> [00002183] c3 ret
>>> Size in bytes:(0018) [00002183]
>>>
>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>> by H0 cannot possibly return.
>>
>> What is shown above does not prove that the call to 15d3 does not
>> return, nor whether there is H0 or HHH0 or something else at that
>> location.
>>
>
> It is stipulated that DDD is correctly emulated by the
> H0 at machine address 000015d2.
There is no such stipulation in the above text. The C code specifies
and a comment in the machine code claims that H0 is called but don't
say what H0 does.
> It is stipulated the the correct simulation is ruled by
> the semantics of the x86 programming language.
That does not fully define "correct simulation" but may specify enough
of it to contradict the previous stipulation.
> *This conclusively proves*
> The call from DDD to H0(DDD) when DDD is correctly emulated
> by H0 *CANNOT POSSIBLY RETURN*
It proves nothing if no proof is shown.
> I am unwilling to talk about anything else with you until
> you agree to this.
Unlikely to ever happen, especially about stipulations.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 07:25 -0500 |
| Message-ID | <v5h1bo$24jbd$1@dont-email.me> |
| In reply to | #107842 |
On 6/26/2024 2:41 AM, Mikko wrote:
> On 2024-06-25 13:29:50 +0000, olcott said:
>
>> On 6/25/2024 4:42 AM, Mikko wrote:
>>> On 2024-06-24 13:52:23 +0000, olcott said:
>>>
>>>> On 6/24/2024 2:31 AM, Mikko wrote:
>>>>> On 2024-06-23 13:25:36 +0000, olcott said:
>>>>>
>>>>>> On 6/23/2024 4:50 AM, Mikko wrote:
>>>>>>> On 2024-06-22 19:03:13 +0000, olcott said:
>>>>>>>
>>>>>>>> On 6/22/2024 1:55 PM, Richard Damon wrote:
>>>>>>>>> On 6/22/24 2:49 PM, olcott wrote:
>>>>>>>>>> On 6/22/2024 1:43 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/22/24 1:29 PM, olcott wrote:
>>>>>>>>>>>> On 6/22/2024 12:13 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 6/22/24 12:18 PM, olcott wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> HHH0(DDD);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The input to HHH0(DDD) includes itself.
>>>>>>>>>>>>>> The input to HHH1(DDD) DOES NOT include itself.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is stipulated that correct emulation is defined by the
>>>>>>>>>>>>>> semantics of the x86 programming language and nothing else.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And thus, your emulation traces show that your "Simulating
>>>>>>>>>>>>> Halt Deciders" do not do a "Correct Simulation"
>>>>>>>>>>>>
>>>>>>>>>>>> Apparently your ADD preventing you from paying close attention
>>>>>>>>>>>> to ALL of my words.
>>>>>>>>>>>>
>>>>>>>>>>>> *Function names adapted to correspond to my updated paper*
>>>>>>>>>>>>
>>>>>>>>>>>> void DDD()
>>>>>>>>>>>> {
>>>>>>>>>>>> H0(DDD);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>
>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>
>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>
>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>
>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>
>>>>>>>>>>>> then we see that when DDD is correctly emulated by H0 that
>>>>>>>>>>>> its call to H0(DDD) cannot possibly return.
>>>>>>>>>>>
>>>>>>>>>>> Since your H0 has never demonstrated that is actually DOES
>>>>>>>>>>> the correct simulation per your stipulation,
>>>>>>>>>>
>>>>>>>>>> Liar
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Then where is it?
>>>>>>>>>
>>>>>>>> When we stipulate that the only measure of a correct emulation
>>>>>>>> is the semantics of the x86 programming language then we see that
>>>>>>>> when DDD is correctly emulated by H0 that its call to H0(DDD)
>>>>>>>> cannot possibly return.
>>>>>>>
>>>>>>> Semantics of the x86 programming language does not specifiy
>>>>>>> emulation
>>>>>>> or correctness of emulation.
>>>>>>>
>>>>>>
>>>>>> WRONG!
>>>>>
>>>>> Unless you point where in Intel's documentation emulation or
>>>>> correctness
>>>>> of emulation is specified you have no basis to say "WRONG".
>>>>>
>>>>
>>>> Not at all. That is the same as saying that 2 + 3 = 5
>>>> is wrong until proven by PA.
>>>
>>> If you want to claim that 2 + 3 = 5 you must show some basis for the
>>> claim.
>>> One obvious source of such basis is Peano Arithmetic. Likewise, if
>>> you say
>>> "WRONG" you must show some basis for the claim. When the statement
>>> claimed
>>> "WRONG" is about x86 programming language, an sobvious source for
>>> such basis
>>> is Intel's documentation.
>>>
>>>>>> Otherwise we could say that for the decimal integers
>>>>>> 2 + 3 = 17 and the semantics of arithmetic does not disagree.
>>>
>>> No, you can only say that you don't know any disageement between them.
>>> Without a proof threse is a possibility of an unknown disagreement.
>>>
>>>>> I can believe you couls but I would not.
>>>>>
>>>>>> The semantics of arithmetic agrees that for the decimal
>>>>>> integers 2 + 3 = 5.
>>>>>
>>>>> Intel's processors seem to agree, too. But I havn't checked every one.
>>>>
>>>> _DDD()
>>>> [00002172] 55 push ebp ; housekeeping
>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>> [0000217f] 83c404 add esp,+04
>>>> [00002182] 5d pop ebp
>>>> [00002183] c3 ret
>>>> Size in bytes:(0018) [00002183]
>>>>
>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>> by H0 cannot possibly return.
>>>
>>> What is shown above does not prove that the call to 15d3 does not
>>> return, nor whether there is H0 or HHH0 or something else at that
>>> location.
>>>
>>
>> It is stipulated that DDD is correctly emulated by the
>> H0 at machine address 000015d2.
>
> There is no such stipulation in the above text. The C code specifies
> and a comment in the machine code claims that H0 is called but don't
> say what H0 does.
>
>> It is stipulated the the correct simulation is ruled by
>> the semantics of the x86 programming language.
>
> That does not fully define "correct simulation" but may specify enough
> of it to contradict the previous stipulation.
>
>> *This conclusively proves*
>> The call from DDD to H0(DDD) when DDD is correctly emulated
>> by H0 *CANNOT POSSIBLY RETURN*
>
> It proves nothing if no proof is shown.
>
I will use your system of reasoning.
The semantics of decimal arithmetic prove that 2 + 3 = 5.
Your reply
Aritmetic has no semantics and there is no such thing as numbers
>> I am unwilling to talk about anything else with you until
>> you agree to this.
>
> Unlikely to ever happen, especially about stipulations.
>
_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]
For every x86 emulator H0 at machine address 0000217a
The call from DDD to H0(DDD) when DDD is correctly emulated
by H0 cannot possibly return is proven correct by the semantics
of the x86 programming language.
If you want to play head games and continue to deny verified
fact you will look increasingly ridiculous and I will greatly
reduce the number of your posts that I look at.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-27 10:02 +0300 |
| Message-ID | <v5j2qu$2kgmo$1@dont-email.me> |
| In reply to | #107853 |
On 2024-06-26 12:25:28 +0000, olcott said:
> On 6/26/2024 2:41 AM, Mikko wrote:
>> On 2024-06-25 13:29:50 +0000, olcott said:
>>
>>> On 6/25/2024 4:42 AM, Mikko wrote:
>>>> On 2024-06-24 13:52:23 +0000, olcott said:
>>>>
>>>>> On 6/24/2024 2:31 AM, Mikko wrote:
>>>>>> On 2024-06-23 13:25:36 +0000, olcott said:
>>>>>>
>>>>>>> On 6/23/2024 4:50 AM, Mikko wrote:
>>>>>>>> On 2024-06-22 19:03:13 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 6/22/2024 1:55 PM, Richard Damon wrote:
>>>>>>>>>> On 6/22/24 2:49 PM, olcott wrote:
>>>>>>>>>>> On 6/22/2024 1:43 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/22/24 1:29 PM, olcott wrote:
>>>>>>>>>>>>> On 6/22/2024 12:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/22/24 12:18 PM, olcott wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> HHH0(DDD);
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The input to HHH0(DDD) includes itself.
>>>>>>>>>>>>>>> The input to HHH1(DDD) DOES NOT include itself.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is stipulated that correct emulation is defined by the
>>>>>>>>>>>>>>> semantics of the x86 programming language and nothing else.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And thus, your emulation traces show that your "Simulating Halt
>>>>>>>>>>>>>> Deciders" do not do a "Correct Simulation"
>>>>>>>>>>>>>
>>>>>>>>>>>>> Apparently your ADD preventing you from paying close attention
>>>>>>>>>>>>> to ALL of my words.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Function names adapted to correspond to my updated paper*
>>>>>>>>>>>>>
>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> H0(DDD);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>
>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>
>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>
>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>
>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>
>>>>>>>>>>>>> then we see that when DDD is correctly emulated by H0 that
>>>>>>>>>>>>> its call to H0(DDD) cannot possibly return.
>>>>>>>>>>>>
>>>>>>>>>>>> Since your H0 has never demonstrated that is actually DOES the correct
>>>>>>>>>>>> simulation per your stipulation,
>>>>>>>>>>>
>>>>>>>>>>> Liar
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Then where is it?
>>>>>>>>>>
>>>>>>>>> When we stipulate that the only measure of a correct emulation
>>>>>>>>> is the semantics of the x86 programming language then we see that
>>>>>>>>> when DDD is correctly emulated by H0 that its call to H0(DDD)
>>>>>>>>> cannot possibly return.
>>>>>>>>
>>>>>>>> Semantics of the x86 programming language does not specifiy emulation
>>>>>>>> or correctness of emulation.
>>>>>>>>
>>>>>>>
>>>>>>> WRONG!
>>>>>>
>>>>>> Unless you point where in Intel's documentation emulation or correctness
>>>>>> of emulation is specified you have no basis to say "WRONG".
>>>>>>
>>>>>
>>>>> Not at all. That is the same as saying that 2 + 3 = 5
>>>>> is wrong until proven by PA.
>>>>
>>>> If you want to claim that 2 + 3 = 5 you must show some basis for the claim.
>>>> One obvious source of such basis is Peano Arithmetic. Likewise, if you say
>>>> "WRONG" you must show some basis for the claim. When the statement claimed
>>>> "WRONG" is about x86 programming language, an sobvious source for such basis
>>>> is Intel's documentation.
>>>>
>>>>>>> Otherwise we could say that for the decimal integers
>>>>>>> 2 + 3 = 17 and the semantics of arithmetic does not disagree.
>>>>
>>>> No, you can only say that you don't know any disageement between them.
>>>> Without a proof threse is a possibility of an unknown disagreement.
>>>>
>>>>>> I can believe you couls but I would not.
>>>>>>
>>>>>>> The semantics of arithmetic agrees that for the decimal
>>>>>>> integers 2 + 3 = 5.
>>>>>>
>>>>>> Intel's processors seem to agree, too. But I havn't checked every one.
>>>>>
>>>>> _DDD()
>>>>> [00002172] 55 push ebp ; housekeeping
>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>>> [0000217f] 83c404 add esp,+04
>>>>> [00002182] 5d pop ebp
>>>>> [00002183] c3 ret
>>>>> Size in bytes:(0018) [00002183]
>>>>>
>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>> by H0 cannot possibly return.
>>>>
>>>> What is shown above does not prove that the call to 15d3 does not
>>>> return, nor whether there is H0 or HHH0 or something else at that
>>>> location.
>>>>
>>>
>>> It is stipulated that DDD is correctly emulated by the
>>> H0 at machine address 000015d2.
>>
>> There is no such stipulation in the above text. The C code specifies
>> and a comment in the machine code claims that H0 is called but don't
>> say what H0 does.
>>
>>> It is stipulated the the correct simulation is ruled by
>>> the semantics of the x86 programming language.
>>
>> That does not fully define "correct simulation" but may specify enough
>> of it to contradict the previous stipulation.
>>
>>> *This conclusively proves*
>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>> by H0 *CANNOT POSSIBLY RETURN*
>>
>> It proves nothing if no proof is shown.
>>
>
> I will use your system of reasoning.
> The semantics of decimal arithmetic prove that 2 + 3 = 5.
You nave not shown the proof.
> Your reply
> Aritmetic has no semantics and there is no such thing as numbers
There is the standard semantics of Peano arithmetic and various other
arithmetics. You have not proven that there is no such thing as numbers.
Whether that is provable depends on the exact meanings of "there is" and
"such" and "numbers". These (and many other) vernacular words are fuzzy.
>>> I am unwilling to talk about anything else with you until
>>> you agree to this.
>>
>> Unlikely to ever happen, especially about stipulations.
>
> _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]
>
> For every x86 emulator H0 at machine address 0000217a
> The call from DDD to H0(DDD) when DDD is correctly emulated
> by H0 cannot possibly return is proven correct by the semantics
> of the x86 programming language.
Proofs about machine language programs tend to be long as one must
prove about every instruction at least that it does not invalidate
the proofs about other instructions. A proof about a C program
would be much shorter.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-27 12:18 -0500 |
| Message-ID | <v5k6sv$2qsdr$3@dont-email.me> |
| In reply to | #107917 |
On 6/27/2024 2:02 AM, Mikko wrote:
> On 2024-06-26 12:25:28 +0000, olcott said:
>
>> On 6/26/2024 2:41 AM, Mikko wrote:
>>> On 2024-06-25 13:29:50 +0000, olcott said:
>>>
>>>> On 6/25/2024 4:42 AM, Mikko wrote:
>>>>> On 2024-06-24 13:52:23 +0000, olcott said:
>>>>>
>>>>>> On 6/24/2024 2:31 AM, Mikko wrote:
>>>>>>> On 2024-06-23 13:25:36 +0000, olcott said:
>>>>>>>
>>>>>>>> On 6/23/2024 4:50 AM, Mikko wrote:
>>>>>>>>> On 2024-06-22 19:03:13 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 6/22/2024 1:55 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/22/24 2:49 PM, olcott wrote:
>>>>>>>>>>>> On 6/22/2024 1:43 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 6/22/24 1:29 PM, olcott wrote:
>>>>>>>>>>>>>> On 6/22/2024 12:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 6/22/24 12:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> HHH0(DDD);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The input to HHH0(DDD) includes itself.
>>>>>>>>>>>>>>>> The input to HHH1(DDD) DOES NOT include itself.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is stipulated that correct emulation is defined by the
>>>>>>>>>>>>>>>> semantics of the x86 programming language and nothing else.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And thus, your emulation traces show that your
>>>>>>>>>>>>>>> "Simulating Halt Deciders" do not do a "Correct Simulation"
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Apparently your ADD preventing you from paying close
>>>>>>>>>>>>>> attention
>>>>>>>>>>>>>> to ALL of my words.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Function names adapted to correspond to my updated paper*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> H0(DDD);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> then we see that when DDD is correctly emulated by H0 that
>>>>>>>>>>>>>> its call to H0(DDD) cannot possibly return.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since your H0 has never demonstrated that is actually DOES
>>>>>>>>>>>>> the correct simulation per your stipulation,
>>>>>>>>>>>>
>>>>>>>>>>>> Liar
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Then where is it?
>>>>>>>>>>>
>>>>>>>>>> When we stipulate that the only measure of a correct emulation
>>>>>>>>>> is the semantics of the x86 programming language then we see that
>>>>>>>>>> when DDD is correctly emulated by H0 that its call to H0(DDD)
>>>>>>>>>> cannot possibly return.
>>>>>>>>>
>>>>>>>>> Semantics of the x86 programming language does not specifiy
>>>>>>>>> emulation
>>>>>>>>> or correctness of emulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> WRONG!
>>>>>>>
>>>>>>> Unless you point where in Intel's documentation emulation or
>>>>>>> correctness
>>>>>>> of emulation is specified you have no basis to say "WRONG".
>>>>>>>
>>>>>>
>>>>>> Not at all. That is the same as saying that 2 + 3 = 5
>>>>>> is wrong until proven by PA.
>>>>>
>>>>> If you want to claim that 2 + 3 = 5 you must show some basis for
>>>>> the claim.
>>>>> One obvious source of such basis is Peano Arithmetic. Likewise, if
>>>>> you say
>>>>> "WRONG" you must show some basis for the claim. When the statement
>>>>> claimed
>>>>> "WRONG" is about x86 programming language, an sobvious source for
>>>>> such basis
>>>>> is Intel's documentation.
>>>>>
>>>>>>>> Otherwise we could say that for the decimal integers
>>>>>>>> 2 + 3 = 17 and the semantics of arithmetic does not disagree.
>>>>>
>>>>> No, you can only say that you don't know any disageement between them.
>>>>> Without a proof threse is a possibility of an unknown disagreement.
>>>>>
>>>>>>> I can believe you couls but I would not.
>>>>>>>
>>>>>>>> The semantics of arithmetic agrees that for the decimal
>>>>>>>> integers 2 + 3 = 5.
>>>>>>>
>>>>>>> Intel's processors seem to agree, too. But I havn't checked every
>>>>>>> one.
>>>>>>
>>>>>> _DDD()
>>>>>> [00002172] 55 push ebp ; housekeeping
>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>>>> [0000217f] 83c404 add esp,+04
>>>>>> [00002182] 5d pop ebp
>>>>>> [00002183] c3 ret
>>>>>> Size in bytes:(0018) [00002183]
>>>>>>
>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>>> by H0 cannot possibly return.
>>>>>
>>>>> What is shown above does not prove that the call to 15d3 does not
>>>>> return, nor whether there is H0 or HHH0 or something else at that
>>>>> location.
>>>>>
>>>>
>>>> It is stipulated that DDD is correctly emulated by the
>>>> H0 at machine address 000015d2.
>>>
>>> There is no such stipulation in the above text. The C code specifies
>>> and a comment in the machine code claims that H0 is called but don't
>>> say what H0 does.
>>>
>>>> It is stipulated the the correct simulation is ruled by
>>>> the semantics of the x86 programming language.
>>>
>>> That does not fully define "correct simulation" but may specify enough
>>> of it to contradict the previous stipulation.
>>>
>>>> *This conclusively proves*
>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>> by H0 *CANNOT POSSIBLY RETURN*
>>>
>>> It proves nothing if no proof is shown.
>>>
>>
>> I will use your system of reasoning.
>> The semantics of decimal arithmetic prove that 2 + 3 = 5.
>
> You nave not shown the proof.
>
That is a stupid thing to say.
When you try to disagree with arithmetic that proves
you are a troll that wants to infinitely delay any and
all closure at the possible expense of life on Earth.
The same system of reasoning that I use to show how
the input to H0(DD) does not halt.
*Truth preserving operations applied to expressions of*
*language known to be true*
can stop all dangerous lies that can cause the end
of life on Earth and overturn Democracy with Fascism.
The body of formal or natural expressions of language
that are {true on the basis of their verbal meaning}
form a semantic tautology of self-evident truth.
If you disagree that 2 + 3 = 5 then you are an ignoramus
or a 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-27 19:57 -0400 |
| Message-ID | <v5ku9f$1as00$6@i2pn2.org> |
| In reply to | #107933 |
On 6/27/24 1:18 PM, olcott wrote:
> On 6/27/2024 2:02 AM, Mikko wrote:
>> On 2024-06-26 12:25:28 +0000, olcott said:
>>
>>> On 6/26/2024 2:41 AM, Mikko wrote:
>>>> On 2024-06-25 13:29:50 +0000, olcott said:
>>>>
>>>>> On 6/25/2024 4:42 AM, Mikko wrote:
>>>>>> On 2024-06-24 13:52:23 +0000, olcott said:
>>>>>>
>>>>>>> On 6/24/2024 2:31 AM, Mikko wrote:
>>>>>>>> On 2024-06-23 13:25:36 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 6/23/2024 4:50 AM, Mikko wrote:
>>>>>>>>>> On 2024-06-22 19:03:13 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 6/22/2024 1:55 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/22/24 2:49 PM, olcott wrote:
>>>>>>>>>>>>> On 6/22/2024 1:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/22/24 1:29 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/22/2024 12:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 6/22/24 12:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> HHH0(DDD);
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The input to HHH0(DDD) includes itself.
>>>>>>>>>>>>>>>>> The input to HHH1(DDD) DOES NOT include itself.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is stipulated that correct emulation is defined by the
>>>>>>>>>>>>>>>>> semantics of the x86 programming language and nothing
>>>>>>>>>>>>>>>>> else.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And thus, your emulation traces show that your
>>>>>>>>>>>>>>>> "Simulating Halt Deciders" do not do a "Correct Simulation"
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Apparently your ADD preventing you from paying close
>>>>>>>>>>>>>>> attention
>>>>>>>>>>>>>>> to ALL of my words.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Function names adapted to correspond to my updated paper*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> H0(DDD);
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> then we see that when DDD is correctly emulated by H0 that
>>>>>>>>>>>>>>> its call to H0(DDD) cannot possibly return.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since your H0 has never demonstrated that is actually DOES
>>>>>>>>>>>>>> the correct simulation per your stipulation,
>>>>>>>>>>>>>
>>>>>>>>>>>>> Liar
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Then where is it?
>>>>>>>>>>>>
>>>>>>>>>>> When we stipulate that the only measure of a correct emulation
>>>>>>>>>>> is the semantics of the x86 programming language then we see
>>>>>>>>>>> that
>>>>>>>>>>> when DDD is correctly emulated by H0 that its call to H0(DDD)
>>>>>>>>>>> cannot possibly return.
>>>>>>>>>>
>>>>>>>>>> Semantics of the x86 programming language does not specifiy
>>>>>>>>>> emulation
>>>>>>>>>> or correctness of emulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> WRONG!
>>>>>>>>
>>>>>>>> Unless you point where in Intel's documentation emulation or
>>>>>>>> correctness
>>>>>>>> of emulation is specified you have no basis to say "WRONG".
>>>>>>>>
>>>>>>>
>>>>>>> Not at all. That is the same as saying that 2 + 3 = 5
>>>>>>> is wrong until proven by PA.
>>>>>>
>>>>>> If you want to claim that 2 + 3 = 5 you must show some basis for
>>>>>> the claim.
>>>>>> One obvious source of such basis is Peano Arithmetic. Likewise, if
>>>>>> you say
>>>>>> "WRONG" you must show some basis for the claim. When the statement
>>>>>> claimed
>>>>>> "WRONG" is about x86 programming language, an sobvious source for
>>>>>> such basis
>>>>>> is Intel's documentation.
>>>>>>
>>>>>>>>> Otherwise we could say that for the decimal integers
>>>>>>>>> 2 + 3 = 17 and the semantics of arithmetic does not disagree.
>>>>>>
>>>>>> No, you can only say that you don't know any disageement between
>>>>>> them.
>>>>>> Without a proof threse is a possibility of an unknown disagreement.
>>>>>>
>>>>>>>> I can believe you couls but I would not.
>>>>>>>>
>>>>>>>>> The semantics of arithmetic agrees that for the decimal
>>>>>>>>> integers 2 + 3 = 5.
>>>>>>>>
>>>>>>>> Intel's processors seem to agree, too. But I havn't checked
>>>>>>>> every one.
>>>>>>>
>>>>>>> _DDD()
>>>>>>> [00002172] 55 push ebp ; housekeeping
>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>>>>> [0000217f] 83c404 add esp,+04
>>>>>>> [00002182] 5d pop ebp
>>>>>>> [00002183] c3 ret
>>>>>>> Size in bytes:(0018) [00002183]
>>>>>>>
>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>>>> by H0 cannot possibly return.
>>>>>>
>>>>>> What is shown above does not prove that the call to 15d3 does not
>>>>>> return, nor whether there is H0 or HHH0 or something else at that
>>>>>> location.
>>>>>>
>>>>>
>>>>> It is stipulated that DDD is correctly emulated by the
>>>>> H0 at machine address 000015d2.
>>>>
>>>> There is no such stipulation in the above text. The C code specifies
>>>> and a comment in the machine code claims that H0 is called but don't
>>>> say what H0 does.
>>>>
>>>>> It is stipulated the the correct simulation is ruled by
>>>>> the semantics of the x86 programming language.
>>>>
>>>> That does not fully define "correct simulation" but may specify enough
>>>> of it to contradict the previous stipulation.
>>>>
>>>>> *This conclusively proves*
>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>> by H0 *CANNOT POSSIBLY RETURN*
>>>>
>>>> It proves nothing if no proof is shown.
>>>>
>>>
>>> I will use your system of reasoning.
>>> The semantics of decimal arithmetic prove that 2 + 3 = 5.
>>
>> You nave not shown the proof.
>>
>
> That is a stupid thing to say.
Why? because it is true that you haven't shown an actual formal proof,
just arguments.
> When you try to disagree with arithmetic that proves
> you are a troll that wants to infinitely delay any and
> all closure at the possible expense of life on Earth.
>
> The same system of reasoning that I use to show how
> the input to H0(DD) does not halt.
Except for arithmetic there are standard proofs that most people in the
field know.
You haven't shown one for your claim.
>
> *Truth preserving operations applied to expressions of*
> *language known to be true*
Right, so were are they?
>
> can stop all dangerous lies that can cause the end
> of life on Earth and overturn Democracy with Fascism.
>
> The body of formal or natural expressions of language
> that are {true on the basis of their verbal meaning}
> form a semantic tautology of self-evident truth.
But in FORMAL SYSTEMS, the only definitions you can use are those
defined in the system.
>
> If you disagree that 2 + 3 = 5 then you are an ignoramus
> or a liar.
>
Right, and if you disagree that since H(P,P) returns 0 that P(P) Halts
and thus H is not a correct Halt Decider, YOU are a liar.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-28 11:55 +0300 |
| Message-ID | <v5ltqp$394ns$1@dont-email.me> |
| In reply to | #107933 |
On 2024-06-27 17:18:23 +0000, olcott said:
> On 6/27/2024 2:02 AM, Mikko wrote:
>> On 2024-06-26 12:25:28 +0000, olcott said:
>>
>>> On 6/26/2024 2:41 AM, Mikko wrote:
>>>> On 2024-06-25 13:29:50 +0000, olcott said:
>>>>
>>>>> On 6/25/2024 4:42 AM, Mikko wrote:
>>>>>> On 2024-06-24 13:52:23 +0000, olcott said:
>>>>>>
>>>>>>> On 6/24/2024 2:31 AM, Mikko wrote:
>>>>>>>> On 2024-06-23 13:25:36 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 6/23/2024 4:50 AM, Mikko wrote:
>>>>>>>>>> On 2024-06-22 19:03:13 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 6/22/2024 1:55 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/22/24 2:49 PM, olcott wrote:
>>>>>>>>>>>>> On 6/22/2024 1:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/22/24 1:29 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/22/2024 12:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 6/22/24 12:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> HHH0(DDD);
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The input to HHH0(DDD) includes itself.
>>>>>>>>>>>>>>>>> The input to HHH1(DDD) DOES NOT include itself.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is stipulated that correct emulation is defined by the
>>>>>>>>>>>>>>>>> semantics of the x86 programming language and nothing else.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And thus, your emulation traces show that your "Simulating Halt
>>>>>>>>>>>>>>>> Deciders" do not do a "Correct Simulation"
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Apparently your ADD preventing you from paying close attention
>>>>>>>>>>>>>>> to ALL of my words.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Function names adapted to correspond to my updated paper*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> H0(DDD);
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *When we stipulate that the only measure of a correct*
>>>>>>>>>>>>>>> *emulation is the semantics of the x86 programming language*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> then we see that when DDD is correctly emulated by H0 that
>>>>>>>>>>>>>>> its call to H0(DDD) cannot possibly return.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since your H0 has never demonstrated that is actually DOES the correct
>>>>>>>>>>>>>> simulation per your stipulation,
>>>>>>>>>>>>>
>>>>>>>>>>>>> Liar
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Then where is it?
>>>>>>>>>>>>
>>>>>>>>>>> When we stipulate that the only measure of a correct emulation
>>>>>>>>>>> is the semantics of the x86 programming language then we see that
>>>>>>>>>>> when DDD is correctly emulated by H0 that its call to H0(DDD)
>>>>>>>>>>> cannot possibly return.
>>>>>>>>>>
>>>>>>>>>> Semantics of the x86 programming language does not specifiy emulation
>>>>>>>>>> or correctness of emulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> WRONG!
>>>>>>>>
>>>>>>>> Unless you point where in Intel's documentation emulation or correctness
>>>>>>>> of emulation is specified you have no basis to say "WRONG".
>>>>>>>>
>>>>>>>
>>>>>>> Not at all. That is the same as saying that 2 + 3 = 5
>>>>>>> is wrong until proven by PA.
>>>>>>
>>>>>> If you want to claim that 2 + 3 = 5 you must show some basis for the claim.
>>>>>> One obvious source of such basis is Peano Arithmetic. Likewise, if you say
>>>>>> "WRONG" you must show some basis for the claim. When the statement claimed
>>>>>> "WRONG" is about x86 programming language, an sobvious source for such basis
>>>>>> is Intel's documentation.
>>>>>>
>>>>>>>>> Otherwise we could say that for the decimal integers
>>>>>>>>> 2 + 3 = 17 and the semantics of arithmetic does not disagree.
>>>>>>
>>>>>> No, you can only say that you don't know any disageement between them.
>>>>>> Without a proof threse is a possibility of an unknown disagreement.
>>>>>>
>>>>>>>> I can believe you couls but I would not.
>>>>>>>>
>>>>>>>>> The semantics of arithmetic agrees that for the decimal
>>>>>>>>> integers 2 + 3 = 5.
>>>>>>>>
>>>>>>>> Intel's processors seem to agree, too. But I havn't checked every one.
>>>>>>>
>>>>>>> _DDD()
>>>>>>> [00002172] 55 push ebp ; housekeeping
>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call H0(DDD)
>>>>>>> [0000217f] 83c404 add esp,+04
>>>>>>> [00002182] 5d pop ebp
>>>>>>> [00002183] c3 ret
>>>>>>> Size in bytes:(0018) [00002183]
>>>>>>>
>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>>>> by H0 cannot possibly return.
>>>>>>
>>>>>> What is shown above does not prove that the call to 15d3 does not
>>>>>> return, nor whether there is H0 or HHH0 or something else at that
>>>>>> location.
>>>>>>
>>>>>
>>>>> It is stipulated that DDD is correctly emulated by the
>>>>> H0 at machine address 000015d2.
>>>>
>>>> There is no such stipulation in the above text. The C code specifies
>>>> and a comment in the machine code claims that H0 is called but don't
>>>> say what H0 does.
>>>>
>>>>> It is stipulated the the correct simulation is ruled by
>>>>> the semantics of the x86 programming language.
>>>>
>>>> That does not fully define "correct simulation" but may specify enough
>>>> of it to contradict the previous stipulation.
>>>>
>>>>> *This conclusively proves*
>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>> by H0 *CANNOT POSSIBLY RETURN*
>>>>
>>>> It proves nothing if no proof is shown.
>>>>
>>>
>>> I will use your system of reasoning.
>>> The semantics of decimal arithmetic prove that 2 + 3 = 5.
>>
>> You nave not shown the proof.
>
> That is a stupid thing to say.
No, it is not. Sometimes it is important to say the obvious. Of course,
other things should be said, too, though not necessarily at the same time.
> When you try to disagree with arithmetic that proves
> you are a troll that wants to infinitely delay any and
> all closure at the possible expense of life on Earth.
That "when" refers to 'never'.
> The same system of reasoning that I use to show how
> the input to H0(DD) does not halt.
True, but your reasoning is not good enough for serious use.
> *Truth preserving operations applied to expressions of*
> *language known to be true*
Yes, as long as you don't provide that you have proven nothing.
> can stop all dangerous lies that can cause the end
> of life on Earth and overturn Democracy with Fascism.
No, they can't. But they can help to figure out whom to trust.
> The body of formal or natural expressions of language
> that are {true on the basis of their verbal meaning}
> form a semantic tautology of self-evident truth.
Which is not very helpful.
> If you disagree that 2 + 3 = 5 then you are an ignoramus
> or a liar.
That is a big if. But I know there are people who disagree with
proven truths.
--
Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-28 09:54 -0500 |
| Message-ID | <v5miqm$3cibm$2@dont-email.me> |
| In reply to | #107951 |
On 6/28/2024 3:55 AM, Mikko wrote:
> On 2024-06-27 17:18:23 +0000, olcott said:
>
>> On 6/27/2024 2:02 AM, Mikko wrote:
>>> On 2024-06-26 12:25:28 +0000, olcott said:
>>>
>>>>
>>>> I will use your system of reasoning.
>>>> The semantics of decimal arithmetic prove that 2 + 3 = 5.
>>>
>>> You nave not shown the proof.
>>
>> That is a stupid thing to say.
>
The details of common knowledge of self-evident truth
are never required to be provided, not even in patents.
When I say that this is proven by the semantics of the
x86 language then the entire semantics of the x86 language
is incorporated by reference.
> No, it is not. Sometimes it is important to say the obvious. Of course,
> other things should be said, too, though not necessarily at the same time.
>
>> When you try to disagree with arithmetic that proves
>> you are a troll that wants to infinitely delay any and
>> all closure at the possible expense of life on Earth.
>
> That "when" refers to 'never'.
>
You just did do this:
>>> You nave (typo for "have") not shown the proof.
>> The same system of reasoning that I use to show how
>> the input to H0(DD) does not halt.
>
> True, but your reasoning is not good enough for serious use.
>
We could say that this is true:
2 + 3 = 5 and get into an infinite debate about
exactly what the English word "this" means.
A dishonest deflection like Trump did on two key
questions last night. He also flat out lied in
most of his answers.
>> *Truth preserving operations applied to expressions of*
>> *language known to be true*
>
> Yes, as long as you don't provide that you have proven nothing.
>
If you don't sufficiently understand the x86 language then
we can stop right here. If you do then it is self-evident
that I am correct.
>> can stop all dangerous lies that can cause the end
>> of life on Earth and overturn Democracy with Fascism.
>
> No, they can't. But they can help to figure out whom to trust.
>
That human caused climate change is having drastic impact
on the climate is proven by verified facts
https://www.researchgate.net/publication/336568434_Severe_anthropogenic_climate_change_proven_entirely_with_verifiable_facts
People disagreeing are damned liars in that they have condemned
themselves to actual Hell if such a place exists.
>> The body of formal or natural expressions of language
>> that are {true on the basis of their verbal meaning}
>> form a semantic tautology of self-evident truth.
>
> Which is not very helpful.
>
It is the actual foundation of True(L,x) in my redefinition
of the analytic side of the analytic/synthetic distinction.
*True and unprovable has always been ridiculous nonsense*
True and provable in meta-mathematics corresponds to
untrue and unprovable in PA.
https://www.liarparadox.org/Wittgenstein.pdf
>> If you disagree that 2 + 3 = 5 then you are an ignoramus
>> or a liar.
>
> That is a big if. But I know there are people who disagree with
> proven truths.
>
Disagreeing with expressions that are
{true on the basis of their verbal meaning} that are proven
true on the basis of a sequence of truth preserving operations
from their verbal meaning cannot possibly be anything besides
incorrect.
The problem of induction prevents the same degree of logically
justified certainty for empirical knowledge.
--
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 |
| Message-ID | <v5o085$1eli4$1@i2pn2.org> |
| In reply to | #107965 |
On 6/28/24 10:54 AM, olcott wrote:
> On 6/28/2024 3:55 AM, Mikko wrote:
>> On 2024-06-27 17:18:23 +0000, olcott said:
>>
>>> On 6/27/2024 2:02 AM, Mikko wrote:
>>>> On 2024-06-26 12:25:28 +0000, olcott said:
>>>>
>>>>>
>>>>> I will use your system of reasoning.
>>>>> The semantics of decimal arithmetic prove that 2 + 3 = 5.
>>>>
>>>> You nave not shown the proof.
>>>
>>> That is a stupid thing to say.
>>
>
> The details of common knowledge of self-evident truth
> are never required to be provided, not even in patents.
But that isn't part of Forma Logic.
>
> When I say that this is proven by the semantics of the
> x86 language then the entire semantics of the x86 language
> is incorporated by reference.
And thus, stopping in the middle of the exectution is NOT allowed, so
your emulatios that return are not "Correct Emulators"
>
>> No, it is not. Sometimes it is important to say the obvious. Of course,
>> other things should be said, too, though not necessarily at the same
>> time.
>>
>>> When you try to disagree with arithmetic that proves
>>> you are a troll that wants to infinitely delay any and
>>> all closure at the possible expense of life on Earth.
>>
>> That "when" refers to 'never'.
>>
>
> You just did do this:
> >>> You nave (typo for "have") not shown the proof.
Yes, you have NEVER shown a proof for any of your major claims, I think
because you don;t understand how to do a proof.
>
>>> The same system of reasoning that I use to show how
>>> the input to H0(DD) does not halt.
>>
>> True, but your reasoning is not good enough for serious use.
>>
> We could say that this is true:
> 2 + 3 = 5 and get into an infinite debate about
> exactly what the English word "this" means.
>
> A dishonest deflection like Trump did on two key
> questions last night. He also flat out lied in
> most of his answers.
As is your deflection that we could get into a long diversion on the
meaning of "this".
2 + 3 = 5 is easily provable by someone who understand the basic
principles of number theory.
YOU can't prove your claims, because you don't understand the basic of
Computation theory.
>
>>> *Truth preserving operations applied to expressions of*
>>> *language known to be true*
>>
>> Yes, as long as you don't provide that you have proven nothing.
>>
>
> If you don't sufficiently understand the x86 language then
> we can stop right here. If you do then it is self-evident
> that I am correct.
And it seems you don't either, due to your incorerct claims about it.
>
>>> can stop all dangerous lies that can cause the end
>>> of life on Earth and overturn Democracy with Fascism.
>>
>> No, they can't. But they can help to figure out whom to trust.
>>
> That human caused climate change is having drastic impact
> on the climate is proven by verified facts
>
> https://www.researchgate.net/publication/336568434_Severe_anthropogenic_climate_change_proven_entirely_with_verifiable_facts
>
> People disagreeing are damned liars in that they have condemned
> themselves to actual Hell if such a place exists.
Just like YOU are a damned liar for saying that Halting is computable,
and using the same techniques as the climate deniers to try to claim it.
>
>>> The body of formal or natural expressions of language
>>> that are {true on the basis of their verbal meaning}
>>> form a semantic tautology of self-evident truth.
>>
>> Which is not very helpful.
>>
> It is the actual foundation of True(L,x) in my redefinition
> of the analytic side of the analytic/synthetic distinction.
> *True and unprovable has always been ridiculous nonsense*
Yes, you have "redefined" the meaning of truth, but refuse to see that
this mean you have to start you logic system from your new definition
and show what that can do.
To try to just change an existing system, just makes you a LIAR.
>
> True and provable in meta-mathematics corresponds to
> untrue and unprovable in PA.
> https://www.liarparadox.org/Wittgenstein.pdf
Silly thing to say, that True <-> unTrue and Provable <-> unprovable.
Sounds like someone is on something.
Note, you claim shows up NO WHERE in the page you cite.
>
>>> If you disagree that 2 + 3 = 5 then you are an ignoramus
>>> or a liar.
>>
>> That is a big if. But I know there are people who disagree with
>> proven truths.
>>
>
> Disagreeing with expressions that are
> {true on the basis of their verbal meaning} that are proven
> true on the basis of a sequence of truth preserving operations
> from their verbal meaning cannot possibly be anything besides
> incorrect.
>
> The problem of induction prevents the same degree of logically
> justified certainty for empirical knowledge.
>
Nope, you just don't understand what you are talking about.
Note, "Formal Systems" only have in them the meanings put into them by
their defintions. Trying to use meanings not in the system, is just LYING.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-29 10:44 +0300 |
| Message-ID | <v5oe19$3quod$1@dont-email.me> |
| In reply to | #107965 |
On 2024-06-28 14:54:14 +0000, olcott said: > On 6/28/2024 3:55 AM, Mikko wrote: >> On 2024-06-27 17:18:23 +0000, olcott said: >> >>> On 6/27/2024 2:02 AM, Mikko wrote: >>>> On 2024-06-26 12:25:28 +0000, olcott said: >>>> >>>>> >>>>> I will use your system of reasoning. >>>>> The semantics of decimal arithmetic prove that 2 + 3 = 5. >>>> >>>> You nave not shown the proof. >>> >>> That is a stupid thing to say. >> > > The details of common knowledge of self-evident truth > are never required to be provided, not even in patents. What is regarded as common knowledge depends on the target audience. It also depends on what you agree. In comp.theory you can regrard all commonly used textbooks on computation theory as common knowledge as long as you agree with everyting they say. > When I say that this is proven by the semantics of the > x86 language then the entire semantics of the x86 language > is incorporated by reference. The x86 semantics is not common knowledge in comp.theory. Claims about x86 semantics need not be accepted as truth unless supported by a pointer to the relevant point in Intel's documentation. >> No, it is not. Sometimes it is important to say the obvious. Of course, >> other things should be said, too, though not necessarily at the same time. >> >>> When you try to disagree with arithmetic that proves >>> you are a troll that wants to infinitely delay any and >>> all closure at the possible expense of life on Earth. >> >> That "when" refers to 'never'. >> > > You just did do this: > >>> You nave (typo for "have") not shown the proof. Thanks. Fortunately you got the intended meaning. >>> The same system of reasoning that I use to show how >>> the input to H0(DD) does not halt. >> >> True, but your reasoning is not good enough for serious use. >> > We could say that this is true: > 2 + 3 = 5 and get into an infinite debate about > exactly what the English word "this" means. Indeed we could. Though people who prefer to talk about details of English semantics usually prefer less mathematical examples. > A dishonest deflection like Trump did on two key > questions last night. He also flat out lied in > most of his answers. He has a good knowledge about the claims voters want to hear and how much they care abotu truth. >>> *Truth preserving operations applied to expressions of* >>> *language known to be true* >> >> Yes, as long as you don't provide that you have proven nothing. > > If you don't sufficiently understand the x86 language then > we can stop right here. Yes, we can stay here until you prove something. -- Mikko
[toc] | [prev] | [next] | [standalone]
| From | joes <noreply@example.com> |
|---|---|
| Date | 2024-06-25 20:41 +0000 |
| Message-ID | <v5fa29$134dk$4@i2pn2.org> |
| In reply to | #107628 |
Am Sat, 22 Jun 2024 11:18:07 -0500 schrieb olcott: > On 6/22/2024 11:03 AM, joes wrote: >> Am Sat, 22 Jun 2024 10:16:18 -0500 schrieb olcott: >>> On 6/22/2024 9:42 AM, Richard Damon wrote: >>>> On 6/22/24 10:31 AM, olcott wrote: >>> The input to HHH0(DDD) includes itself. >>> The input to HHH1(DDD) DOES NOT include itself. >> Yes, both include HHH0. The second case is boring. Suppose DDD1 only called HHH1. How would HHH1 simulate it? > The fact that DDD calls HHH0(DDD) and does not call HHH1(DDD) changes > the behavior of DDD correctly emulated by HHH0 relative to DDD correctly > emulated by HHH1. DDD does not change behaviour depending on its simulator, that is an error on the part of the simulator. -- 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-25 16:24 -0500 |
| Message-ID | <v5fcii$1nsua$2@dont-email.me> |
| In reply to | #107813 |
On 6/25/2024 3:41 PM, joes wrote: > Am Sat, 22 Jun 2024 11:18:07 -0500 schrieb olcott: >> On 6/22/2024 11:03 AM, joes wrote: >>> Am Sat, 22 Jun 2024 10:16:18 -0500 schrieb olcott: >>>> On 6/22/2024 9:42 AM, Richard Damon wrote: >>>>> On 6/22/24 10:31 AM, olcott wrote: > >>>> The input to HHH0(DDD) includes itself. >>>> The input to HHH1(DDD) DOES NOT include itself. >>> Yes, both include HHH0. The second case is boring. > Suppose DDD1 only called HHH1. How would HHH1 simulate it? > >> The fact that DDD calls HHH0(DDD) and does not call HHH1(DDD) changes >> the behavior of DDD correctly emulated by HHH0 relative to DDD correctly >> emulated by HHH1. > DDD does not change behaviour depending on its simulator, that is an > error on the part of the simulator. > No dumbo that is not it. The input that calls its own simulator defines different behavior than when it is simulated by a different simulator. -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-25 21:47 -0400 |
| Message-ID | <v5frvf$14bcm$2@i2pn2.org> |
| In reply to | #107816 |
On 6/25/24 5:24 PM, olcott wrote: > On 6/25/2024 3:41 PM, joes wrote: >> Am Sat, 22 Jun 2024 11:18:07 -0500 schrieb olcott: >>> On 6/22/2024 11:03 AM, joes wrote: >>>> Am Sat, 22 Jun 2024 10:16:18 -0500 schrieb olcott: >>>>> On 6/22/2024 9:42 AM, Richard Damon wrote: >>>>>> On 6/22/24 10:31 AM, olcott wrote: >> >>>>> The input to HHH0(DDD) includes itself. >>>>> The input to HHH1(DDD) DOES NOT include itself. >>>> Yes, both include HHH0. The second case is boring. >> Suppose DDD1 only called HHH1. How would HHH1 simulate it? >> >>> The fact that DDD calls HHH0(DDD) and does not call HHH1(DDD) changes >>> the behavior of DDD correctly emulated by HHH0 relative to DDD correctly >>> emulated by HHH1. >> DDD does not change behaviour depending on its simulator, that is an >> error on the part of the simulator. >> > > No dumbo that is not it. > The input that calls its own simulator defines different > behavior than when it is simulated by a different simulator. > And where does the behavior differ? It shows the EXACT SAME BEHAVIOR up to the point it is aborted, and partial simulation do not show behavior after the point of aborting. Both show that HHH0 did not return to DDD for the period that HHH0 simulated it. HHH1 shows that it will later. That is not DIFFERENT behavior, but a fuller description of the behavior.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-26 10:46 +0300 |
| Message-ID | <v5gh15$21pcr$1@dont-email.me> |
| In reply to | #107816 |
On 2024-06-25 21:24:34 +0000, olcott said: > On 6/25/2024 3:41 PM, joes wrote: >> Am Sat, 22 Jun 2024 11:18:07 -0500 schrieb olcott: >>> On 6/22/2024 11:03 AM, joes wrote: >>>> Am Sat, 22 Jun 2024 10:16:18 -0500 schrieb olcott: >>>>> On 6/22/2024 9:42 AM, Richard Damon wrote: >>>>>> On 6/22/24 10:31 AM, olcott wrote: >> >>>>> The input to HHH0(DDD) includes itself. >>>>> The input to HHH1(DDD) DOES NOT include itself. >>>> Yes, both include HHH0. The second case is boring. >> Suppose DDD1 only called HHH1. How would HHH1 simulate it? >> >>> The fact that DDD calls HHH0(DDD) and does not call HHH1(DDD) changes >>> the behavior of DDD correctly emulated by HHH0 relative to DDD correctly >>> emulated by HHH1. >> DDD does not change behaviour depending on its simulator, that is an >> error on the part of the simulator. >> > > No dumbo that is not it. > The input that calls its own simulator defines different > behavior than when it is simulated by a different simulator. The only correct interpretation of the input is the interpretation specified by the problem statement. If your program interpretes it differently then its interpretation is wrong. -- Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-26 07:45 -0500 |
| Message-ID | <v5h2i4$24jbd$2@dont-email.me> |
| In reply to | #107843 |
On 6/26/2024 2:46 AM, Mikko wrote: > On 2024-06-25 21:24:34 +0000, olcott said: > >> On 6/25/2024 3:41 PM, joes wrote: >>> Am Sat, 22 Jun 2024 11:18:07 -0500 schrieb olcott: >>>> On 6/22/2024 11:03 AM, joes wrote: >>>>> Am Sat, 22 Jun 2024 10:16:18 -0500 schrieb olcott: >>>>>> On 6/22/2024 9:42 AM, Richard Damon wrote: >>>>>>> On 6/22/24 10:31 AM, olcott wrote: >>> >>>>>> The input to HHH0(DDD) includes itself. >>>>>> The input to HHH1(DDD) DOES NOT include itself. >>>>> Yes, both include HHH0. The second case is boring. >>> Suppose DDD1 only called HHH1. How would HHH1 simulate it? >>> >>>> The fact that DDD calls HHH0(DDD) and does not call HHH1(DDD) changes >>>> the behavior of DDD correctly emulated by HHH0 relative to DDD >>>> correctly >>>> emulated by HHH1. >>> DDD does not change behaviour depending on its simulator, that is an >>> error on the part of the simulator. >>> >> >> No dumbo that is not it. >> The input that calls its own simulator defines different >> behavior than when it is simulated by a different simulator. > > The only correct interpretation of the input is the interpretation > specified by the problem statement. In other words you believe that the you have the power to overrule the semantics of the x86 language. That is a ridiculously stupid thing to say. > If your program interpretes it > differently then its interpretation is wrong. > If that was not a flat out lie then you could show the detailed steps of how this is false. Exactly how does an x86 emulator at machine address 000015d2 emulate DDD such that the call from DDD to H0(DDD) returns? _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] So far no one has ever provided these details because they know that they are lying. -- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <richard@damon-family.org> |
|---|---|
| Date | 2024-06-26 19:41 -0400 |
| Message-ID | <v5i8vs$17ej1$5@i2pn2.org> |
| In reply to | #107854 |
On 6/26/24 8:45 AM, olcott wrote:
> On 6/26/2024 2:46 AM, Mikko wrote:
>> On 2024-06-25 21:24:34 +0000, olcott said:
>>
>>> On 6/25/2024 3:41 PM, joes wrote:
>>>> Am Sat, 22 Jun 2024 11:18:07 -0500 schrieb olcott:
>>>>> On 6/22/2024 11:03 AM, joes wrote:
>>>>>> Am Sat, 22 Jun 2024 10:16:18 -0500 schrieb olcott:
>>>>>>> On 6/22/2024 9:42 AM, Richard Damon wrote:
>>>>>>>> On 6/22/24 10:31 AM, olcott wrote:
>>>>
>>>>>>> The input to HHH0(DDD) includes itself.
>>>>>>> The input to HHH1(DDD) DOES NOT include itself.
>>>>>> Yes, both include HHH0. The second case is boring.
>>>> Suppose DDD1 only called HHH1. How would HHH1 simulate it?
>>>>
>>>>> The fact that DDD calls HHH0(DDD) and does not call HHH1(DDD) changes
>>>>> the behavior of DDD correctly emulated by HHH0 relative to DDD
>>>>> correctly
>>>>> emulated by HHH1.
>>>> DDD does not change behaviour depending on its simulator, that is an
>>>> error on the part of the simulator.
>>>>
>>>
>>> No dumbo that is not it.
>>> The input that calls its own simulator defines different
>>> behavior than when it is simulated by a different simulator.
>>
>> The only correct interpretation of the input is the interpretation
>> specified by the problem statement.
>
> In other words you believe that the you have the power to
> overrule the semantics of the x86 language.
>
Which says that execution, and thus correct emulation continue to a
final state is reached.
> That is a ridiculously stupid thing to say.
Yes, that an aborted emulation is "correct" (vs incomplete) is just a
rediculously stupid thing to say.
>
>> If your program interpretes it
>> differently then its interpretation is wrong.
>>
>
> If that was not a flat out lie then you could show
> the detailed steps of how this is false.
That would be something you would say.
So, if your emulation doesn't exactly match the behavior defined by the
code being emulated, that ISN'T an "incorrect results".
You are just proving that your logic is based on the right to assert lies.
>
> Exactly how does an x86 emulator at machine address 000015d2
> emulate DDD such that the call from DDD to H0(DDD) returns?
>
If the emulator begins with:
int H0(ptr addr) {
static int flag = 0;
if (flag) return 0;
flag = 1;
...
Then it can. Nothing you have said in these posts contradict that behavior..
> _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]
>
> So far no one has ever provided these details because
> they know that they are lying.
No, we have, you just refuse to see because it shows how ignorant you
are of what you talk about.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2024-06-27 10:06 +0300 |
| Message-ID | <v5j31q$2khqo$1@dont-email.me> |
| In reply to | #107854 |
On 2024-06-26 12:45:56 +0000, olcott said: > On 6/26/2024 2:46 AM, Mikko wrote: >> On 2024-06-25 21:24:34 +0000, olcott said: >> >>> On 6/25/2024 3:41 PM, joes wrote: >>>> Am Sat, 22 Jun 2024 11:18:07 -0500 schrieb olcott: >>>>> On 6/22/2024 11:03 AM, joes wrote: >>>>>> Am Sat, 22 Jun 2024 10:16:18 -0500 schrieb olcott: >>>>>>> On 6/22/2024 9:42 AM, Richard Damon wrote: >>>>>>>> On 6/22/24 10:31 AM, olcott wrote: >>>> >>>>>>> The input to HHH0(DDD) includes itself. >>>>>>> The input to HHH1(DDD) DOES NOT include itself. >>>>>> Yes, both include HHH0. The second case is boring. >>>> Suppose DDD1 only called HHH1. How would HHH1 simulate it? >>>> >>>>> The fact that DDD calls HHH0(DDD) and does not call HHH1(DDD) changes >>>>> the behavior of DDD correctly emulated by HHH0 relative to DDD correctly >>>>> emulated by HHH1. >>>> DDD does not change behaviour depending on its simulator, that is an >>>> error on the part of the simulator. >>>> >>> >>> No dumbo that is not it. >>> The input that calls its own simulator defines different >>> behavior than when it is simulated by a different simulator. >> >> The only correct interpretation of the input is the interpretation >> specified by the problem statement. > > In other words you believe that the you have the power to > overrule the semantics of the x86 language. That is just your lie. The supreme authority on a problem is the problem statement. -- Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott333@gmail.com> |
|---|---|
| Date | 2024-06-27 14:19 -0500 |
| Message-ID | <v5kdvu$2rv8r$1@dont-email.me> |
| In reply to | #107918 |
On 6/27/2024 2:06 AM, Mikko wrote: > On 2024-06-26 12:45:56 +0000, olcott said: > >> On 6/26/2024 2:46 AM, Mikko wrote: >>> On 2024-06-25 21:24:34 +0000, olcott said: >>> >>>> On 6/25/2024 3:41 PM, joes wrote: >>>>> Am Sat, 22 Jun 2024 11:18:07 -0500 schrieb olcott: >>>>>> On 6/22/2024 11:03 AM, joes wrote: >>>>>>> Am Sat, 22 Jun 2024 10:16:18 -0500 schrieb olcott: >>>>>>>> On 6/22/2024 9:42 AM, Richard Damon wrote: >>>>>>>>> On 6/22/24 10:31 AM, olcott wrote: >>>>> >>>>>>>> The input to HHH0(DDD) includes itself. >>>>>>>> The input to HHH1(DDD) DOES NOT include itself. >>>>>>> Yes, both include HHH0. The second case is boring. >>>>> Suppose DDD1 only called HHH1. How would HHH1 simulate it? >>>>> >>>>>> The fact that DDD calls HHH0(DDD) and does not call HHH1(DDD) changes >>>>>> the behavior of DDD correctly emulated by HHH0 relative to DDD >>>>>> correctly >>>>>> emulated by HHH1. >>>>> DDD does not change behaviour depending on its simulator, that is an >>>>> error on the part of the simulator. >>>>> >>>> >>>> No dumbo that is not it. >>>> The input that calls its own simulator defines different >>>> behavior than when it is simulated by a different simulator. >>> >>> The only correct interpretation of the input is the interpretation >>> specified by the problem statement. >> >> In other words you believe that the you have the power to >> overrule the semantics of the x86 language. > > That is just your lie. The supreme authority on a problem is the problem > statement. > The supreme authority on whether DDD correctly simulated by H0 can halt is the x86 programming language. _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] -- 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 3 of 5 — ← Prev page 1 2 [3] 4 5 Next page →
Back to top | Article view | comp.theory
csiph-web