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 1 of 2  [1] 2  Next page →

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

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.

(a) It is a verified fact that for every possible H/D pair where
1 to N steps of D(D) are simulated by H that this simulated D(D)
cannot possibly reach past its own line 03.

(b) Rebuttals must show a counter example where 1 to N steps
of D(D) are simulated by H and the simulated D(D) reaches past
its own line 03.

*Termination Analyzer H is Not Fooled by Pathological Input D*
https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D 


*Fully operational code implemented in the x86utm operating system*
https://github.com/plolcott/x86utm



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

[toc] | [next] | [standalone]

#104273

On 5/3/24 9:40 AM, olcott wrote:
> 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.
> 
> (a) It is a verified fact that for every possible H/D pair where
> 1 to N steps of D(D) are simulated by H that this simulated D(D)
> cannot possibly reach past its own line 03.

Nope.

> 
> (b) Rebuttals must show a counter example where 1 to N steps
> of D(D) are simulated by H and the simulated D(D) reaches past
> its own line 03.

WAS DONE.

> 
> *Termination Analyzer H is Not Fooled by Pathological Input D*
> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
> 
> *Fully operational code implemented in the x86utm operating system*
> https://github.com/plolcott/x86utm
> 
> 
> 

Proven wrong, and you have declined to try to refute that proof.

If you claim I haven't done this, make a clear statement of that claim, 
with a clear statement that if I can point out where I did this, and you 
failed to respond, you will admit that you are just wrong and will admit 
that you logic is just broken and will give up the statement that people 
haven't refuted you.

Unitl then, you have effectively conceded that you statement is just 
FALSE, and your repeating it is just demonstration that are just a 
pathological liar that doesn't understand what he is talking abour.

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

#104284

On 5/3/2024 4:53 PM, Richard Damon wrote:
> On 5/3/24 9:40 AM, olcott wrote:
>> 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.
>>
>> (a) It is a verified fact that for every possible H/D pair where
>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>> cannot possibly reach past its own line 03.
> 
> Nope.
> 

*This only requires knowing two things*
(1) What an execution trace is and how it works.
You seem to know that other people here do not.

(2) When the executed H(D,D) aborts its simulated input
that all of the nested simulations (if any) immediately
totally stop running. No simulated H ever returns any value
to any simulated D.

*This seems to be over your head and you don't know it*

>>
>> (b) Rebuttals must show a counter example where 1 to N steps
>> of D(D) are simulated by H and the simulated D(D) reaches past
>> its own line 03.
> 
> WAS DONE.
> 
>>
>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>
>> *Fully operational code implemented in the x86utm operating system*
>> https://github.com/plolcott/x86utm
>>
>>
>>
> 
> Proven wrong, and you have declined to try to refute that proof.
> 
> If you claim I haven't done this, make a clear statement of that claim, 
> with a clear statement that if I can point out where I did this, and you 
> failed to respond, you will admit that you are just wrong and will admit 
> that you logic is just broken and will give up the statement that people 
> haven't refuted you.
> 
> Unitl then, you have effectively conceded that you statement is just 
> FALSE, and your repeating it is just demonstration that are just a 
> pathological liar that doesn't understand what he is talking abour.

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

#104309

On 5/3/24 10:32 PM, olcott wrote:
> On 5/3/2024 4:53 PM, Richard Damon wrote:
>> On 5/3/24 9:40 AM, olcott wrote:
>>> 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.
>>>
>>> (a) It is a verified fact that for every possible H/D pair where
>>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>>> cannot possibly reach past its own line 03.
>>
>> Nope.
>>
> 
> *This only requires knowing two things*
> (1) What an execution trace is and how it works.
> You seem to know that other people here do not.


Proven otherwise and ignored by you, proving you are just a pathological 
liar.

> 
> (2) When the executed H(D,D) aborts its simulated input
> that all of the nested simulations (if any) immediately
> totally stop running. No simulated H ever returns any value
> to any simulated D.
> 
> *This seems to be over your head and you don't know it*

