Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.theory > #107616 > unrolled thread

Why do people here insist on denying these verified facts?

Back to article view | Back to comp.theory

Contents

  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 4 of 5 — ← Prev page 1 2 3 [4] 5  Next page →

#107848

Am Tue, 25 Jun 2024 16:24:34 -0500 schrieb olcott:
> 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:

>> 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.
Those are different DDD's. All HHH's should give the same result.

>> DDD does not change behaviour depending on its simulator, that is an
>> error on the part of the simulator.
> The input that calls its own simulator defines different behavior than
> when it is simulated by a different simulator.
It's the other way around: the simulator that DDD calls can't simulate it.
Other simulators give the same result as when run directly. The behaviour
of DDD is fixed.
Every simulator running a program that calls that same simulator
makes a mistake.

-- 
Man kann mit dunklen Zahlen nicht rechnen. Für die eigentliche Mathematik 
sind sie vollkommen nutzlos. --Wolfgang Mückenheim

[toc] | [prev] | [next] | [standalone]

#107665

When the head line has the words "these verified facts" the message should
first tell what facts are "these verified facts" and who verified them
before any further discussion.

What Professor Sipser has verfied below is not a fact but a criterion.

On 2024-06-22 14:31:45 +0000, olcott said:

> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X/ 
> 
> 
> To understand this analysis requires a sufficient knowledge of
> the C programming language and what an x86 emulator does. HHH0
> and HHH1 have this criteria as their algorithm:
> 
> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>    If simulating halt decider H correctly simulates its input D
>    until H correctly determines that its simulated D would never
>    stop running unless aborted then
> 
>    H can abort its simulation of D and correctly report that D
>    specifies a non-halting sequence of configurations.
> </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
  ...

-- 
Mikko

[toc] | [prev] | [next] | [standalone]

#107673

On 6/23/2024 4:42 AM, Mikko wrote:
> When the head line has the words "these verified facts" the message should
> first tell what facts are "these verified facts" and who verified them
> before any further discussion.
> 

It is a verified fact that 2 + 3 = 5 according to the semantics
of arithmetic. Anyone having an opinion that contradicts this is WRONG.

_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]

It is a verified fact that the call from DDD to H0(DDD)
cannot possibly return to DDD correctly emulated by H0
according to the semantics of the x86 language.
Anyone having an opinion that contradicts this is WRONG.

> What Professor Sipser has verfied below is not a fact but a criterion.
> 

It is a verified fact that professor Sipser agreed with my
verbatim words.

> On 2024-06-22 14:31:45 +0000, olcott said:
> 
>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X/
>>
>> To understand this analysis requires a sufficient knowledge of
>> the C programming language and what an x86 emulator does. HHH0
>> and HHH1 have this criteria as their algorithm:
>>
>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>    If simulating halt decider H correctly simulates its input D
>>    until H correctly determines that its simulated D would never
>>    stop running unless aborted then
>>
>>    H can abort its simulation of D and correctly report that D
>>    specifies a non-halting sequence of configurations.
>> </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>   ...
> 

-- 
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]

#107716

On 2024-06-23 13:23:10 +0000, olcott said:

> On 6/23/2024 4:42 AM, Mikko wrote:
>> When the head line has the words "these verified facts" the message should
>> first tell what facts are "these verified facts" and who verified them
>> before any further discussion.
>> 
> 
> It is a verified fact that 2 + 3 = 5 according to the semantics
> of arithmetic. Anyone having an opinion that contradicts this is WRONG.

Sure, but that was not the first thing mentioned in the initial message.

-- 
Mikko

[toc] | [prev] | [next] | [standalone]

#107724

On 6/24/2024 2:32 AM, Mikko wrote:
> On 2024-06-23 13:23:10 +0000, olcott said:
> 
>> On 6/23/2024 4:42 AM, Mikko wrote:
>>> When the head line has the words "these verified facts" the message 
>>> should
>>> first tell what facts are "these verified facts" and who verified them
>>> before any further discussion.
>>>
>>
>> It is a verified fact that 2 + 3 = 5 according to the semantics
>> of arithmetic. Anyone having an opinion that contradicts this is WRONG.
> 
> Sure, but that was not the first thing mentioned in the initial message.
> 


