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

Groups > comp.theory > #104261 > unrolled thread

D(D) simulated by H cannot possibly reach past its own line 03

Back to article view | Back to comp.theory

Contents

  D(D) simulated by H cannot possibly reach past its own line 03 olcott <polcott333@gmail.com> - 2024-05-03 08:40 -0500
    Re: D(D) simulated by H cannot possibly reach past its own line 03 Richard Damon <richard@damon-family.org> - 2024-05-03 17:53 -0400
      Re: D(D) simulated by H cannot possibly reach past its own line 03 olcott <polcott333@gmail.com> - 2024-05-03 21:32 -0500
        Re: D(D) simulated by H cannot possibly reach past its own line 03 Richard Damon <richard@damon-family.org> - 2024-05-04 08:55 -0400
    Re: D(D) simulated by H cannot possibly reach past its own line 03 olcott <polcott333@gmail.com> - 2024-05-03 17:42 -0500
      Re: D(D) simulated by H cannot possibly reach past its own line 03 olcott <polcott333@gmail.com> - 2024-05-03 18:55 -0500
        Re: D(D) simulated by H cannot possibly reach past its own line 03 Richard Damon <richard@damon-family.org> - 2024-05-04 08:56 -0400
      Re: D(D) simulated by H cannot possibly reach past its own line 03 Richard Damon <richard@damon-family.org> - 2024-05-03 23:11 -0400
    Re: D(D) simulated by H cannot possibly reach past its own line 03 olcott <polcott333@gmail.com> - 2024-05-03 19:13 -0500
      Re: D(D) simulated by H cannot possibly reach past its own line 03 Richard Damon <richard@damon-family.org> - 2024-05-03 23:24 -0400
        Re: D(D) simulated by H cannot possibly reach past its own line 03 olcott <polcott333@gmail.com> - 2024-05-03 22:39 -0500
          Re: D(D) simulated by H cannot possibly reach past its own line 03 Richard Damon <richard@damon-family.org> - 2024-05-04 08:59 -0400
    Re: D(D) simulated by H cannot possibly reach past its own line 03 "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-02 11:50 +0200
      Re: D(D) simulated by H cannot possibly reach past its own line 03 olcott <polcott333@gmail.com> - 2024-06-02 09:50 -0500
        Re: D(D) simulated by H cannot possibly reach past its own line 03 Mikko <mikko.levanto@iki.fi> - 2024-06-03 10:39 +0300
          Re: D(D) simulated by H cannot possibly reach past its own line 03 olcott <polcott333@gmail.com> - 2024-06-03 07:25 -0500
            Re: D(D) simulated by H cannot possibly reach past its own line 03 Mikko <mikko.levanto@iki.fi> - 2024-06-03 17:17 +0300
              Re: D(D) simulated by H cannot possibly reach past its own line 03 olcott <polcott333@gmail.com> - 2024-06-03 13:09 -0500
                Re: D(D) simulated by H cannot possibly reach past its own line 03 "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2024-06-03 21:47 +0200
                Re: D(D) simulated by H cannot possibly reach past its own line 03 Richard Damon <richard@damon-family.org> - 2024-06-03 20:56 -0400
                Re: D(D) simulated by H cannot possibly reach past its own line 03 joes <noreply@example.com> - 2024-06-04 08:19 +0000
                  Re: D(D) simulated by H cannot possibly reach past its own line 03 olcott <polcott333@gmail.com> - 2024-06-04 12:30 -0500
                Re: D(D) simulated by H cannot possibly reach past its own line 03 Mikko <mikko.levanto@iki.fi> - 2024-06-05 10:05 +0300
                  Re: D(D) simulated by H cannot possibly reach past its own line 03 olcott <polcott333@gmail.com> - 2024-06-05 08:05 -0500
                    Re: D(D) simulated by H cannot possibly reach past its own line 03 joes <noreply@example.com> - 2024-06-05 18:07 +0000
                    Re: D(D) simulated by H cannot possibly reach past its own line 03 Mikko <mikko.levanto@iki.fi> - 2024-06-06 11:07 +0300
                      Re: D(D) simulated by H cannot possibly reach past its own line 03 olcott <polcott333@gmail.com> - 2024-06-06 08:04 -0500
                    Re: D(D) simulated by H cannot possibly reach past its own line 03 immibis <news2@immibis.com> - 2024-06-07 16:25 +0200