Nope, it stops the SIMULATION of all the programs nested in it, but does 
not stop the BEHAVIOR of those programs, as that is defined by the 
direct execution of it.

This seems over YOUR head.

> 
>>>
>>> (b) Rebuttals must show a counter example where 1 to N steps
>>> of D(D) are simulated by H and the simulated D(D) reaches past
>>> its own line 03.
>>
>> WAS DONE.
>>
>>>
>>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>>
>>> *Fully operational code implemented in the x86utm operating system*
>>> https://github.com/plolcott/x86utm
>>>
>>>
>>>
>>
>> Proven wrong, and you have declined to try to refute that proof.
>>
>> If you claim I haven't done this, make a clear statement of that 
>> claim, with a clear statement that if I can point out where I did 
>> this, and you failed to respond, you will admit that you are just 
>> wrong and will admit that you logic is just broken and will give up 
>> the statement that people haven't refuted you.
>>
>> Unitl then, you have effectively conceded that you statement is just 
>> FALSE, and your repeating it is just demonstration that are just a 
>> pathological liar that doesn't understand what he is talking abour.
> 

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

#104276

On 5/3/2024 8:40 AM, olcott wrote:
> 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.
> 
> (a) It is a verified fact that for every possible H/D pair where
> 1 to N steps of D(D) are simulated by H that this simulated D(D)
> cannot possibly reach past its own line 03.

Since everyone is denying these facts on the basis that no one
here has a clue about what execution traces are and how they work
it makes no sense to go to the next step.

> 
> (b) Rebuttals must show a counter example where 1 to N steps
> of D(D) are simulated by H and the simulated D(D) reaches past
> its own line 03.
> 
> *Termination Analyzer H is Not Fooled by Pathological Input D*
> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
> 
> *Fully operational code implemented in the x86utm operating system*
> https://github.com/plolcott/x86utm
> 
> 
> 

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

#104278

On 5/3/2024 5:42 PM, olcott wrote:
> On 5/3/2024 8:40 AM, olcott wrote:
>> 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.
>>
>> (a) It is a verified fact that for every possible H/D pair where
>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>> cannot possibly reach past its own line 03.
> 
> Since everyone is denying these facts on the basis that no one
> here has a clue about what execution traces are and how they work
> it makes no sense to go to the next step.
> 

The next step depends on this prior step and is trivially
entailed by this prior step. When each D simulated by H
of the infinite set of H/D pairs cannot possibly reach past
its own line 03 then it cannot possibly reach its own line
06 and halt.

There is one more software engineering step that depends
on the above steps and is trivially entailed by the above
step. After this last software engineering step we begin
to get into the computer science steps.

>>
>> (b) Rebuttals must show a counter example where 1 to N steps
>> of D(D) are simulated by H and the simulated D(D) reaches past
>> its own line 03.
>>
>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>
>> *Fully operational code implemented in the x86utm operating system*
>> https://github.com/plolcott/x86utm
>>
>>
>>
> 

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

#104310

On 5/3/24 7:55 PM, olcott wrote:
> On 5/3/2024 5:42 PM, olcott wrote:
>> On 5/3/2024 8:40 AM, olcott wrote:
>>> 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.
>>>
>>> (a) It is a verified fact that for every possible H/D pair where
>>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>>> cannot possibly reach past its own line 03.
>>
>> Since everyone is denying these facts on the basis that no one
>> here has a clue about what execution traces are and how they work
>> it makes no sense to go to the next step.
>>
> 
> The next step depends on this prior step and is trivially
> entailed by this prior step. When each D simulated by H
> of the infinite set of H/D pairs cannot possibly reach past
> its own line 03 then it cannot possibly reach its own line
> 06 and halt.
> 
> There is one more software engineering step that depends
> on the above steps and is trivially entailed by the above
> step. After this last software engineering step we begin
> to get into the computer science steps.
> 