int P(ptr2 x)
{
   int Halt_Status = H(x, x);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

The call from P to H(P,P) when P is correctly emulated
by H cannot possibly return.

The call from P to H(P,P) when P is correctly emulated
by H1 DOES return.


-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[toc] | [prev] | [next] | [standalone]

#107726

On 24/06/24 15:50, olcott wrote:
> On 6/24/2024 2:32 AM, Mikko wrote:
>> On 2024-06-23 13:23:10 +0000, olcott said:
>>
>>> On 6/23/2024 4:42 AM, Mikko wrote:
>>>> When the head line has the words "these verified facts" the message 
>>>> should
>>>> first tell what facts are "these verified facts" and who verified them
>>>> before any further discussion.
>>>>
>>>
>>> It is a verified fact that 2 + 3 = 5 according to the semantics
>>> of arithmetic. Anyone having an opinion that contradicts this is WRONG.
>>
>> Sure, but that was not the first thing mentioned in the initial message.
>>
> 
> 
> int P(ptr2 x)
> {
>    int Halt_Status = H(x, x);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
> 
> The call from P to H(P,P) when P is correctly emulated
> by H cannot possibly return.
> 
> The call from P to H(P,P) when P is correctly emulated
> by H1 DOES return.
> 
> 

Verified fact: the emulation is incorrect

[toc] | [prev] | [next] | [standalone]

#107781

On 2024-06-24 14:03:12 +0000, immibis said:

> On 24/06/24 15:50, olcott wrote:
>> On 6/24/2024 2:32 AM, Mikko wrote:
>>> On 2024-06-23 13:23:10 +0000, olcott said:
>>> 
>>>> On 6/23/2024 4:42 AM, Mikko wrote:
>>>>> When the head line has the words "these verified facts" the message should
>>>>> first tell what facts are "these verified facts" and who verified them
>>>>> before any further discussion.
>>>>> 
>>>> 
>>>> It is a verified fact that 2 + 3 = 5 according to the semantics
>>>> of arithmetic. Anyone having an opinion that contradicts this is WRONG.
>>> 
>>> Sure, but that was not the first thing mentioned in the initial message.
>>> 
>> 
>> 
>> int P(ptr2 x)
>> {
>>   int Halt_Status = H(x, x);
>>   if (Halt_Status)
>>     HERE: goto HERE;
>>   return Halt_Status;
>> }
>> 
>> The call from P to H(P,P) when P is correctly emulated
>> by H cannot possibly return.
>> 
>> The call from P to H(P,P) when P is correctly emulated
>> by H1 DOES return.
>> 
>> 
> 
> Verified fact: the emulation is incorrect

But which emulation? By H or by H1?

-- 
Mikko

[toc] | [prev] | [next] | [standalone]

#107789

On 6/25/2024 4:48 AM, Mikko wrote:
> On 2024-06-24 14:03:12 +0000, immibis said:
> 
>> On 24/06/24 15:50, olcott wrote:
>>> On 6/24/2024 2:32 AM, Mikko wrote:
>>>> On 2024-06-23 13:23:10 +0000, olcott said:
>>>>
>>>>> On 6/23/2024 4:42 AM, Mikko wrote:
>>>>>> When the head line has the words "these verified facts" the 
>>>>>> message should
>>>>>> first tell what facts are "these verified facts" and who verified 
>>>>>> them
>>>>>> before any further discussion.
>>>>>>
>>>>>
>>>>> It is a verified fact that 2 + 3 = 5 according to the semantics
>>>>> of arithmetic. Anyone having an opinion that contradicts this is 
>>>>> WRONG.
>>>>
>>>> Sure, but that was not the first thing mentioned in the initial 
>>>> message.
>>>>
>>>
>>>
>>> int P(ptr2 x)
>>> {
>>>   int Halt_Status = H(x, x);
>>>   if (Halt_Status)
>>>     HERE: goto HERE;
>>>   return Halt_Status;
>>> }
>>>
>>> The call from P to H(P,P) when P is correctly emulated
>>> by H cannot possibly return.
>>>
>>> The call from P to H(P,P) when P is correctly emulated
>>> by H1 DOES return.
>>>
>>>
>>
>> Verified fact: the emulation is incorrect
> 
> But which emulation? By H or by H1?
> 

Both of them are correct.
Because P never calls H1(P,P) and P does call H(P,P)
the call from P to H(P,P) returns in the first case
and cannot possibly return in the second case.

-- 
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]

#107820

On 6/25/24 9:19 AM, olcott wrote:
> On 6/25/2024 4:48 AM, Mikko wrote:
>> On 2024-06-24 14:03:12 +0000, immibis said:
>>
>>> On 24/06/24 15:50, olcott wrote:
>>>> On 6/24/2024 2:32 AM, Mikko wrote:
>>>>> On 2024-06-23 13:23:10 +0000, olcott said:
>>>>>
>>>>>> On 6/23/2024 4:42 AM, Mikko wrote:
>>>>>>> When the head line has the words "these verified facts" the 
>>>>>>> message should
>>>>>>> first tell what facts are "these verified facts" and who verified 
>>>>>>> them
>>>>>>> before any further discussion.
>>>>>>>
>>>>>>
>>>>>> It is a verified fact that 2 + 3 = 5 according to the semantics
>>>>>> of arithmetic. Anyone having an opinion that contradicts this is 
>>>>>> WRONG.
>>>>>
>>>>> Sure, but that was not the first thing mentioned in the initial 
>>>>> message.
>>>>>
>>>>
>>>>
>>>> int P(ptr2 x)
>>>> {
>>>>   int Halt_Status = H(x, x);
>>>>   if (Halt_Status)
>>>>     HERE: goto HERE;
>>>>   return Halt_Status;
>>>> }
>>>>
>>>> The call from P to H(P,P) when P is correctly emulated
>>>> by H cannot possibly return.
>>>>
>>>> The call from P to H(P,P) when P is correctly emulated
>>>> by H1 DOES return.
>>>>
>>>>
>>>
>>> Verified fact: the emulation is incorrect
>>
>> But which emulation? By H or by H1?
>>
> 
> Both of them are correct.
> Because P never calls H1(P,P) and P does call H(P,P)
> the call from P to H(P,P) returns in the first case
> and cannot possibly return in the second case.
> 

No, H just can't see that it will return to P. You can say the 
Simulation by H didn't get to that point, but that is not a "behavior" 
of the input, but of the decider.

[toc] | [prev] | [next] | [standalone]

#107844

On 2024-06-25 13:19:46 +0000, olcott said:

> On 6/25/2024 4:48 AM, Mikko wrote:
>> On 2024-06-24 14:03:12 +0000, immibis said:
>> 
>>> On 24/06/24 15:50, olcott wrote:
>>>> On 6/24/2024 2:32 AM, Mikko wrote:
>>>>> On 2024-06-23 13:23:10 +0000, olcott said:
>>>>> 
>>>>>> On 6/23/2024 4:42 AM, Mikko wrote:
>>>>>>> When the head line has the words "these verified facts" the message should
>>>>>>> first tell what facts are "these verified facts" and who verified them
>>>>>>> before any further discussion.
>>>>>>> 
>>>>>> 
>>>>>> It is a verified fact that 2 + 3 = 5 according to the semantics
>>>>>> of arithmetic. Anyone having an opinion that contradicts this is WRONG.
>>>>> 
>>>>> Sure, but that was not the first thing mentioned in the initial message.
>>>>> 
>>>> 
>>>> 
>>>> int P(ptr2 x)
>>>> {
>>>>   int Halt_Status = H(x, x);
>>>>   if (Halt_Status)
>>>>     HERE: goto HERE;
>>>>   return Halt_Status;
>>>> }
>>>> 
>>>> The call from P to H(P,P) when P is correctly emulated
>>>> by H cannot possibly return.
>>>> 
>>>> The call from P to H(P,P) when P is correctly emulated
>>>> by H1 DOES return.
>>>> 
>>>> 
>>> 
>>> Verified fact: the emulation is incorrect
>> 
>> But which emulation? By H or by H1?
>> 
> 
> Both of them are correct.
> Because P never calls H1(P,P) and P does call H(P,P)
> the call from P to H(P,P) returns in the first case
> and cannot possibly return in the second case.

Obviously false. The meaning of H(P,P) is determined by the text of H.
The meaning is fully determined by the complier that complies to the
x86 code and the semantics of x86. If one simulator interpretes the
x86 code differently from another simulator then one of them does not
follow the x86 semantics and is therefore incorrect.

-- 
Mikko

[toc] | [prev] | [next] | [standalone]

#107855

On 6/26/2024 2:54 AM, Mikko wrote:
> On 2024-06-25 13:19:46 +0000, olcott said:
> 
>> On 6/25/2024 4:48 AM, Mikko wrote:
>>> On 2024-06-24 14:03:12 +0000, immibis said:
>>>
>>>> On 24/06/24 15:50, olcott wrote:
>>>>> On 6/24/2024 2:32 AM, Mikko wrote:
>>>>>> On 2024-06-23 13:23:10 +0000, olcott said:
>>>>>>
>>>>>>> On 6/23/2024 4:42 AM, Mikko wrote:
>>>>>>>> When the head line has the words "these verified facts" the 
>>>>>>>> message should
>>>>>>>> first tell what facts are "these verified facts" and who 
>>>>>>>> verified them
>>>>>>>> before any further discussion.
>>>>>>>>
>>>>>>>
>>>>>>> It is a verified fact that 2 + 3 = 5 according to the semantics
>>>>>>> of arithmetic. Anyone having an opinion that contradicts this is 
>>>>>>> WRONG.
>>>>>>
>>>>>> Sure, but that was not the first thing mentioned in the initial 
>>>>>> message.
>>>>>>
>>>>>
>>>>>
>>>>> int P(ptr2 x)
>>>>> {
>>>>>   int Halt_Status = H(x, x);
>>>>>   if (Halt_Status)
>>>>>     HERE: goto HERE;
>>>>>   return Halt_Status;
>>>>> }
>>>>>
>>>>> The call from P to H(P,P) when P is correctly emulated
>>>>> by H cannot possibly return.
>>>>>
>>>>> The call from P to H(P,P) when P is correctly emulated
>>>>> by H1 DOES return.
>>>>>
>>>>>
>>>>
>>>> Verified fact: the emulation is incorrect
>>>
>>> But which emulation? By H or by H1?
>>>
>>
>> Both of them are correct.
>> Because P never calls H1(P,P) and P does call H(P,P)
>> the call from P to H(P,P) returns in the first case
>> and cannot possibly return in the second case.
> 
> Obviously false. The meaning of H(P,P) is determined by the text of H.
> The meaning is fully determined by the complier that complies to the
> x86 code and the semantics of x86. If one simulator interpretes the
> x86 code differently from another simulator then one of them does not
> follow the x86 semantics and is therefore incorrect.
> 

_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
the x86 emulator H0(DDD) at machine address 0000217a
when DDD is correctly emulated by H0 cannot possibly return.

When DDD is correctly emulated by H0 then H0 must emulate itself
emulating DDD. This derives recursive emulation.

When DDD is correctly emulated by H1 then H1 NEED NOT emulate itself
emulating DDD. This DOES NOT derive recursive emulation.

*You probably lack suffcient technical competence*

-- 
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]