Page 2 of 2 — ← Prev page 1 [2]

#106226

Am Mon, 03 Jun 2024 13:09:30 -0500 schrieb olcott:
> On 6/3/2024 9:17 AM, Mikko wrote:
>> On 2024-06-03 12:25:48 +0000, olcott said:
>>> On 6/3/2024 2:39 AM, Mikko wrote:
>>>> On 2024-06-02 14:50:26 +0000, olcott said:
>>>>> On 6/2/2024 4:50 AM, Fred. Zwarts wrote:
>>>>>> Op 03.mei.2024 om 15:40 schreef olcott:

>>>>> Already addressed in another reply.
>>>>
>>>> Which reply? The one where you said you made a mistake? Or typo?
>>>>
>>> I am not going to answer the same question from multiple people.
>> 
>> Your choice. But you can't keep multiple people from seeing your lack
>> of answer.
> This is my canned reply that no one has attempted to refute because they
> know it is irrefutable. When we are analyzing x86 code and someone
> disagrees that is like disagreeing that 2 + 3 = 5.
If you regard it as irrefutable, you may ignore all attempts to do so.
No need to spam it.

> That is why it is essential that I get agreement on the x86/C code
> before moving on to Turing Machines. If they are going to lie about
> arithmetic we cannot trust them with more complex math.
> 
> DD correctly emulated by any HH that can possibly exist DOES NOT HALT
Then H also doesn't halt, making it not a decider.

-- 
joes

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

#106250

On 6/4/2024 3:19 AM, joes wrote:
> Am Mon, 03 Jun 2024 13:09:30 -0500 schrieb olcott:
>> On 6/3/2024 9:17 AM, Mikko wrote:
>>> On 2024-06-03 12:25:48 +0000, olcott said:
>>>> On 6/3/2024 2:39 AM, Mikko wrote:
>>>>> On 2024-06-02 14:50:26 +0000, olcott said:
>>>>>> On 6/2/2024 4:50 AM, Fred. Zwarts wrote:
>>>>>>> Op 03.mei.2024 om 15:40 schreef olcott:
> 
>>>>>> Already addressed in another reply.
>>>>>
>>>>> Which reply? The one where you said you made a mistake? Or typo?
>>>>>
>>>> I am not going to answer the same question from multiple people.
>>>
>>> Your choice. But you can't keep multiple people from seeing your lack
>>> of answer.
>> This is my canned reply that no one has attempted to refute because they
>> know it is irrefutable. When we are analyzing x86 code and someone
>> disagrees that is like disagreeing that 2 + 3 = 5.
> If you regard it as irrefutable, you may ignore all attempts to do so.
> No need to spam it.
> 
>> That is why it is essential that I get agreement on the x86/C code
>> before moving on to Turing Machines. If they are going to lie about
>> arithmetic we cannot trust them with more complex math.
>>
>> DD correctly emulated by any HH that can possibly exist DOES NOT HALT
> Then H also doesn't halt, making it not a decider.
> 

*Not at all as I prove right here*
Published hundreds of times here any other places,
now publishing it again right here:

On 6/4/2024 11:28 AM, olcott wrote:
[Proof that executed HH(DD,DD) and simulated HH(DD,DD)
  simulate DD correctly -- Mike Terry]

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

#106290

On 2024-06-03 18:09:30 +0000, olcott said:

> On 6/3/2024 9:17 AM, Mikko wrote:
>> On 2024-06-03 12:25:48 +0000, olcott said:
>> 
>>> On 6/3/2024 2:39 AM, Mikko wrote:
>>>> On 2024-06-02 14:50:26 +0000, olcott said:
>>>> 
>>>>> On 6/2/2024 4:50 AM, Fred. Zwarts wrote:
>>>>>> Op 03.mei.2024 om 15:40 schreef olcott:
>>>>>>> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
>>>>>>> 01 int D(ptr x)
>>>>>>> 02 {
>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>> 04   if (Halt_Status)
>>>>>>> 05     HERE: goto HERE;
>>>>>>> 06   return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 void main()
>>>>>>> 10 {
>>>>>>> 11   H(D,D);
>>>>>>> 12 }
>>>>>>> 
>>>>>>> We are examining the behavior of D(D) for every possible H/D pair
>>>>>>> where 1 to N steps of D(D) are simulated by H.
>>>>>>> 
>>>>>>> *Execution Trace*
>>>>>>> Line 11: main() invokes H(D,D) that simulates D(D)
>>>>>>> 
>>>>>>> *keeps repeating* (unless aborted)
>>>>>>> Line 01
>>>>>>> Line 02
>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>> 
>>>>>>> *Simulation invariant*
>>>>>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>>>> 
>>>>>> The Linz proof is based on the pathological relation ship that D 
>>>>>> contradicts the result of H. This is expressed in lines 04, 05, 06 of 
>>>>>> D, above.
>>>>>> It is strange that olcott claims that the simulation never sees the 
>>>>>> pathological part of D. He now seems to shift the meaning of 
>>>>>> pathological to the mere fact that D calls H. Lines 04, 05, and 06 are 
>>>>>> completely irrelevant.
>>>>>> In fact, any function that calls H now become pathological.
>>>>>> 
>>>>>> E.G. if we replace D with a function P that only returns its own Halt_Status:
>>>>>> 
>>>>>> 01 int P(ptr x)
>>>>>> 02 {
>>>>>> 03   int Halt_Status = H(x, x);
>>>>>> 04
>>>>>> 05
>>>>>> 06   return Halt_Status;
>>>>>> 07 }
>>>>>> 
>>>>>> Then we would normally expect that, because H is required to halt, P 
>>>>>> would halt as well. But the simulation of P by H does not halt. So, P, 
>>>>>> when it halts, reports that it not halting.
>>>>>> 
>>>>>> The problem here is, that H is unable to simulate itself to its final 
>>>>>> state. That has no relation with the Linz proof, it is a problem of H.
>>>>>> 
>>>>>> So, there is another *Simulation invariant*
>>>>>> H correctly simulated by H cannot possibly reach its own return.
>>>>>> 
>>>>> 
>>>>> Already addressed in another reply.
>>>> 
>>>> Which reply? The one where you said you made a mistake? Or typo?
>>>> 
>>> 
>>> I am not going to answer the same question from multiple people.
>> 
>> Your choice. But you can't keep multiple people from seeing your
>> lack of answer.
>> 
> 
> This is my canned reply that no one has attempted to refute because
> they know it is irrefutable. When we are analyzing x86 code and
> someone disagrees that is like disagreeing that 2 + 3 = 5.

The code has been anylzed by several people so carefully that
any disagreement really is like s like disagreeing that 2 + 3 = 5.
But you disagree anyway:

> DD correctly emulated by any HH that can possibly exist DOES NOT HALT

-- 
Mikko

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

#106308

On 6/5/2024 2:05 AM, Mikko wrote:
> On 2024-06-03 18:09:30 +0000, olcott said:
> 
>> On 6/3/2024 9:17 AM, Mikko wrote:
>>> On 2024-06-03 12:25:48 +0000, olcott said:
>>>
>>>> On 6/3/2024 2:39 AM, Mikko wrote:
>>>>> On 2024-06-02 14:50:26 +0000, olcott said:
>>>>>
>>>>>> On 6/2/2024 4:50 AM, Fred. Zwarts wrote:
>>>>>>> Op 03.mei.2024 om 15:40 schreef olcott:
>>>>>>>> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
>>>>>>>> 01 int D(ptr x)
>>>>>>>> 02 {
>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>> 04   if (Halt_Status)
>>>>>>>> 05     HERE: goto HERE;
>>>>>>>> 06   return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 void main()
>>>>>>>> 10 {
>>>>>>>> 11   H(D,D);
>>>>>>>> 12 }
>>>>>>>>
>>>>>>>> We are examining the behavior of D(D) for every possible H/D pair
>>>>>>>> where 1 to N steps of D(D) are simulated by H.
>>>>>>>>
>>>>>>>> *Execution Trace*
>>>>>>>> Line 11: main() invokes H(D,D) that simulates D(D)
>>>>>>>>
>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>> Line 01
>>>>>>>> Line 02
>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates 
>>>>>>>> D(D)
>>>>>>>>
>>>>>>>> *Simulation invariant*
>>>>>>>> D correctly simulated by H cannot possibly reach past its own 
>>>>>>>> line 03.
>>>>>>>
>>>>>>> The Linz proof is based on the pathological relation ship that D 
>>>>>>> contradicts the result of H. This is expressed in lines 04, 05, 
>>>>>>> 06 of D, above.
>>>>>>> It is strange that olcott claims that the simulation never sees 
>>>>>>> the pathological part of D. He now seems to shift the meaning of 
>>>>>>> pathological to the mere fact that D calls H. Lines 04, 05, and 
>>>>>>> 06 are completely irrelevant.
>>>>>>> In fact, any function that calls H now become pathological.
>>>>>>>
>>>>>>> E.G. if we replace D with a function P that only returns its own 
>>>>>>> Halt_Status:
>>>>>>>
>>>>>>> 01 int P(ptr x)
>>>>>>> 02 {
>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>> 04
>>>>>>> 05
>>>>>>> 06   return Halt_Status;
>>>>>>> 07 }
>>>>>>>
>>>>>>> Then we would normally expect that, because H is required to 
>>>>>>> halt, P would halt as well. But the simulation of P by H does not 
>>>>>>> halt. So, P, when it halts, reports that it not halting.
>>>>>>>
>>>>>>> The problem here is, that H is unable to simulate itself to its 
>>>>>>> final state. That has no relation with the Linz proof, it is a 
>>>>>>> problem of H.
>>>>>>>
>>>>>>> So, there is another *Simulation invariant*
>>>>>>> H correctly simulated by H cannot possibly reach its own return.
>>>>>>>
>>>>>>
>>>>>> Already addressed in another reply.
>>>>>
>>>>> Which reply? The one where you said you made a mistake? Or typo?
>>>>>
>>>>
>>>> I am not going to answer the same question from multiple people.
>>>
>>> Your choice. But you can't keep multiple people from seeing your
>>> lack of answer.
>>>
>>
>> This is my canned reply that no one has attempted to refute because
>> they know it is irrefutable. When we are analyzing x86 code and
>> someone disagrees that is like disagreeing that 2 + 3 = 5.
> 
> The code has been anylzed by several people so carefully that
> any disagreement really is like s like disagreeing that 2 + 3 = 5.
> But you disagree anyway:
> 

It has been "analyzed" by dogmatic assertions utterly bereft
of any supporting reasoning. It is empirically proven that
the behavior of the directly executed DD(DD) is different
than the behavior of DD correctly simulated by HH. People
can lie about this yet cannot possibly show otherwise.

*Here is the complete proof all over again all in one place*
https://liarparadox.org/DD_correctly_simulated_by_HH_is_Proven.pdf


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

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

#106334

Am Wed, 05 Jun 2024 08:05:11 -0500 schrieb olcott:
> On 6/5/2024 2:05 AM, Mikko wrote:
>> On 2024-06-03 18:09:30 +0000, olcott said:
>>> On 6/3/2024 9:17 AM, Mikko wrote:
>>>> On 2024-06-03 12:25:48 +0000, olcott said:
>>>>> On 6/3/2024 2:39 AM, Mikko wrote:
>>>>>> On 2024-06-02 14:50:26 +0000, olcott said:
>>>>>>> On 6/2/2024 4:50 AM, Fred. Zwarts wrote:
>>>>>>>> Op 03.mei.2024 om 15:40 schreef olcott:

>> The code has been anylzed by several people so carefully that any
>> disagreement really is like s like disagreeing that 2 + 3 = 5.
>> But you disagree anyway:
>> 
> It has been "analyzed" by dogmatic assertions utterly bereft of any
> supporting reasoning. It is empirically proven that the behavior of the
> directly executed DD(DD) is different than the behavior of DD correctly
> simulated by HH. People can lie about this yet cannot possibly show
> otherwise.
How can a simulation be correct that behaves differently than the direct
execution?

-- 
joes

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

#106379

On 2024-06-05 13:05:11 +0000, olcott said:

> On 6/5/2024 2:05 AM, Mikko wrote:
>> On 2024-06-03 18:09:30 +0000, olcott said:
>> 
>>> On 6/3/2024 9:17 AM, Mikko wrote:
>>>> On 2024-06-03 12:25:48 +0000, olcott said:
>>>> 
>>>>> On 6/3/2024 2:39 AM, Mikko wrote:
>>>>>> On 2024-06-02 14:50:26 +0000, olcott said:
>>>>>> 
>>>>>>> On 6/2/2024 4:50 AM, Fred. Zwarts wrote:
>>>>>>>> Op 03.mei.2024 om 15:40 schreef olcott:
>>>>>>>>> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
>>>>>>>>> 01 int D(ptr x)
>>>>>>>>> 02 {
>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>> 06   return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 void main()
>>>>>>>>> 10 {
>>>>>>>>> 11   H(D,D);
>>>>>>>>> 12 }
>>>>>>>>> 
>>>>>>>>> We are examining the behavior of D(D) for every possible H/D pair
>>>>>>>>> where 1 to N steps of D(D) are simulated by H.
>>>>>>>>> 
>>>>>>>>> *Execution Trace*
>>>>>>>>> Line 11: main() invokes H(D,D) that simulates D(D)
>>>>>>>>> 
>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>> Line 01
>>>>>>>>> Line 02
>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>>>> 
>>>>>>>>> *Simulation invariant*
>>>>>>>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>>>>>> 
>>>>>>>> The Linz proof is based on the pathological relation ship that D 
>>>>>>>> contradicts the result of H. This is expressed in lines 04, 05, 06 of 
>>>>>>>> D, above.
>>>>>>>> It is strange that olcott claims that the simulation never sees the 
>>>>>>>> pathological part of D. He now seems to shift the meaning of 
>>>>>>>> pathological to the mere fact that D calls H. Lines 04, 05, and 06 are 
>>>>>>>> completely irrelevant.
>>>>>>>> In fact, any function that calls H now become pathological.
>>>>>>>> 
>>>>>>>> E.G. if we replace D with a function P that only returns its own Halt_Status:
>>>>>>>> 
>>>>>>>> 01 int P(ptr x)
>>>>>>>> 02 {
>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>> 04
>>>>>>>> 05
>>>>>>>> 06   return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 
>>>>>>>> Then we would normally expect that, because H is required to halt, P 
>>>>>>>> would halt as well. But the simulation of P by H does not halt. So, P, 
>>>>>>>> when it halts, reports that it not halting.
>>>>>>>> 
>>>>>>>> The problem here is, that H is unable to simulate itself to its final 
>>>>>>>> state. That has no relation with the Linz proof, it is a problem of H.
>>>>>>>> 
>>>>>>>> So, there is another *Simulation invariant*
>>>>>>>> H correctly simulated by H cannot possibly reach its own return.
>>>>>>>> 
>>>>>>> 
>>>>>>> Already addressed in another reply.
>>>>>> 
>>>>>> Which reply? The one where you said you made a mistake? Or typo?
>>>>>> 
>>>>> 
>>>>> I am not going to answer the same question from multiple people.
>>>> 
>>>> Your choice. But you can't keep multiple people from seeing your
>>>> lack of answer.
>>>> 
>>> 
>>> This is my canned reply that no one has attempted to refute because
>>> they know it is irrefutable. When we are analyzing x86 code and
>>> someone disagrees that is like disagreeing that 2 + 3 = 5.
>> 
>> The code has been anylzed by several people so carefully that
>> any disagreement really is like s like disagreeing that 2 + 3 = 5.
>> But you disagree anyway:
>> 
> 
> It has been "analyzed" by dogmatic assertions utterly bereft
> of any supporting reasoning.

So it has, at least by you.

> It is empirically proven that the behavior of the directly executed
> DD(DD) is different than the behavior of DD correctly simulated by
> HH.

Empirical observations are not an analysis. They do not prove about
the same as an analysis so cannot contradict. Any demonstration of
any relation between the two requires a careful comparison the details
of each, for example whether the HH in the empirical proof is similar
enough to H in the analysis.

> People can lie about this yet cannot possibly show otherwise.

That is the restriction of some people, for example you. But some have
shown otherwise. They needn't to show it to you but for someone not yet
familiar with the topic those demonstrations can be useful.

-- 
Mikko

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

#106390

On 6/6/2024 3:07 AM, Mikko wrote:
> On 2024-06-05 13:05:11 +0000, olcott said:
> 
>> On 6/5/2024 2:05 AM, Mikko wrote:
>>> On 2024-06-03 18:09:30 +0000, olcott said:
>>>
>>>> On 6/3/2024 9:17 AM, Mikko wrote:
>>>>> On 2024-06-03 12:25:48 +0000, olcott said:
>>>>>
>>>>>> On 6/3/2024 2:39 AM, Mikko wrote:
>>>>>>> On 2024-06-02 14:50:26 +0000, olcott said:
>>>>>>>
>>>>>>>> On 6/2/2024 4:50 AM, Fred. Zwarts wrote:
>>>>>>>>> Op 03.mei.2024 om 15:40 schreef olcott:
>>>>>>>>>> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
>>>>>>>>>> 01 int D(ptr x)
>>>>>>>>>> 02 {
>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>> 07 }
>>>>>>>>>> 08
>>>>>>>>>> 09 void main()
>>>>>>>>>> 10 {
>>>>>>>>>> 11   H(D,D);
>>>>>>>>>> 12 }
>>>>>>>>>>
>>>>>>>>>> We are examining the behavior of D(D) for every possible H/D pair
>>>>>>>>>> where 1 to N steps of D(D) are simulated by H.
>>>>>>>>>>
>>>>>>>>>> *Execution Trace*
>>>>>>>>>> Line 11: main() invokes H(D,D) that simulates D(D)
>>>>>>>>>>
>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>> Line 01
>>>>>>>>>> Line 02
>>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that 
>>>>>>>>>> simulates D(D)
>>>>>>>>>>
>>>>>>>>>> *Simulation invariant*
>>>>>>>>>> D correctly simulated by H cannot possibly reach past its own 
>>>>>>>>>> line 03.
>>>>>>>>>
>>>>>>>>> The Linz proof is based on the pathological relation ship that 
>>>>>>>>> D contradicts the result of H. This is expressed in lines 04, 
>>>>>>>>> 05, 06 of D, above.
>>>>>>>>> It is strange that olcott claims that the simulation never sees 
>>>>>>>>> the pathological part of D. He now seems to shift the meaning 
>>>>>>>>> of pathological to the mere fact that D calls H. Lines 04, 05, 
>>>>>>>>> and 06 are completely irrelevant.
>>>>>>>>> In fact, any function that calls H now become pathological.
>>>>>>>>>
>>>>>>>>> E.G. if we replace D with a function P that only returns its 
>>>>>>>>> own Halt_Status:
>>>>>>>>>
>>>>>>>>> 01 int P(ptr x)
>>>>>>>>> 02 {
>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>> 04
>>>>>>>>> 05
>>>>>>>>> 06   return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>>
>>>>>>>>> Then we would normally expect that, because H is required to 
>>>>>>>>> halt, P would halt as well. But the simulation of P by H does 
>>>>>>>>> not halt. So, P, when it halts, reports that it not halting.
>>>>>>>>>
>>>>>>>>> The problem here is, that H is unable to simulate itself to its 
>>>>>>>>> final state. That has no relation with the Linz proof, it is a 
>>>>>>>>> problem of H.
>>>>>>>>>
>>>>>>>>> So, there is another *Simulation invariant*
>>>>>>>>> H correctly simulated by H cannot possibly reach its own return.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Already addressed in another reply.
>>>>>>>
>>>>>>> Which reply? The one where you said you made a mistake? Or typo?
>>>>>>>
>>>>>>
>>>>>> I am not going to answer the same question from multiple people.
>>>>>
>>>>> Your choice. But you can't keep multiple people from seeing your
>>>>> lack of answer.
>>>>>
>>>>
>>>> This is my canned reply that no one has attempted to refute because
>>>> they know it is irrefutable. When we are analyzing x86 code and
>>>> someone disagrees that is like disagreeing that 2 + 3 = 5.
>>>
>>> The code has been anylzed by several people so carefully that
>>> any disagreement really is like s like disagreeing that 2 + 3 = 5.
>>> But you disagree anyway:
>>>
>>
>> It has been "analyzed" by dogmatic assertions utterly bereft
>> of any supporting reasoning.
> 
> So it has, at least by you.
> 
>> It is empirically proven that the behavior of the directly executed
>> DD(DD) is different than the behavior of DD correctly simulated by
>> HH.
> 
> Empirical observations are not an analysis. 

Try any show how this DD can be correctly simulated by any HH
such that this DD reaches past its machine address [00001dbe]

_DD()
[00001e12] 55         push ebp
[00001e13] 8bec       mov  ebp,esp
[00001e15] 51         push ecx
[00001e16] 8b4508     mov  eax,[ebp+08]
[00001e19] 50         push eax      ; push DD
[00001e1a] 8b4d08     mov  ecx,[ebp+08]
[00001e1d] 51         push ecx      ; push DD
[00001e1e] e85ff5ffff call 00001382 ; call HH

> They do not prove about
> the same as an analysis so cannot contradict. Any demonstration of
> any relation between the two requires a careful comparison the details
> of each, for example whether the HH in the empirical proof is similar
> enough to H in the analysis.
> 
>> People can lie about this yet cannot possibly show otherwise.
> 
> That is the restriction of some people, for example you. But some have
> shown otherwise. They needn't to show it to you but for someone not yet
> familiar with the topic those demonstrations can be useful.
> 

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

#106469

On 5/06/24 15:05, olcott wrote:
> It has been "analyzed" by dogmatic assertions utterly bereft
> of any supporting reasoning.

> It is empirically proven that
> the behavior of the directly executed DD(DD) is different
> than the behavior of DD correctly simulated by HH.

Speaking of "dogmatic assertions utterly bereft of any supporting 
reasoning"...

[toc] | [prev] | [standalone]

Page 2 of 2 — ← Prev page 1 [2]

Back to top | Article view | comp.theory

csiph-web