And since that step is wrong, you need to go back and fix it.

Your (a) has been proven INCORRECT, and descriptions of TWO DIFFERENT 
methods that an H could use to get past there described.

Your ignoring them just proves you are just a pathological liar.


>>>
>>> (b) Rebuttals must show a counter example where 1 to N steps
>>> of D(D) are simulated by H and the simulated D(D) reaches past
>>> its own line 03.
>>>
>>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>>
>>> *Fully operational code implemented in the x86utm operating system*
>>> https://github.com/plolcott/x86utm
>>>
>>>
>>>
>>
> 

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

#104293

On 5/3/24 6:42 PM, olcott wrote:
> On 5/3/2024 8:40 AM, olcott wrote:
>> 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.
>>
>> (a) It is a verified fact that for every possible H/D pair where
>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>> cannot possibly reach past its own line 03.
> 
> Since everyone is denying these facts on the basis that no one
> here has a clue about what execution traces are and how they work
> it makes no sense to go to the next step.

(a) has been proven incorrect.

If you won't make the effort to try to refute that proof, you are just 
admitting that you are not interested in an honest dialog.

Of course people won't accept a step that is known to be incorrect.

If you won't handle the objections, YOU are the one holding up your 
progress.

> 
>>
>> (b) Rebuttals must show a counter example where 1 to N steps
>> of D(D) are simulated by H and the simulated D(D) reaches past
>> its own line 03.

Which it was.

>>
>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>
>> *Fully operational code implemented in the x86utm operating system*
>> https://github.com/plolcott/x86utm
>>
>>
>>
> 

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

#104279

On 5/3/2024 8:40 AM, olcott wrote:
> 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.
> 
> (a) It is a verified fact that for every possible H/D pair where
> 1 to N steps of D(D) are simulated by H that this simulated D(D)
> cannot possibly reach past its own line 03.
> 

I only had to add this new step because I found that some people just
do not understand that when the executed H(D,D) aborts its simulated
input that all of the nested simulations (if any) immediately totally 
stop running. No simulated H ever returns any value to any simulated D.
We can sum this up much more concisely with (a).

> (b) Rebuttals must show a counter example where 1 to N steps
> of D(D) are simulated by H and the simulated D(D) reaches past
> its own line 03.
> 
> *Termination Analyzer H is Not Fooled by Pathological Input D*
> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
> 
> *Fully operational code implemented in the x86utm operating system*
> https://github.com/plolcott/x86utm
> 
> 
> 

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

#104294

On 5/3/24 8:13 PM, olcott wrote:
> On 5/3/2024 8:40 AM, olcott wrote:
>> 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.
>>
>> (a) It is a verified fact that for every possible H/D pair where
>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>> cannot possibly reach past its own line 03.
>>
> 
> I only had to add this new step because I found that some people just
> do not understand that when the executed H(D,D) aborts its simulated
> input that all of the nested simulations (if any) immediately totally 
> stop running. No simulated H ever returns any value to any simulated D.
> We can sum this up much more concisely with (a).

Fixing definitions is good.

The refutation of (a) that I gave didn't use that "loop hole" and both 
of the examples actually simulated the steps to past line 3.

After all, how can you simulate past line 3 and not simulate any steps?

The no-simulation case was just showing that using your conclusion from 
(a) and saying that H is correct to abort here, allows, with just as 
valid of logic, to allow a decider to trivally decide to abort either 
after 0, or with your modification, after 1 step, to just abort and say 
it couldn't reach the end.

> 
>> (b) Rebuttals must show a counter example where 1 to N steps
>> of D(D) are simulated by H and the simulated D(D) reaches past
>> its own line 03.

Was done.

You need to refute that example or you are just admitting you are a liar 
that makes claims that have been disproven.

The fact that you don't understand how it was disproven, the fact that 
you know that the statements were made and you haven't refuted it, means 
your claims have become unproven statements, and thus not valid to claim.