#107877

On 6/26/24 8:53 AM, olcott wrote:
> On 6/26/2024 2:54 AM, Mikko wrote:
>> On 2024-06-25 13:19:46 +0000, olcott said:
>>
>>> On 6/25/2024 4:48 AM, Mikko wrote:
>>>> On 2024-06-24 14:03:12 +0000, immibis said:
>>>>
>>>>> On 24/06/24 15:50, olcott wrote:
>>>>>> On 6/24/2024 2:32 AM, Mikko wrote:
>>>>>>> On 2024-06-23 13:23:10 +0000, olcott said:
>>>>>>>
>>>>>>>> On 6/23/2024 4:42 AM, Mikko wrote:
>>>>>>>>> When the head line has the words "these verified facts" the 
>>>>>>>>> message should
>>>>>>>>> first tell what facts are "these verified facts" and who 
>>>>>>>>> verified them
>>>>>>>>> before any further discussion.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is a verified fact that 2 + 3 = 5 according to the semantics
>>>>>>>> of arithmetic. Anyone having an opinion that contradicts this is 
>>>>>>>> WRONG.
>>>>>>>
>>>>>>> Sure, but that was not the first thing mentioned in the initial 
>>>>>>> message.
>>>>>>>
>>>>>>
>>>>>>
>>>>>> int P(ptr2 x)
>>>>>> {
>>>>>>   int Halt_Status = H(x, x);
>>>>>>   if (Halt_Status)
>>>>>>     HERE: goto HERE;
>>>>>>   return Halt_Status;
>>>>>> }
>>>>>>
>>>>>> The call from P to H(P,P) when P is correctly emulated
>>>>>> by H cannot possibly return.
>>>>>>
>>>>>> The call from P to H(P,P) when P is correctly emulated
>>>>>> by H1 DOES return.
>>>>>>
>>>>>>
>>>>>
>>>>> Verified fact: the emulation is incorrect
>>>>
>>>> But which emulation? By H or by H1?
>>>>
>>>
>>> Both of them are correct.
>>> Because P never calls H1(P,P) and P does call H(P,P)
>>> the call from P to H(P,P) returns in the first case
>>> and cannot possibly return in the second case.
>>
>> Obviously false. The meaning of H(P,P) is determined by the text of H.
>> The meaning is fully determined by the complier that complies to the
>> x86 code and the semantics of x86. If one simulator interpretes the
>> x86 code differently from another simulator then one of them does not
>> follow the x86 semantics and is therefore incorrect.

By that logic, ALL deciders are "Correct" as they answer what they 
answer. That seems to be the sort of logic system you want.

What H is SUPPOSED to do, and the meaning of the input to H, is 
determined by the SPECIFICATION of H.

>>
> 
> _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
> the x86 emulator H0(DDD) at machine address 0000217a
> when DDD is correctly emulated by H0 cannot possibly return.

And "Correct Emulation" of an input is only really correct if carried to 
completion, because that IS the semantics of the x86 instruction set. 
Otherwise it is just a PARTIAL emulation.

> 
> When DDD is correctly emulated by H0 then H0 must emulate itself
> emulating DDD. This derives recursive emulation.

So, is H0 defined to be an UNCONDITIONAL emulator, or are you going to 
claim at some point that it can stop and still meet its requirements.

> 
> When DDD is correctly emulated by H1 then H1 NEED NOT emulate itself
> emulating DDD. This DOES NOT derive recursive emulation.

But, if H0 never stops emulating its input, then H1 will never reach the 
end either.

So, if H1 can see an end, then H0 MUST have returned. If H0 didn't see 
that in its emulation, it must have aborted it too soon.

> 
> *You probably lack suffcient technical competence*
> 

YOU clearly don't have the needed technical competence.

[toc] | [prev] | [next] | [standalone]

#107919

On 2024-06-26 12:53:16 +0000, olcott said:

> On 6/26/2024 2:54 AM, Mikko wrote:
>> On 2024-06-25 13:19:46 +0000, olcott said:
>> 
>>> On 6/25/2024 4:48 AM, Mikko wrote:
>>>> On 2024-06-24 14:03:12 +0000, immibis said:
>>>> 
>>>>> On 24/06/24 15:50, olcott wrote:
>>>>>> On 6/24/2024 2:32 AM, Mikko wrote:
>>>>>>> On 2024-06-23 13:23:10 +0000, olcott said:
>>>>>>> 
>>>>>>>> On 6/23/2024 4:42 AM, Mikko wrote:
>>>>>>>>> When the head line has the words "these verified facts" the message should
>>>>>>>>> first tell what facts are "these verified facts" and who verified them
>>>>>>>>> before any further discussion.
>>>>>>>>> 
>>>>>>>> 
>>>>>>>> It is a verified fact that 2 + 3 = 5 according to the semantics
>>>>>>>> of arithmetic. Anyone having an opinion that contradicts this is WRONG.
>>>>>>> 
>>>>>>> Sure, but that was not the first thing mentioned in the initial message.
>>>>>>> 
>>>>>> 
>>>>>> 
>>>>>> int P(ptr2 x)
>>>>>> {
>>>>>>   int Halt_Status = H(x, x);
>>>>>>   if (Halt_Status)
>>>>>>     HERE: goto HERE;
>>>>>>   return Halt_Status;
>>>>>> }
>>>>>> 
>>>>>> The call from P to H(P,P) when P is correctly emulated
>>>>>> by H cannot possibly return.
>>>>>> 
>>>>>> The call from P to H(P,P) when P is correctly emulated
>>>>>> by H1 DOES return.
>>>>>> 
>>>>>> 
>>>>> 
>>>>> Verified fact: the emulation is incorrect
>>>> 
>>>> But which emulation? By H or by H1?
>>>> 
>>> 
>>> Both of them are correct.
>>> Because P never calls H1(P,P) and P does call H(P,P)
>>> the call from P to H(P,P) returns in the first case
>>> and cannot possibly return in the second case.
>> 
>> Obviously false. The meaning of H(P,P) is determined by the text of H.
>> The meaning is fully determined by the complier that complies to the
>> x86 code and the semantics of x86. If one simulator interpretes the
>> x86 code differently from another simulator then one of them does not
>> follow the x86 semantics and is therefore incorrect.
> 
> _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
> the x86 emulator H0(DDD) at machine address 0000217a
> when DDD is correctly emulated by H0 cannot possibly return.
> 
> When DDD is correctly emulated by H0 then H0 must emulate itself
> emulating DDD. This derives recursive emulation.
> 
> When DDD is correctly emulated by H1 then H1 NEED NOT emulate itself
> emulating DDD. This DOES NOT derive recursive emulation.

When DDD is emulated by H1 then H1 needs to the call to H0 and the
instructions of H0 which emulate DDD and its call to H0 and a recorsive
emulation follows. If H1 emulates correctly it must not emulate the
emulation of the instruction at 217f. Unless, of course, you lied
about H0.

-- 
Mikko

[toc] | [prev] | [next] | [standalone]

#107939

On 6/27/2024 2:18 AM, Mikko wrote:
> On 2024-06-26 12:53:16 +0000, olcott said:
> 
>> On 6/26/2024 2:54 AM, Mikko wrote:
>>>
>>> Obviously false. The meaning of H(P,P) is determined by the text of H.
>>> The meaning is fully determined by the complier that complies to the
>>> x86 code and the semantics of x86. If one simulator interpretes the
>>> x86 code differently from another simulator then one of them does not
>>> follow the x86 semantics and is therefore incorrect.
>>
>> _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
>> the x86 emulator H0(DDD) at machine address 0000217a
>> when DDD is correctly emulated by H0 cannot possibly return.
>>
>> When DDD is correctly emulated by H0 then H0 must emulate itself
>> emulating DDD. This derives recursive emulation.
>>
>> When DDD is correctly emulated by H1 then H1 NEED NOT emulate itself
>> emulating DDD. This DOES NOT derive recursive emulation.
> 
> When DDD is emulated by H1 then H1 needs to the call to H0 and the
> instructions of H0 which emulate DDD and its call to H0 and a recorsive
> emulation follows. If H1 emulates correctly it must not emulate the
> emulation of the instruction at 217f. Unless, of course, you lied
> about H0.
> 

You contradict yourself.
*Here is what actually happens*

_DDD()
[00002172] 55         push ebp
[00002173] 8bec       mov ebp,esp
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH0
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