>>
>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>
>> *Fully operational code implemented in the x86utm operating system*
>> https://github.com/plolcott/x86utm
>>
>>
>>
> 

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

#104298

On 5/3/2024 10:24 PM, Richard Damon wrote:
> On 5/3/24 8:13 PM, olcott wrote:
>> On 5/3/2024 8:40 AM, olcott wrote:
>>> 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.
>>>
>>> (a) It is a verified fact that for every possible H/D pair where
>>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>>> cannot possibly reach past its own line 03.
>>>
>>
>> I only had to add this new step because I found that some people just
>> do not understand that when the executed H(D,D) aborts its simulated
>> input that all of the nested simulations (if any) immediately totally 
>> stop running. No simulated H ever returns any value to any simulated D.
>> We can sum this up much more concisely with (a).
> 
> Fixing definitions is good.
> 
> The refutation of (a) that I gave didn't use that "loop hole" and both 
> of the examples actually simulated the steps to past line 3.
> 
> After all, how can you simulate past line 3 and not simulate any steps?
> 

THIS WAS THE DEFINITION THAT YOU RESPONDED TO
(a) It is a verified fact that *D(D) simulated by H* cannot
possibly reach past line 03 of *D(D) simulated by H* whether
H aborts its simulation or not.

You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
That is a ridiculously stupid mistake.

You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
That is a ridiculously stupid mistake.

You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
That is a ridiculously stupid mistake.

You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
That is a ridiculously stupid mistake.

> The no-simulation case was just showing that using your conclusion from 
> (a) and saying that H is correct to abort here, allows, with just as 
> valid of logic, to allow a decider to trivally decide to abort either 
> after 0, or with your modification, after 1 step, to just abort and say 
> it couldn't reach the end.
> 
>>
>>> (b) Rebuttals must show a counter example where 1 to N steps
>>> of D(D) are simulated by H and the simulated D(D) reaches past
>>> its own line 03.
> 
> Was done.
> 
> You need to refute that example or you are just admitting you are a liar 
> that makes claims that have been disproven.
> 

No I am proving that one of your rebuttals was a ridiculously stupid
mistake. When you make a ridiculously stupid mistake that is not me
lying at all.

If you have a better rebuttal please provide it.

> The fact that you don't understand how it was disproven, the fact that 
> you know that the statements were made and you haven't refuted it, means 
> your claims have become unproven statements, and thus not valid to claim.
> 

*It was not me that made the ridiculously stupid mistake*

>>>
>>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>>
>>> *Fully operational code implemented in the x86utm operating system*
>>> https://github.com/plolcott/x86utm
>>>
>>>
>>>
>>
> 

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

#104311

On 5/3/24 11:39 PM, olcott wrote:
> On 5/3/2024 10:24 PM, Richard Damon wrote:
>> On 5/3/24 8:13 PM, olcott wrote:
>>> On 5/3/2024 8:40 AM, olcott wrote:
>>>> 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.
>>>>
>>>> (a) It is a verified fact that for every possible H/D pair where
>>>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>>>> cannot possibly reach past its own line 03.
>>>>
>>>
>>> I only had to add this new step because I found that some people just
>>> do not understand that when the executed H(D,D) aborts its simulated
>>> input that all of the nested simulations (if any) immediately totally 
>>> stop running. No simulated H ever returns any value to any simulated D.
>>> We can sum this up much more concisely with (a).
>>
>> Fixing definitions is good.
>>
>> The refutation of (a) that I gave didn't use that "loop hole" and both 
>> of the examples actually simulated the steps to past line 3.
>>
>> After all, how can you simulate past line 3 and not simulate any steps?
>>
> 
> THIS WAS THE DEFINITION THAT YOU RESPONDED TO
> (a) It is a verified fact that *D(D) simulated by H* cannot
> possibly reach past line 03 of *D(D) simulated by H* whether
> H aborts its simulation or not.
> 
> You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
> That is a ridiculously stupid mistake.
> 
> You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
> That is a ridiculously stupid mistake.
> 
> You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
> That is a ridiculously stupid mistake.
> 
> You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
> That is a ridiculously stupid mistake.

You are looking at the wrong case and don't even seem to understand what 
I was saying,

THAT example actually took your assumption that (a) was true, and 
thought, based on this statement being true, what can I show, and I 
showed that you can make a valid H that calls almost every input to be 
non-halting.

You donn't seem to actually understand how logic works.


> 
>> The no-simulation case was just showing that using your conclusion 
>> from (a) and saying that H is correct to abort here, allows, with just 
>> as valid of logic, to allow a decider to trivally decide to abort 
>> either after 0, or with your modification, after 1 step, to just abort 
>> and say it couldn't reach the end.
>>
>>>
>>>> (b) Rebuttals must show a counter example where 1 to N steps
>>>> of D(D) are simulated by H and the simulated D(D) reaches past
>>>> its own line 03.
>>
>> Was done.
>>
>> You need to refute that example or you are just admitting you are a 
>> liar that makes claims that have been disproven.
>>
> 
> No I am proving that one of your rebuttals was a ridiculously stupid
> mistake. When you make a ridiculously stupid mistake that is not me
> lying at all.

But you need to prove that ALL my rebuttals don't work.

> 
> If you have a better rebuttal please provide it.

I did. You ignored it.

> 
>> The fact that you don't understand how it was disproven, the fact that 
>> you know that the statements were made and you haven't refuted it, 
>> means your claims have become unproven statements, and thus not valid 
>> to claim.
>>
> 
> *It was not me that made the ridiculously stupid mistake*

Yep, it was.

> 
>>>>
>>>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>>>
>>>> *Fully operational code implemented in the x86utm operating system*
>>>> https://github.com/plolcott/x86utm
>>>>
>>>>
>>>>
>>>
>>
> 

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

#106001

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.

> 
> (a) It is a verified fact that for every possible H/D pair where
> 1 to N steps of D(D) are simulated by H that this simulated D(D)
> cannot possibly reach past its own line 03.

(aa) If so, then it is also a verified fact that for every possible H/D 
pair where1 to N steps of H are simulated by H that the simulated H 
cannot possibly reach to its own return.

> 
> (b) Rebuttals must show a counter example where 1 to N steps
> of D(D) are simulated by H and the simulated D(D) reaches past
> its own line 03.

(bb) Rebuttals must show the trace where 1 to N steps of H are simulated 
by H and the simulated H reaches its return.

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

#106018

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.


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

#106105

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?

-- 
Mikko

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

#106126

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.

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

#106140

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.

-- 
Mikko

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

#106158

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.

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
DD correctly emulated by any HH that can possibly exist DOES NOT HALT
DD correctly emulated by any HH that can possibly exist DOES NOT HALT

typedef int (*ptr)();  // ptr is pointer to int function in C
00       int HH(ptr p, ptr i);
01       int DD(ptr p)
02       {
03         int Halt_Status = HH(p, p);
04         if (Halt_Status)
05           HERE: goto HERE;
06         return Halt_Status;
07       }

_DD()
[00001c22] 55         push ebp
[00001c23] 8bec       mov ebp,esp
[00001c25] 51         push ecx
[00001c26] 8b4508     mov eax,[ebp+08]
[00001c29] 50         push eax        ; push DD 1c22
[00001c2a] 8b4d08     mov ecx,[ebp+08]
[00001c2d] 51         push ecx        ; push DD 1c22
[00001c2e] e80ff7ffff call 00001342   ; call HH
[00001c33] 83c408     add esp,+08
[00001c36] 8945fc     mov [ebp-04],eax
[00001c39] 837dfc00   cmp dword [ebp-04],+00
[00001c3d] 7402       jz 00001c41
[00001c3f] ebfe       jmp 00001c3f
[00001c41] 8b45fc     mov eax,[ebp-04]
[00001c44] 8be5       mov esp,ebp
[00001c46] 5d         pop ebp
[00001c47] c3         ret
Size in bytes:(0038) [00001c47]

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