_main()
[00002192] 55         push ebp
[00002193] 8bec       mov ebp,esp
[00002195] 6872210000 push 00002172 ; push DDD
[0000219a] e863f3ffff call 00001502 ; call HHH1(DDD)
[0000219f] 83c404     add esp,+04
[000021a2] 50         push eax
[000021a3] 6843070000 push 00000743
[000021a8] e8b5e5ffff call 00000762
[000021ad] 83c408     add esp,+08
[000021b0] eb04       jmp 000021b6
[000021b2] 33c0       xor eax,eax
[000021b4] eb02       jmp 000021b8
[000021b6] 33c0       xor eax,eax
[000021b8] 5d         pop ebp
[000021b9] c3         ret
Size in bytes:(0040) [000021b9]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00002192][00103826][00000000] 55         push ebp
[00002193][00103826][00000000] 8bec       mov ebp,esp
[00002195][00103822][00002172] 6872210000 push 00002172 ; push DDD
[0000219a][0010381e][0000219f] e863f3ffff call 00001502 ; call HHH1(DDD)
New slave_stack at:1038ca

Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d2
[00002172][001138c2][001138c6] 55         push ebp
[00002173][001138c2][001138c6] 8bec       mov ebp,esp
[00002175][001138be][00002172] 6872210000 push 00002172 ; push DDD
[0000217a][001138ba][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
New slave_stack at:14e2f2

Begin Local Halt Decider Simulation   Execution Trace Stored at:15e2fa
[00002172][0015e2ea][0015e2ee] 55         push ebp
[00002173][0015e2ea][0015e2ee] 8bec       mov ebp,esp
[00002175][0015e2e6][00002172] 6872210000 push 00002172 ; push DDD
[0000217a][0015e2e2][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
New slave_stack at:198d1a
[00002172][001a8d12][001a8d16] 55         push ebp
[00002173][001a8d12][001a8d16] 8bec       mov ebp,esp
[00002175][001a8d0e][00002172] 6872210000 push 00002172 ; push DDD
[0000217a][001a8d0a][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[0000217f][001138c2][001138c6] 83c404     add esp,+04   ; return to DDD
[00002182][001138c6][000015b7] 5d         pop ebp
[00002183][001138ca][0003a980] c3         ret           ; return to main
[0000219f][00103826][00000000] 83c404     add esp,+04
[000021a2][00103822][00000001] 50         push eax
[000021a3][0010381e][00000743] 6843070000 push 00000743
[000021a8][0010381e][00000743] e8b5e5ffff call 00000762
Input_Halts = 1
[000021ad][00103826][00000000] 83c408     add esp,+08
[000021b0][00103826][00000000] eb04       jmp 000021b6
[000021b6][00103826][00000000] 33c0       xor eax,eax
[000021b8][0010382a][00000018] 5d         pop ebp
[000021b9][0010382e][00000000] c3         ret
Number of Instructions Executed(352835) == 5266 Pages


-- 
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]

#107944

On 6/27/24 3:42 PM, olcott wrote:
> On 6/27/2024 2:18 AM, Mikko wrote:
>> On 2024-06-26 12:53:16 +0000, olcott said:
>>
>>> On 6/26/2024 2:54 AM, Mikko wrote:
>>>>
>>>> Obviously false. The meaning of H(P,P) is determined by the text of H.
>>>> The meaning is fully determined by the complier that complies to the
>>>> x86 code and the semantics of x86. If one simulator interpretes the
>>>> x86 code differently from another simulator then one of them does not
>>>> follow the x86 semantics and is therefore incorrect.
>>>
>>> _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
>>> the x86 emulator H0(DDD) at machine address 0000217a
>>> when DDD is correctly emulated by H0 cannot possibly return.
>>>
>>> When DDD is correctly emulated by H0 then H0 must emulate itself
>>> emulating DDD. This derives recursive emulation.
>>>
>>> When DDD is correctly emulated by H1 then H1 NEED NOT emulate itself
>>> emulating DDD. This DOES NOT derive recursive emulation.
>>
>> When DDD is emulated by H1 then H1 needs to the call to H0 and the
>> instructions of H0 which emulate DDD and its call to H0 and a recorsive
>> emulation follows. If H1 emulates correctly it must not emulate the
>> emulation of the instruction at 217f. Unless, of course, you lied
>> about H0.
>>
> 
> You contradict yourself.
> *Here is what actually happens*
> 
> _DDD()
> [00002172] 55         push ebp
> [00002173] 8bec       mov ebp,esp
> [00002175] 6872210000 push 00002172 ; push DDD
> [0000217a] e853f4ffff call 000015d2 ; call HHH0
> [0000217f] 83c404     add esp,+04
> [00002182] 5d         pop ebp
> [00002183] c3         ret
> Size in bytes:(0018) [00002183]
> 
> _main()
> [00002192] 55         push ebp
> [00002193] 8bec       mov ebp,esp
> [00002195] 6872210000 push 00002172 ; push DDD
> [0000219a] e863f3ffff call 00001502 ; call HHH1(DDD)
> [0000219f] 83c404     add esp,+04
> [000021a2] 50         push eax
> [000021a3] 6843070000 push 00000743
> [000021a8] e8b5e5ffff call 00000762
> [000021ad] 83c408     add esp,+08
> [000021b0] eb04       jmp 000021b6
> [000021b2] 33c0       xor eax,eax
> [000021b4] eb02       jmp 000021b8
> [000021b6] 33c0       xor eax,eax
> [000021b8] 5d         pop ebp
> [000021b9] c3         ret
> Size in bytes:(0040) [000021b9]
> 
>   machine   stack     stack     machine    assembly
>   address   address   data      code       language
>   ========  ========  ========  =========  =============
> [00002192][00103826][00000000] 55         push ebp
> [00002193][00103826][00000000] 8bec       mov ebp,esp
> [00002195][00103822][00002172] 6872210000 push 00002172 ; push DDD
> [0000219a][0010381e][0000219f] e863f3ffff call 00001502 ; call HHH1(DDD)
> New slave_stack at:1038ca

Which isn't a correct simulation of the CALL HHH1 instruction.

So, you proof is shown to be a LIE.

Note, by the rules of the x86, calling a function, even if it is a 
emulator, doesn't make the x86 emulation of that call to be an emulation 
of the input to that function.

> 
> Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d2
> [00002172][001138c2][001138c6] 55         push ebp
> [00002173][001138c2][001138c6] 8bec       mov ebp,esp
> [00002175][001138be][00002172] 6872210000 push 00002172 ; push DDD
> [0000217a][001138ba][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
> New slave_stack at:14e2f2
> 
> Begin Local Halt Decider Simulation   Execution Trace Stored at:15e2fa
> [00002172][0015e2ea][0015e2ee] 55         push ebp
> [00002173][0015e2ea][0015e2ee] 8bec       mov ebp,esp
> [00002175][0015e2e6][00002172] 6872210000 push 00002172 ; push DDD
> [0000217a][0015e2e2][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
> New slave_stack at:198d1a
> [00002172][001a8d12][001a8d16] 55         push ebp
> [00002173][001a8d12][001a8d16] 8bec       mov ebp,esp
> [00002175][001a8d0e][00002172] 6872210000 push 00002172 ; push DDD
> [0000217a][001a8d0a][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> 
> [0000217f][001138c2][001138c6] 83c404     add esp,+04   ; return to DDD
> [00002182][001138c6][000015b7] 5d         pop ebp
> [00002183][001138ca][0003a980] c3         ret           ; return to main
> [0000219f][00103826][00000000] 83c404     add esp,+04
> [000021a2][00103822][00000001] 50         push eax
> [000021a3][0010381e][00000743] 6843070000 push 00000743
> [000021a8][0010381e][00000743] e8b5e5ffff call 00000762
> Input_Halts = 1
> [000021ad][00103826][00000000] 83c408     add esp,+08
> [000021b0][00103826][00000000] eb04       jmp 000021b6
> [000021b6][00103826][00000000] 33c0       xor eax,eax
> [000021b8][0010382a][00000018] 5d         pop ebp
> [000021b9][0010382e][00000000] c3         ret
> Number of Instructions Executed(352835) == 5266 Pages
> 
> 

[toc] | [prev] | [next] | [standalone]

#107952

On 2024-06-27 19:42:21 +0000, olcott said:

> On 6/27/2024 2:18 AM, Mikko wrote:
>> On 2024-06-26 12:53:16 +0000, olcott said:
>> 
>>> On 6/26/2024 2:54 AM, Mikko wrote:
>>>> 
>>>> Obviously false. The meaning of H(P,P) is determined by the text of H.
>>>> The meaning is fully determined by the complier that complies to the
>>>> x86 code and the semantics of x86. If one simulator interpretes the
>>>> x86 code differently from another simulator then one of them does not
>>>> follow the x86 semantics and is therefore incorrect.
>>> 
>>> _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
>>> the x86 emulator H0(DDD) at machine address 0000217a
>>> when DDD is correctly emulated by H0 cannot possibly return.
>>> 
>>> When DDD is correctly emulated by H0 then H0 must emulate itself
>>> emulating DDD. This derives recursive emulation.
>>> 
>>> When DDD is correctly emulated by H1 then H1 NEED NOT emulate itself
>>> emulating DDD. This DOES NOT derive recursive emulation.
>> 
>> When DDD is emulated by H1 then H1 needs to the call to H0 and the
>> instructions of H0 which emulate DDD and its call to H0 and a recorsive
>> emulation follows. If H1 emulates correctly it must not emulate the
>> emulation of the instruction at 217f. Unless, of course, you lied
>> about H0.
> 
> You contradict yourself.

You have not shown any self-contradiction in my words. There is no
obvious self-contradiction but maybe there is some less obvious
mistake.

> *Here is what actually happens*
> 
> _DDD()
> [00002172] 55         push ebp
> [00002173] 8bec       mov ebp,esp
> [00002175] 6872210000 push 00002172 ; push DDD
> [0000217a] e853f4ffff call 000015d2 ; call HHH0
> [0000217f] 83c404     add esp,+04
> [00002182] 5d         pop ebp
> [00002183] c3         ret
> Size in bytes:(0018) [00002183]
> 
> _main()
> [00002192] 55         push ebp
> [00002193] 8bec       mov ebp,esp
> [00002195] 6872210000 push 00002172 ; push DDD
> [0000219a] e863f3ffff call 00001502 ; call HHH1(DDD)
> [0000219f] 83c404     add esp,+04
> [000021a2] 50         push eax
> [000021a3] 6843070000 push 00000743
> [000021a8] e8b5e5ffff call 00000762
> [000021ad] 83c408     add esp,+08
> [000021b0] eb04       jmp 000021b6
> [000021b2] 33c0       xor eax,eax
> [000021b4] eb02       jmp 000021b8
> [000021b6] 33c0       xor eax,eax
> [000021b8] 5d         pop ebp
> [000021b9] c3         ret
> Size in bytes:(0040) [000021b9]
> 
>   machine   stack     stack     machine    assembly
>   address   address   data      code       language
>   ========  ========  ========  =========  =============
> [00002192][00103826][00000000] 55         push ebp
> [00002193][00103826][00000000] 8bec       mov ebp,esp
> [00002195][00103822][00002172] 6872210000 push 00002172 ; push DDD
> [0000219a][0010381e][0000219f] e863f3ffff call 00001502 ; call HHH1(DDD)
> New slave_stack at:1038ca
> 
> Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d2
> [00002172][001138c2][001138c6] 55         push ebp
> [00002173][001138c2][001138c6] 8bec       mov ebp,esp
> [00002175][001138be][00002172] 6872210000 push 00002172 ; push DDD
> [0000217a][001138ba][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
> New slave_stack at:14e2f2
> 
> Begin Local Halt Decider Simulation   Execution Trace Stored at:15e2fa
> [00002172][0015e2ea][0015e2ee] 55         push ebp
> [00002173][0015e2ea][0015e2ee] 8bec       mov ebp,esp
> [00002175][0015e2e6][00002172] 6872210000 push 00002172 ; push DDD
> [0000217a][0015e2e2][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
> New slave_stack at:198d1a
> [00002172][001a8d12][001a8d16] 55         push ebp
> [00002173][001a8d12][001a8d16] 8bec       mov ebp,esp
> [00002175][001a8d0e][00002172] 6872210000 push 00002172 ; push DDD
> [0000217a][001a8d0a][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> 
> [0000217f][001138c2][001138c6] 83c404     add esp,+04   ; return to DDD
> [00002182][001138c6][000015b7] 5d         pop ebp
> [00002183][001138ca][0003a980] c3         ret           ; return to main
> [0000219f][00103826][00000000] 83c404     add esp,+04
> [000021a2][00103822][00000001] 50         push eax
> [000021a3][0010381e][00000743] 6843070000 push 00000743
> [000021a8][0010381e][00000743] e8b5e5ffff call 00000762
> Input_Halts = 1
> [000021ad][00103826][00000000] 83c408     add esp,+08
> [000021b0][00103826][00000000] eb04       jmp 000021b6
> [000021b6][00103826][00000000] 33c0       xor eax,eax
> [000021b8][0010382a][00000018] 5d         pop ebp
> [000021b9][0010382e][00000000] c3         ret
> Number of Instructions Executed(352835) == 5266 Pages

Is the program at 15d2 H0 or HHH0?

-- 
Mikko

[toc] | [prev] | [next] | [standalone]

#107968

On 6/28/2024 4:06 AM, Mikko wrote:
> On 2024-06-27 19:42:21 +0000, olcott said:
> 
>> On 6/27/2024 2:18 AM, Mikko wrote:
>>> On 2024-06-26 12:53:16 +0000, olcott said:
>>>
>>>> On 6/26/2024 2:54 AM, Mikko wrote:
>>>>>
>>>>> Obviously false. The meaning of H(P,P) is determined by the text of H.
>>>>> The meaning is fully determined by the complier that complies to the
>>>>> x86 code and the semantics of x86. If one simulator interpretes the
>>>>> x86 code differently from another simulator then one of them does not
>>>>> follow the x86 semantics and is therefore incorrect.
>>>>
>>>> _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
>>>> the x86 emulator H0(DDD) at machine address 0000217a
>>>> when DDD is correctly emulated by H0 cannot possibly return.
>>>>
>>>> When DDD is correctly emulated by H0 then H0 must emulate itself
>>>> emulating DDD. This derives recursive emulation.
>>>>
>>>> When DDD is correctly emulated by H1 then H1 NEED NOT emulate itself
>>>> emulating DDD. This DOES NOT derive recursive emulation.
>>>
>>> When DDD is emulated by H1 then H1 needs to the call to H0 and the
>>> instructions of H0 which emulate DDD and its call to H0 and a recorsive
>>> emulation follows. If H1 emulates correctly it must not emulate the
>>> emulation of the instruction at 217f. Unless, of course, you lied
>>> about H0.
>>
>> You contradict yourself.
> 
> You have not shown any self-contradiction in my words. There is no
> obvious self-contradiction but maybe there is some less obvious
> mistake.
> 
>> *Here is what actually happens*
>>
>> _DDD()
>> [00002172] 55         push ebp
>> [00002173] 8bec       mov ebp,esp
>> [00002175] 6872210000 push 00002172 ; push DDD
>> [0000217a] e853f4ffff call 000015d2 ; call HHH0
>> [0000217f] 83c404     add esp,+04
>> [00002182] 5d         pop ebp
>> [00002183] c3         ret
>> Size in bytes:(0018) [00002183]
>>
>> _main()
>> [00002192] 55         push ebp
>> [00002193] 8bec       mov ebp,esp
>> [00002195] 6872210000 push 00002172 ; push DDD
>> [0000219a] e863f3ffff call 00001502 ; call HHH1(DDD)
>> [0000219f] 83c404     add esp,+04
>> [000021a2] 50         push eax
>> [000021a3] 6843070000 push 00000743
>> [000021a8] e8b5e5ffff call 00000762
>> [000021ad] 83c408     add esp,+08
>> [000021b0] eb04       jmp 000021b6
>> [000021b2] 33c0       xor eax,eax
>> [000021b4] eb02       jmp 000021b8
>> [000021b6] 33c0       xor eax,eax
>> [000021b8] 5d         pop ebp
>> [000021b9] c3         ret
>> Size in bytes:(0040) [000021b9]
>>
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [00002192][00103826][00000000] 55         push ebp
>> [00002193][00103826][00000000] 8bec       mov ebp,esp
>> [00002195][00103822][00002172] 6872210000 push 00002172 ; push DDD
>> [0000219a][0010381e][0000219f] e863f3ffff call 00001502 ; call HHH1(DDD)
>> New slave_stack at:1038ca
>>
>> Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d2
>> [00002172][001138c2][001138c6] 55         push ebp
>> [00002173][001138c2][001138c6] 8bec       mov ebp,esp
>> [00002175][001138be][00002172] 6872210000 push 00002172 ; push DDD
>> [0000217a][001138ba][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
>> New slave_stack at:14e2f2
>>
>> Begin Local Halt Decider Simulation   Execution Trace Stored at:15e2fa
>> [00002172][0015e2ea][0015e2ee] 55         push ebp
>> [00002173][0015e2ea][0015e2ee] 8bec       mov ebp,esp
>> [00002175][0015e2e6][00002172] 6872210000 push 00002172 ; push DDD
>> [0000217a][0015e2e2][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
>> New slave_stack at:198d1a
>> [00002172][001a8d12][001a8d16] 55         push ebp
>> [00002173][001a8d12][001a8d16] 8bec       mov ebp,esp
>> [00002175][001a8d0e][00002172] 6872210000 push 00002172 ; push DDD
>> [0000217a][001a8d0a][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> [0000217f][001138c2][001138c6] 83c404     add esp,+04   ; return to DDD
>> [00002182][001138c6][000015b7] 5d         pop ebp
>> [00002183][001138ca][0003a980] c3         ret           ; return to main
>> [0000219f][00103826][00000000] 83c404     add esp,+04
>> [000021a2][00103822][00000001] 50         push eax
>> [000021a3][0010381e][00000743] 6843070000 push 00000743
>> [000021a8][0010381e][00000743] e8b5e5ffff call 00000762
>> Input_Halts = 1
>> [000021ad][00103826][00000000] 83c408     add esp,+08
>> [000021b0][00103826][00000000] eb04       jmp 000021b6
>> [000021b6][00103826][00000000] 33c0       xor eax,eax
>> [000021b8][0010382a][00000018] 5d         pop ebp
>> [000021b9][0010382e][00000000] c3         ret
>> Number of Instructions Executed(352835) == 5266 Pages
> 
> Is the program at 15d2 H0 or HHH0?
> 

I have standardized the naming conventions.
H0 and HHH0 are now called HHH.

// HHH(DDD) and HHH1(DDD) are the standard names for DDD input
// DDD calls HHH(DDD). HHH1 is identical to HHH.


-- 
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]

#107999

On 2024-06-28 15:07:30 +0000, olcott said:

> On 6/28/2024 4:06 AM, Mikko wrote:
>> On 2024-06-27 19:42:21 +0000, olcott said:
>> 
>>> On 6/27/2024 2:18 AM, Mikko wrote:
>>>> On 2024-06-26 12:53:16 +0000, olcott said:
>>>> 
>>>>> On 6/26/2024 2:54 AM, Mikko wrote:
>>>>>> 
>>>>>> Obviously false. The meaning of H(P,P) is determined by the text of H.
>>>>>> The meaning is fully determined by the complier that complies to the
>>>>>> x86 code and the semantics of x86. If one simulator interpretes the
>>>>>> x86 code differently from another simulator then one of them does not
>>>>>> follow the x86 semantics and is therefore incorrect.
>>>>> 
>>>>> _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
>>>>> the x86 emulator H0(DDD) at machine address 0000217a
>>>>> when DDD is correctly emulated by H0 cannot possibly return.
>>>>> 
>>>>> When DDD is correctly emulated by H0 then H0 must emulate itself
>>>>> emulating DDD. This derives recursive emulation.
>>>>> 
>>>>> When DDD is correctly emulated by H1 then H1 NEED NOT emulate itself
>>>>> emulating DDD. This DOES NOT derive recursive emulation.
>>>> 
>>>> When DDD is emulated by H1 then H1 needs to the call to H0 and the
>>>> instructions of H0 which emulate DDD and its call to H0 and a recorsive
>>>> emulation follows. If H1 emulates correctly it must not emulate the
>>>> emulation of the instruction at 217f. Unless, of course, you lied
>>>> about H0.
>>> 
>>> You contradict yourself.
>> 
>> You have not shown any self-contradiction in my words. There is no
>> obvious self-contradiction but maybe there is some less obvious
>> mistake.
>> 
>>> *Here is what actually happens*
>>> 
>>> _DDD()
>>> [00002172] 55         push ebp
>>> [00002173] 8bec       mov ebp,esp
>>> [00002175] 6872210000 push 00002172 ; push DDD
>>> [0000217a] e853f4ffff call 000015d2 ; call HHH0
>>> [0000217f] 83c404     add esp,+04
>>> [00002182] 5d         pop ebp
>>> [00002183] c3         ret
>>> Size in bytes:(0018) [00002183]
>>> 
>>> _main()
>>> [00002192] 55         push ebp
>>> [00002193] 8bec       mov ebp,esp
>>> [00002195] 6872210000 push 00002172 ; push DDD
>>> [0000219a] e863f3ffff call 00001502 ; call HHH1(DDD)
>>> [0000219f] 83c404     add esp,+04
>>> [000021a2] 50         push eax
>>> [000021a3] 6843070000 push 00000743
>>> [000021a8] e8b5e5ffff call 00000762
>>> [000021ad] 83c408     add esp,+08
>>> [000021b0] eb04       jmp 000021b6
>>> [000021b2] 33c0       xor eax,eax
>>> [000021b4] eb02       jmp 000021b8
>>> [000021b6] 33c0       xor eax,eax
>>> [000021b8] 5d         pop ebp
>>> [000021b9] c3         ret
>>> Size in bytes:(0040) [000021b9]
>>> 
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ========  ========  ========  =========  =============
>>> [00002192][00103826][00000000] 55         push ebp
>>> [00002193][00103826][00000000] 8bec       mov ebp,esp
>>> [00002195][00103822][00002172] 6872210000 push 00002172 ; push DDD
>>> [0000219a][0010381e][0000219f] e863f3ffff call 00001502 ; call HHH1(DDD)
>>> New slave_stack at:1038ca
>>> 
>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d2
>>> [00002172][001138c2][001138c6] 55         push ebp
>>> [00002173][001138c2][001138c6] 8bec       mov ebp,esp
>>> [00002175][001138be][00002172] 6872210000 push 00002172 ; push DDD
>>> [0000217a][001138ba][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
>>> New slave_stack at:14e2f2
>>> 
>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:15e2fa
>>> [00002172][0015e2ea][0015e2ee] 55         push ebp
>>> [00002173][0015e2ea][0015e2ee] 8bec       mov ebp,esp
>>> [00002175][0015e2e6][00002172] 6872210000 push 00002172 ; push DDD
>>> [0000217a][0015e2e2][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
>>> New slave_stack at:198d1a
>>> [00002172][001a8d12][001a8d16] 55         push ebp
>>> [00002173][001a8d12][001a8d16] 8bec       mov ebp,esp
>>> [00002175][001a8d0e][00002172] 6872210000 push 00002172 ; push DDD
>>> [0000217a][001a8d0a][0000217f] e853f4ffff call 000015d2 ; call HHH0(DDD)
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>> 
>>> [0000217f][001138c2][001138c6] 83c404     add esp,+04   ; return to DDD
>>> [00002182][001138c6][000015b7] 5d         pop ebp
>>> [00002183][001138ca][0003a980] c3         ret           ; return to main
>>> [0000219f][00103826][00000000] 83c404     add esp,+04
>>> [000021a2][00103822][00000001] 50         push eax
>>> [000021a3][0010381e][00000743] 6843070000 push 00000743
>>> [000021a8][0010381e][00000743] e8b5e5ffff call 00000762
>>> Input_Halts = 1
>>> [000021ad][00103826][00000000] 83c408     add esp,+08
>>> [000021b0][00103826][00000000] eb04       jmp 000021b6
>>> [000021b6][00103826][00000000] 33c0       xor eax,eax
>>> [000021b8][0010382a][00000018] 5d         pop ebp
>>> [000021b9][0010382e][00000000] c3         ret
>>> Number of Instructions Executed(352835) == 5266 Pages
>> 
>> Is the program at 15d2 H0 or HHH0?
>> 
> 
> I have standardized the naming conventions.
> H0 and HHH0 are now called HHH.

In which sense the names H0 and HHH0 are non-standard?

-- 
Mikko

[toc] | [prev] | [next] | [standalone]

#107740

On 6/24/24 9:50 AM, olcott wrote:
> On 6/24/2024 2:32 AM, Mikko wrote:
>> On 2024-06-23 13:23:10 +0000, olcott said:
>>
>>> On 6/23/2024 4:42 AM, Mikko wrote:
>>>> When the head line has the words "these verified facts" the message 
>>>> should
>>>> first tell what facts are "these verified facts" and who verified them
>>>> before any further discussion.
>>>>
>>>
>>> It is a verified fact that 2 + 3 = 5 according to the semantics
>>> of arithmetic. Anyone having an opinion that contradicts this is WRONG.
>>
>> Sure, but that was not the first thing mentioned in the initial message.
>>
> 
> 
> int P(ptr2 x)
> {
>    int Halt_Status = H(x, x);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
> 
> The call from P to H(P,P) when P is correctly emulated
> by H cannot possibly return.
> 
> The call from P to H(P,P) when P is correctly emulated
> by H1 DOES return.
> 
> 

So?

That just proves that "Correctly Emulated by the Decider" is a 
subjective question, and thus not really interesting.

[toc] | [prev] | [next] | [standalone]

#107780

On 2024-06-24 13:50:20 +0000, olcott said:

> On 6/24/2024 2:32 AM, Mikko wrote:
>> On 2024-06-23 13:23:10 +0000, olcott said:
>> 
>>> On 6/23/2024 4:42 AM, Mikko wrote:
>>>> When the head line has the words "these verified facts" the message should
>>>> first tell what facts are "these verified facts" and who verified them
>>>> before any further discussion.
>>>> 
>>> 
>>> It is a verified fact that 2 + 3 = 5 according to the semantics
>>> of arithmetic. Anyone having an opinion that contradicts this is WRONG.
>> 
>> Sure, but that was not the first thing mentioned in the initial message.
>> 
> 
> 
> int P(ptr2 x)
> {
>    int Halt_Status = H(x, x);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
> 
> The call from P to H(P,P) when P is correctly emulated
> by H cannot possibly return.
> 
> The call from P to H(P,P) when P is correctly emulated
> by H1 DOES return.

Those two claims don't actually claim anything without a definition
of "correctly emulated" and a proof that they are correctly emlulated
both by H and H1.

-- 
Mikko

[toc] | [prev] | [next] | [standalone]

Page 4 of 5 — ← Prev page 1 2 3 [4] 5  Next page →

Back to top | Article view | comp.theory

csiph-web