#106168

Op 03.jun.2024 om 20:09 schreef 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:
>>>>>>> 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.
> 
> 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
> DD correctly emulated by any HH that can possibly exist DOES NOT HALT
> DD correctly emulated by any HH that can possibly exist DOES NOT HALT

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

> 
> typedef int (*ptr)();  // ptr is pointer to int function in C
> 00       int HH(ptr p, ptr i);
> 01       int DD(ptr p)
> 02       {
> 03         int Halt_Status = HH(p, p);
> 04         if (Halt_Status)
> 05           HERE: goto HERE;
> 06         return Halt_Status;
> 07       }
> 
> _DD()
> [00001c22] 55         push ebp
> [00001c23] 8bec       mov ebp,esp
> [00001c25] 51         push ecx
> [00001c26] 8b4508     mov eax,[ebp+08]
> [00001c29] 50         push eax        ; push DD 1c22
> [00001c2a] 8b4d08     mov ecx,[ebp+08]
> [00001c2d] 51         push ecx        ; push DD 1c22
> [00001c2e] e80ff7ffff call 00001342   ; call HH
> [00001c33] 83c408     add esp,+08
> [00001c36] 8945fc     mov [ebp-04],eax
> [00001c39] 837dfc00   cmp dword [ebp-04],+00
> [00001c3d] 7402       jz 00001c41
> [00001c3f] ebfe       jmp 00001c3f
> [00001c41] 8b45fc     mov eax,[ebp-04]
> [00001c44] 8be5       mov esp,ebp
> [00001c46] 5d         pop ebp
> [00001c47] c3         ret
> Size in bytes:(0038) [00001c47]
> 

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

#106190

On 6/3/24 2:09 PM, olcott wrote:
> 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.

And you just use your canned reply,b ecause you don't know how to actual

> 
> 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
> DD correctly emulated by any HH that can possibly exist DOES NOT HALT
> DD correctly emulated by any HH that can possibly exist DOES NOT HALT

But DD DOES HALT!! It has been proven, you just close your eyes to it.

You mean that *this* HH can not simulate DD to a final state. THAT IS 
NOT non-halting.

You have been told this, and ignoring, showing your reckless disregard 
for the truth that make you just an ignorant pathological liar.

> 
> typedef int (*ptr)();  // ptr is pointer to int function in C
> 00       int HH(ptr p, ptr i);
> 01       int DD(ptr p)
> 02       {
> 03         int Halt_Status = HH(p, p);
> 04         if (Halt_Status)
> 05           HERE: goto HERE;
> 06         return Halt_Status;
> 07       }
> 
> _DD()
> [00001c22] 55         push ebp
> [00001c23] 8bec       mov ebp,esp
> [00001c25] 51         push ecx
> [00001c26] 8b4508     mov eax,[ebp+08]
> [00001c29] 50         push eax        ; push DD 1c22
> [00001c2a] 8b4d08     mov ecx,[ebp+08]
> [00001c2d] 51         push ecx        ; push DD 1c22
> [00001c2e] e80ff7ffff call 00001342   ; call HH
> [00001c33] 83c408     add esp,+08
> [00001c36] 8945fc     mov [ebp-04],eax
> [00001c39] 837dfc00   cmp dword [ebp-04],+00
> [00001c3d] 7402       jz 00001c41
> [00001c3f] ebfe       jmp 00001c3f
> [00001c41] 8b45fc     mov eax,[ebp-04]
> [00001c44] 8be5       mov esp,ebp
> [00001c46] 5d         pop ebp
> [00001c47] c3         ret
> Size in bytes:(0038) [00001c47]
> 

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

Page 1 of 2  [1] 2  Next page →

Back to top | Article view | comp.theory

csiph-web