Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  nodelist  faq  login

Unix is a Registered Bell of AT&T Trademark Laboratories. -- Donn Seeley


computers / comp.ai.philosophy / Halting problem undecidability and infinitely nested simulation (V5) (update)

SubjectAuthor
* Halting problem undecidability and infinitely nested simulation (V5)olcott
+- Re: Halting problem undecidability and infinitely nested simulationolcott
+- Re: Halting problem undecidability and infinitely nested simulationMutt Buncher
+* Re: Halting problem undecidability and infinitely nested simulationMr Flibble
|`* Re: Halting problem undecidability and infinitely nested simulationolcott
| +* Re: Halting problem undecidability and infinitely nested simulationMr Flibble
| |`* Re: Halting problem undecidability and infinitely nested simulationolcott
| | `* Re: Halting problem undecidability and infinitely nested simulationMr Flibble
| |  `* Re: Halting problem undecidability and infinitely nested simulationolcott
| |   `* Re: Halting problem undecidability and infinitely nested simulationMr Flibble
| |    `- Re: Halting problem undecidability and infinitely nested simulationolcott
| `* Re: Halting problem undecidability and infinitely nested simulationRichard Damon
|  `* Re: Halting problem undecidability and infinitely nested simulationolcott
|   `* Re: Halting problem undecidability and infinitely nested simulation (V5) (Richard Damon
|    `* Re: Halting problem undecidability and infinitely nested simulationolcott
|     `* Re: Halting problem undecidability and infinitely nested simulationRichard Damon
|      `* Re: Halting problem undecidability and infinitely nested simulationolcott
|       `* Re: Halting problem undecidability and infinitely nested simulation (V5) (Richard Damon
|        `* Re: Halting problem undecidability and infinitely nested simulationolcott
|         `- Re: Halting problem undecidability and infinitely nested simulationRichard Damon
`- Re: Halting problem undecidability and infinitely nested simulationRichard Damon

1
Subject: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.lang.c, comp.lang.c++
Followup: comp.theory,comp.ai.philosophy,sci.logic
Date: Sat, 21 May 2022 21:48 UTC
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 16:48:27 -0500
Date: Sat, 21 May 2022 16:48:26 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Newsgroups: comp.theory,comp.ai.philosophy,comp.lang.c,comp.lang.c++
Content-Language: en-US
Followup-To: comp.theory,comp.ai.philosophy,sci.logic
From: NoO...@NoWhere.com (olcott)
Subject: Halting problem undecidability and infinitely nested simulation (V5)
(update)
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 194
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-daBXOUfZ3Ix2ynuQwJzTNo9oWihVYbyRSKh2SEgt4ZorEa5wTGZpBq7Am7WQWY3qelvKdt1Kzq/UZC6!2ry9KKDGccmsP80NW3z49i1umHxzWoxu8DuN3lfMPxSP5KclBEm0ZNP8K6oWHuFUOx6NH5F66JA=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 10007
View all headers
Halting problem undecidability and infinitely nested simulation (V5)

This is an explanation of a key new insight into the halting problem provided in the language of software engineering. Technical computer science terms are explained using software engineering terms.

To fully understand this paper a software engineer must be an expert in: the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is. No knowledge of the halting problem is required.

The computer science term “halting” means that a Turing Machine terminated normally reaching its last instruction known as its “final state”. This is the same idea as when a function returns to its caller as opposed to and contrast with getting stuck in an infinite loop or infinite recursion.

      In computability theory, the halting problem is the problem of determining,
      from a description of an arbitrary computer program and an input, whether
      the program will finish running, or continue to run forever. Alan Turing proved
      in 1936 that a general algorithm to solve the halting problem for all possible
      program-input pairs cannot exist.

      For any program H that might determine if programs halt, a "pathological"
      program P, called with some input, can pass its own source and its input to
      H and then specifically do the opposite of what H predicts P will do. No H
      can exist that handles this case. https://en.wikipedia.org/wiki/Halting_problem

Technically a halt decider is a program that computes the mapping from a pair of input finite strings to its own accept or reject state based on the actual behavior specified by these finite strings.  In other words it determines whether or not its input would halt and returns 0 or 1 accordingly.

      Computable functions are the basic objects of study in computability theory.
      Computable functions are the formalized analogue of the intuitive notion of
      algorithms, in the sense that a function is computable if there exists an algorithm
      that can do the job of the function, i.e. given an input of the function domain it
      can return the corresponding output.
      https://en.wikipedia.org/wiki/Computable_function

The most definitive way to determine the actual behavior of the actual input is to simply simulate this input and watch its behavior. This is the ultimate measure of the actual behavior of the input. A simulating halt decider (SHD) simulates its input and determines the halt status of this input on the basis of the behavior of this correctly simulated of its input.

The x86utm operating system was created so that all of the details of the the halting problem counter-example could be examined at the much higher level of abstraction of the C/x86 computer languages. It is based on a very powerful x86 emulator.
The function named P was defined to do the opposite of whatever H reports that it will do. If H(P,P) reports that its input halts, P invokes an infinite loop. If H(P,P) reports that its input is non-halting, P immediately halts.

The technical computer science term "halt" means that a program will reach its last instruction technically called its final state. For P this would be its machine address [0000136c].

H simulates its input one x86 instruction at a time using an x86 emulator. As soon as H(P,P) detects the same infinitely repeating pattern (that we can all see), it aborts its simulation and rejects its input.

Anyone that is an expert in the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is can easily verify that the correctly simulated input to H(P,P) by H specifies a non-halting sequence of configurations.

Software engineering experts can reverse-engineer what the correct x86 emulation of the input to H(P,P) would be for one emulation and one nested emulation thus confirming that the provided execution trace is correct. They can do this entirely on the basis of the x86 source-code for P with no need to see the source-code or execution trace of H.

The function named H continues to simulate its input using an x86 emulator until this input either halts on its own or H detects that it would never halt. If its input halts H returns 1. If H detects that its input would never halt H returns 0.

#include <stdint.h>
#define u32 uint32_t

void P(u32 x)
{
   if (H(x, x))
     HERE: goto HERE;
   return;
}

int main()
{
   Output("Input_Halts = ", H((u32)P, (u32)P));
}

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[0000135d](05)  e840feffff      call 000011a2 // call H
[00001362](03)  83c408          add esp,+08
[00001365](02)  85c0            test eax,eax
[00001367](02)  7402            jz 0000136b
[00001369](02)  ebfe            jmp 00001369
[0000136b](01)  5d              pop ebp
[0000136c](01)  c3              ret
Size in bytes:(0027) [0000136c]

_main()
[00001372](01)  55              push ebp
[00001373](02)  8bec            mov ebp,esp
[00001375](05)  6852130000      push 00001352 // push P
[0000137a](05)  6852130000      push 00001352 // push P
[0000137f](05)  e81efeffff      call 000011a2 // call H
[00001384](03)  83c408          add esp,+08
[00001387](01)  50              push eax
[00001388](05)  6823040000      push 00000423 // "Input_Halts = "
[0000138d](05)  e8e0f0ffff      call 00000472 // call Output
[00001392](03)  83c408          add esp,+08
[00001395](02)  33c0            xor eax,eax
[00001397](01)  5d              pop ebp
[00001398](01)  c3              ret
Size in bytes:(0039) [00001398]

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
....[00001372][0010229e][00000000] 55         push ebp
....[00001373][0010229e][00000000] 8bec       mov ebp,esp
....[00001375][0010229a][00001352] 6852130000 push 00001352 // push P
....[0000137a][00102296][00001352] 6852130000 push 00001352 // push P
....[0000137f][00102292][00001384] e81efeffff call 000011a2 // call H

Begin Local Halt Decider Simulation   Execution Trace Stored at:212352
....[00001352][0021233e][00212342] 55         push ebp      // enter P
....[00001353][0021233e][00212342] 8bec       mov ebp,esp
....[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
....[00001358][0021233a][00001352] 50         push eax      // push P
....[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
....[0000135c][00212336][00001352] 51         push ecx      // push P
....[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
....[00001352][0025cd66][0025cd6a] 55         push ebp      // enter P
....[00001353][0025cd66][0025cd6a] 8bec       mov ebp,esp
....[00001355][0025cd66][0025cd6a] 8b4508     mov eax,[ebp+08]
....[00001358][0025cd62][00001352] 50         push eax      // push P
....[00001359][0025cd62][00001352] 8b4d08     mov ecx,[ebp+08]
....[0000135c][0025cd5e][00001352] 51         push ecx      // push P
....[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

H sees that P is calling the same function from the same machine address with identical parameters, twice in sequence. This is the infinite recursion (infinitely nested simulation) non-halting behavior pattern.

....[00001384][0010229e][00000000] 83c408     add esp,+08
....[00001387][0010229a][00000000] 50         push eax

Click here to read the complete article
Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sat, 21 May 2022 21:50 UTC
References: 1
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 16:50:56 -0500
Date: Sat, 21 May 2022 16:50:55 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <fdqdnUeJacZdwxT_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 201
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ln3VVWvY0bfZTZbOA/JerbmRkNxISGn5audUlFUxq+cYKZx+DBJdo8g06CfcKgPduqtS3ni7GMqdSKS!3RC5TpKr0YzE9aXCNTM9w9HPDuN8ygcQlOoL02ugACNaij8RX0/G04DS94YlhszyV+gUwMdVNWM=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 11210
View all headers
On 5/21/2022 4:48 PM, olcott wrote:
Halting problem undecidability and infinitely nested simulation (V5)

This is an explanation of a key new insight into the halting problem provided in the language of software engineering. Technical computer science terms are explained using software engineering terms.

To fully understand this paper a software engineer must be an expert in: the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is. No knowledge of the halting problem is required.

The computer science term “halting” means that a Turing Machine terminated normally reaching its last instruction known as its “final state”. This is the same idea as when a function returns to its caller as opposed to and contrast with getting stuck in an infinite loop or infinite recursion.

      In computability theory, the halting problem is the problem of determining,
      from a description of an arbitrary computer program and an input, whether
      the program will finish running, or continue to run forever. Alan Turing proved
      in 1936 that a general algorithm to solve the halting problem for all possible
      program-input pairs cannot exist.

      For any program H that might determine if programs halt, a "pathological"
      program P, called with some input, can pass its own source and its input to
      H and then specifically do the opposite of what H predicts P will do. No H
      can exist that handles this case. https://en.wikipedia.org/wiki/Halting_problem

Technically a halt decider is a program that computes the mapping from a pair of input finite strings to its own accept or reject state based on the actual behavior specified by these finite strings.  In other words it determines whether or not its input would halt and returns 0 or 1 accordingly.

      Computable functions are the basic objects of study in computability theory.
      Computable functions are the formalized analogue of the intuitive notion of
      algorithms, in the sense that a function is computable if there exists an algorithm
      that can do the job of the function, i.e. given an input of the function domain it
      can return the corresponding output.
      https://en.wikipedia.org/wiki/Computable_function

The most definitive way to determine the actual behavior of the actual input is to simply simulate this input and watch its behavior. This is the ultimate measure of the actual behavior of the input. A simulating halt decider (SHD) simulates its input and determines the halt status of this input on the basis of the behavior of this correctly simulated of its input.

The x86utm operating system was created so that all of the details of the the halting problem counter-example could be examined at the much higher level of abstraction of the C/x86 computer languages. It is based on a very powerful x86 emulator.
The function named P was defined to do the opposite of whatever H reports that it will do. If H(P,P) reports that its input halts, P invokes an infinite loop. If H(P,P) reports that its input is non-halting, P immediately halts.

The technical computer science term "halt" means that a program will reach its last instruction technically called its final state. For P this would be its machine address [0000136c].

H simulates its input one x86 instruction at a time using an x86 emulator. As soon as H(P,P) detects the same infinitely repeating pattern (that we can all see), it aborts its simulation and rejects its input.

Anyone that is an expert in the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is can easily verify that the correctly simulated input to H(P,P) by H specifies a non-halting sequence of configurations.

Software engineering experts can reverse-engineer what the correct x86 emulation of the input to H(P,P) would be for one emulation and one nested emulation thus confirming that the provided execution trace is correct. They can do this entirely on the basis of the x86 source-code for P with no need to see the source-code or execution trace of H.

The function named H continues to simulate its input using an x86 emulator until this input either halts on its own or H detects that it would never halt. If its input halts H returns 1. If H detects that its input would never halt H returns 0.

#include <stdint.h>
#define u32 uint32_t

void P(u32 x)
{
   if (H(x, x))
     HERE: goto HERE;
   return;
}

int main()
{
   Output("Input_Halts = ", H((u32)P, (u32)P));
}

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[0000135d](05)  e840feffff      call 000011a2 // call H
[00001362](03)  83c408          add esp,+08
[00001365](02)  85c0            test eax,eax
[00001367](02)  7402            jz 0000136b
[00001369](02)  ebfe            jmp 00001369
[0000136b](01)  5d              pop ebp
[0000136c](01)  c3              ret
Size in bytes:(0027) [0000136c]

_main()
[00001372](01)  55              push ebp
[00001373](02)  8bec            mov ebp,esp
[00001375](05)  6852130000      push 00001352 // push P
[0000137a](05)  6852130000      push 00001352 // push P
[0000137f](05)  e81efeffff      call 000011a2 // call H
[00001384](03)  83c408          add esp,+08
[00001387](01)  50              push eax
[00001388](05)  6823040000      push 00000423 // "Input_Halts = "
[0000138d](05)  e8e0f0ffff      call 00000472 // call Output
[00001392](03)  83c408          add esp,+08
[00001395](02)  33c0            xor eax,eax
[00001397](01)  5d              pop ebp
[00001398](01)  c3              ret
Size in bytes:(0039) [00001398]

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[00001372][0010229e][00000000] 55         push ebp
...[00001373][0010229e][00000000] 8bec       mov ebp,esp
...[00001375][0010229a][00001352] 6852130000 push 00001352 // push P
...[0000137a][00102296][00001352] 6852130000 push 00001352 // push P
...[0000137f][00102292][00001384] e81efeffff call 000011a2 // call H

Begin Local Halt Decider Simulation   Execution Trace Stored at:212352
...[00001352][0021233e][00212342] 55         push ebp      // enter P
...[00001353][0021233e][00212342] 8bec       mov ebp,esp
...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
...[00001358][0021233a][00001352] 50         push eax      // push P
...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
...[0000135c][00212336][00001352] 51         push ecx      // push P
...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
...[00001352][0025cd66][0025cd6a] 55         push ebp      // enter P
...[00001353][0025cd66][0025cd6a] 8bec       mov ebp,esp
...[00001355][0025cd66][0025cd6a] 8b4508     mov eax,[ebp+08]
...[00001358][0025cd62][00001352] 50         push eax      // push P
...[00001359][0025cd62][00001352] 8b4d08     mov ecx,[ebp+08]
...[0000135c][0025cd5e][00001352] 51         push ecx      // push P
...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

H sees that P is calling the same function from the same machine address with identical parameters, twice in sequence. This is the infinite recursion (infinitely nested simulation) non-halting behavior pattern.

...[00001384][0010229e][00000000] 83c408     add esp,+08
...[00001387][0010229a][00000000] 50         push eax
...[00001388][00102296][00000423] 6823040000 push 00000423 // "Input_Halts = "
---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call Output
Input_Halts = 0
...[00001392][0010229e][00000000] 83c408     add esp,+08
...[00001395][0010229e][00000000] 33c0       xor eax,eax
...[00001397][001022a2][00100000] 5d         pop ebp
...[00001398][001022a6][00000004] c3         ret
Number_of_User_Instructions(1)
Number of Instructions Executed(15892) = 237 pages

The correct simulation of the input to H(P,P) and the direct execution of P(P) are not computationally equivalent thus need not have the same halting behavior.


Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5 --

Click here to read the complete article
Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: Mutt Buncher
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Aioe.org NNTP Server
Date: Sat, 21 May 2022 22:16 UTC
References: 1
Path: i2pn2.org!i2pn.org!aioe.org!42V55DPF/EHESwy7gmIc+w.user.46.165.242.75.POSTED!not-for-mail
From: mut...@buncher.net (Mutt Buncher)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Date: Sat, 21 May 2022 15:16:02 -0700
Organization: Aioe.org NNTP Server
Message-ID: <t6bob2$1ef2$1@gioia.aioe.org>
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
Reply-To: mutt@buncher.net
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="47586"; posting-host="42V55DPF/EHESwy7gmIc+w.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
X-Notice: Filtered by postfilter v. 0.9.2
Content-Language: en-US
View all headers
On 5/21/2022 2:48 PM, olcott wrote:
Halting problem undecidability and infinitely nested simulation (V5)

Post it 156,334 more times you retarded mouthload of Bolivian goat testicles.




Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: Mr Flibble
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Jupiter Mining Corp
Date: Sat, 21 May 2022 22:51 UTC
References: 1
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!npeer.as286.net!npeer-ng0.as286.net!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx02.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Message-ID: <20220521235140.0000042c@reddwarf.jmc>
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 15
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sat, 21 May 2022 22:51:40 UTC
Date: Sat, 21 May 2022 23:51:40 +0100
X-Received-Bytes: 1318
View all headers
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote:

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and rejects
its input.

There is no infinitely repeating pattern except the one you are making
up in your head based on your misunderstanding of the halting problem
theorem proof. How many times do you have to be told this? You've got
nothing.

/Flibble



Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sat, 21 May 2022 22:55 UTC
References: 1 2
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 17:55:19 -0500
Date: Sat, 21 May 2022 17:55:18 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220521235140.0000042c@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220521235140.0000042c@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 33
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-0TDOcJj9cp9UzgnhyQd6HsB1I3z/jP9Waqa/fqZFhYo9hkiZG1EjUAWq1gmvUnnfptorZUBsGU/q51v!P+0HpFn7KfbDtseWuWlrSVgRkVpvijHWlg+VVmyA7AI94uROgSb6RPybWnq5E9b/Ftd+g2xp5H0=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 2481
View all headers
On 5/21/2022 5:51 PM, Mr Flibble wrote:
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote:

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and rejects
its input.

There is no infinitely repeating pattern except the one you are making
up in your head based on your misunderstanding of the halting problem
theorem proof. How many times do you have to be told this? You've got
nothing.

/Flibble


Clearly you do not have the technical competence to evaluate my paper:

To fully understand this paper a software engineer must be an expert in: the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is. No knowledge of the halting problem is required.

and the ability to recognize infinite recursion at the x86 assembly language level.

--
Copyright 2022 Pete Olcott

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


Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: Mr Flibble
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Jupiter Mining Corp
Date: Sat, 21 May 2022 23:01 UTC
References: 1 2 3
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Message-ID: <20220522000111.00006d62@reddwarf.jmc>
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220521235140.0000042c@reddwarf.jmc>
<eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 36
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sat, 21 May 2022 23:01:11 UTC
Date: Sun, 22 May 2022 00:01:11 +0100
X-Received-Bytes: 2249
View all headers
On Sat, 21 May 2022 17:55:18 -0500
olcott <NoOne@NoWhere.com> wrote:

On 5/21/2022 5:51 PM, Mr Flibble wrote:
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote: 

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and rejects
its input. 

There is no infinitely repeating pattern except the one you are
making up in your head based on your misunderstanding of the
halting problem theorem proof. How many times do you have to be
told this? You've got nothing.

/Flibble
 

Clearly you do not have the technical competence to evaluate my paper:

To fully understand this paper a software engineer must be an expert
in: the C programming language, the x86 programming language, exactly
how C translates into x86 and what an x86 processor emulator is. No
knowledge of the halting problem is required.

and the ability to recognize infinite recursion at the x86 assembly
language level.
 
We have been over this. I am quite capable of recognizing infinite
recursion but, crucially, I can also recognize a *lack* of infinite
recursion: it is a shame that you are not capable of doing the same.

/Flibble



Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sat, 21 May 2022 23:06 UTC
References: 1 2 3 4
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 18:06:58 -0500
Date: Sat, 21 May 2022 18:06:57 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220521235140.0000042c@reddwarf.jmc>
<eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
<20220522000111.00006d62@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220522000111.00006d62@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <obKdnR7jl4MP7RT_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 48
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-woUMHcN6mskNTHyzqsa2q+IsskCoD2EfSdFW9R2GneeqhnEZD6+WHEVsIAelCjrk07I2yCxa0BgSS4o!DybKVixpOKo3XS8yS3K6uWSr5HHKDPrpZ4cojwNAjscqNS+TA1/lw54E/zV9HefAghv0VJCDECA=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3208
View all headers
On 5/21/2022 6:01 PM, Mr Flibble wrote:
On Sat, 21 May 2022 17:55:18 -0500
olcott <NoOne@NoWhere.com> wrote:

On 5/21/2022 5:51 PM, Mr Flibble wrote:
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote:

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and rejects
its input.

There is no infinitely repeating pattern except the one you are
making up in your head based on your misunderstanding of the
halting problem theorem proof. How many times do you have to be
told this? You've got nothing.

/Flibble
  

Clearly you do not have the technical competence to evaluate my paper:

To fully understand this paper a software engineer must be an expert
in: the C programming language, the x86 programming language, exactly
how C translates into x86 and what an x86 processor emulator is. No
knowledge of the halting problem is required.

and the ability to recognize infinite recursion at the x86 assembly
language level.
  We have been over this. I am quite capable of recognizing infinite
recursion but, crucially, I can also recognize a *lack* of infinite
recursion: it is a shame that you are not capable of doing the same.

/Flibble


If you can recognize infinite recursion then you know that when one function calls another function with the same parameters from the same machine address twice in sequence that this specifies infinite recursion.

--
Copyright 2022 Pete Olcott

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


Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: Mr Flibble
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Jupiter Mining Corp
Date: Sat, 21 May 2022 23:11 UTC
References: 1 2 3 4 5
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx06.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Message-ID: <20220522001158.000067bf@reddwarf.jmc>
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220521235140.0000042c@reddwarf.jmc>
<eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
<20220522000111.00006d62@reddwarf.jmc>
<obKdnR7jl4MP7RT_nZ2dnUU7_8xh4p2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 53
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sat, 21 May 2022 23:11:58 UTC
Date: Sun, 22 May 2022 00:11:58 +0100
X-Received-Bytes: 2862
View all headers
On Sat, 21 May 2022 18:06:57 -0500
olcott <NoOne@NoWhere.com> wrote:

On 5/21/2022 6:01 PM, Mr Flibble wrote:
On Sat, 21 May 2022 17:55:18 -0500
olcott <NoOne@NoWhere.com> wrote:
 
On 5/21/2022 5:51 PM, Mr Flibble wrote: 
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote: 

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and
rejects its input. 

There is no infinitely repeating pattern except the one you are
making up in your head based on your misunderstanding of the
halting problem theorem proof. How many times do you have to be
told this? You've got nothing.

/Flibble
    

Clearly you do not have the technical competence to evaluate my
paper:

To fully understand this paper a software engineer must be an
expert in: the C programming language, the x86 programming
language, exactly how C translates into x86 and what an x86
processor emulator is. No knowledge of the halting problem is
required.

and the ability to recognize infinite recursion at the x86 assembly
language level. 
 
We have been over this. I am quite capable of recognizing infinite
recursion but, crucially, I can also recognize a *lack* of infinite
recursion: it is a shame that you are not capable of doing the same.

/Flibble
 

If you can recognize infinite recursion then you know that when one
function calls another function with the same parameters from the
same machine address twice in sequence that this specifies infinite
recursion.
 
But that doesn't happen in the proofs you are attempting to refute as
THERE IS NO INFINITE RECURSION PRESENT IN THOSE PROOFS.

/Flibble



Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sat, 21 May 2022 23:22 UTC
References: 1 2 3 4 5 6
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 18:22:20 -0500
Date: Sat, 21 May 2022 18:22:19 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220521235140.0000042c@reddwarf.jmc>
<eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
<20220522000111.00006d62@reddwarf.jmc>
<obKdnR7jl4MP7RT_nZ2dnUU7_8xh4p2d@giganews.com>
<20220522001158.000067bf@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220522001158.000067bf@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <WdidnWVT--Cx6RT_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 76
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-r5rK7wjvoiCrSb496gg/i74CickgWwOCD+L8frPllK/+KwWDPBZ1bWnJVjOkTt8wXz5MXNRRNniXW5J!QRINxzlTclVsE6yF90lrVyYjYCwirByRwFufcoXMxkyYppBb0QB1KzgVrAe291+deTKnHwLTWpU=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4294
View all headers
On 5/21/2022 6:11 PM, Mr Flibble wrote:
On Sat, 21 May 2022 18:06:57 -0500
olcott <NoOne@NoWhere.com> wrote:

On 5/21/2022 6:01 PM, Mr Flibble wrote:
On Sat, 21 May 2022 17:55:18 -0500
olcott <NoOne@NoWhere.com> wrote:
  
On 5/21/2022 5:51 PM, Mr Flibble wrote:
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote:

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and
rejects its input.

There is no infinitely repeating pattern except the one you are
making up in your head based on your misunderstanding of the
halting problem theorem proof. How many times do you have to be
told this? You've got nothing.

/Flibble
     

Clearly you do not have the technical competence to evaluate my
paper:

To fully understand this paper a software engineer must be an
expert in: the C programming language, the x86 programming
language, exactly how C translates into x86 and what an x86
processor emulator is. No knowledge of the halting problem is
required.

and the ability to recognize infinite recursion at the x86 assembly
language level.
   We have been over this. I am quite capable of recognizing infinite
recursion but, crucially, I can also recognize a *lack* of infinite
recursion: it is a shame that you are not capable of doing the same.

/Flibble
  

If you can recognize infinite recursion then you know that when one
function calls another function with the same parameters from the
same machine address twice in sequence that this specifies infinite
recursion.
  But that doesn't happen in the proofs you are attempting to refute as
THERE IS NO INFINITE RECURSION PRESENT IN THOSE PROOFS.

/Flibble


If you keep changing the subject we will never get any closure on any point. To actually understand my proof we must move point by point one-at-at-time achieving mutual agreement on each point before moving on to the next point.

The C function named H does correctly determine that the its input parameters point to the machine language of a C function that never reaches its last instruction.

Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5 --
Copyright 2022 Pete Olcott

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


Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: Mr Flibble
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Jupiter Mining Corp
Date: Sun, 22 May 2022 00:34 UTC
References: 1 2 3 4 5 6 7
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx12.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Message-ID: <20220522013420.00007c03@reddwarf.jmc>
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220521235140.0000042c@reddwarf.jmc>
<eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
<20220522000111.00006d62@reddwarf.jmc>
<obKdnR7jl4MP7RT_nZ2dnUU7_8xh4p2d@giganews.com>
<20220522001158.000067bf@reddwarf.jmc>
<WdidnWVT--Cx6RT_nZ2dnUU7_8zNnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 78
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 22 May 2022 00:34:20 UTC
Date: Sun, 22 May 2022 01:34:20 +0100
X-Received-Bytes: 4039
View all headers
On Sat, 21 May 2022 18:22:19 -0500
olcott <NoOne@NoWhere.com> wrote:

On 5/21/2022 6:11 PM, Mr Flibble wrote:
On Sat, 21 May 2022 18:06:57 -0500
olcott <NoOne@NoWhere.com> wrote:
 
On 5/21/2022 6:01 PM, Mr Flibble wrote: 
On Sat, 21 May 2022 17:55:18 -0500
olcott <NoOne@NoWhere.com> wrote:
    
On 5/21/2022 5:51 PM, Mr Flibble wrote: 
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote: 

H simulates its input one x86 instruction at a time using an
x86 emulator. As soon as H(P,P) detects the same infinitely
repeating pattern (that we can all see), it aborts its
simulation and rejects its input. 

There is no infinitely repeating pattern except the one you are
making up in your head based on your misunderstanding of the
halting problem theorem proof. How many times do you have to be
told this? You've got nothing.

/Flibble
       

Clearly you do not have the technical competence to evaluate my
paper:

To fully understand this paper a software engineer must be an
expert in: the C programming language, the x86 programming
language, exactly how C translates into x86 and what an x86
processor emulator is. No knowledge of the halting problem is
required.

and the ability to recognize infinite recursion at the x86
assembly language level. 
  
We have been over this. I am quite capable of recognizing infinite
recursion but, crucially, I can also recognize a *lack* of
infinite recursion: it is a shame that you are not capable of
doing the same.

/Flibble
    

If you can recognize infinite recursion then you know that when one
function calls another function with the same parameters from the
same machine address twice in sequence that this specifies infinite
recursion. 
 
But that doesn't happen in the proofs you are attempting to refute
as THERE IS NO INFINITE RECURSION PRESENT IN THOSE PROOFS.

/Flibble
 

If you keep changing the subject we will never get any closure on any
point. To actually understand my proof we must move point by point
one-at-at-time achieving mutual agreement on each point before moving
on to the next point.

The C function named H does correctly determine that the its input
parameters point to the machine language of a C function that never
reaches its last instruction.

Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

Given that there is no infinite recursion in the proof you are trying
to refute then what is the point in going through your proof given it
is based on a false premise?

/Flibble



Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sun, 22 May 2022 00:38 UTC
References: 1 2 3 4 5 6 7 8
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!1.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 19:39:00 -0500
Date: Sat, 21 May 2022 19:38:59 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220521235140.0000042c@reddwarf.jmc>
<eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
<20220522000111.00006d62@reddwarf.jmc>
<obKdnR7jl4MP7RT_nZ2dnUU7_8xh4p2d@giganews.com>
<20220522001158.000067bf@reddwarf.jmc>
<WdidnWVT--Cx6RT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220522013420.00007c03@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220522013420.00007c03@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <YqmdnfUYvaC5GxT_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 90
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-JDL2/xKwc3XSSLkWOuVVGLtMoQKsOlwjn8elTpb3oM+u4XbHQ68upPufJIbvH6ncEqiwKARwYLruoXI!W65K4Jue2ifdaveXCQ8ETvlKpnlPSECudfl20LmZqFbfkpkvdxeH7eYVEi/W6X5nywQfP7GGx/4=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5036
View all headers
On 5/21/2022 7:34 PM, Mr Flibble wrote:
On Sat, 21 May 2022 18:22:19 -0500
olcott <NoOne@NoWhere.com> wrote:

On 5/21/2022 6:11 PM, Mr Flibble wrote:
On Sat, 21 May 2022 18:06:57 -0500
olcott <NoOne@NoWhere.com> wrote:
  
On 5/21/2022 6:01 PM, Mr Flibble wrote:
On Sat, 21 May 2022 17:55:18 -0500
olcott <NoOne@NoWhere.com> wrote:
     
On 5/21/2022 5:51 PM, Mr Flibble wrote:
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote:

H simulates its input one x86 instruction at a time using an
x86 emulator. As soon as H(P,P) detects the same infinitely
repeating pattern (that we can all see), it aborts its
simulation and rejects its input.

There is no infinitely repeating pattern except the one you are
making up in your head based on your misunderstanding of the
halting problem theorem proof. How many times do you have to be
told this? You've got nothing.

/Flibble
        

Clearly you do not have the technical competence to evaluate my
paper:

To fully understand this paper a software engineer must be an
expert in: the C programming language, the x86 programming
language, exactly how C translates into x86 and what an x86
processor emulator is. No knowledge of the halting problem is
required.

and the ability to recognize infinite recursion at the x86
assembly language level.
    We have been over this. I am quite capable of recognizing infinite
recursion but, crucially, I can also recognize a *lack* of
infinite recursion: it is a shame that you are not capable of
doing the same.

/Flibble
     

If you can recognize infinite recursion then you know that when one
function calls another function with the same parameters from the
same machine address twice in sequence that this specifies infinite
recursion.
   But that doesn't happen in the proofs you are attempting to refute
as THERE IS NO INFINITE RECURSION PRESENT IN THOSE PROOFS.

/Flibble
  

If you keep changing the subject we will never get any closure on any
point. To actually understand my proof we must move point by point
one-at-at-time achieving mutual agreement on each point before moving
on to the next point.

The C function named H does correctly determine that the its input
parameters point to the machine language of a C function that never
reaches its last instruction.

Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

Given that there is no infinite recursion in the proof you are trying
to refute then what is the point in going through your proof given it
is based on a false premise?

/Flibble


There is infinitely nested simulation in the Linz proof but you will not be able to begin to understand that until we go through many steps of my other proof first.

--
Copyright 2022 Pete Olcott

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


Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Forte - www.forteinc.com
Date: Sun, 22 May 2022 01:00 UTC
References: 1
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx11.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 213
Message-ID: <BWfiK.28445$J0r9.15509@fx11.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 21:00:16 -0400
X-Received-Bytes: 11261
X-Original-Bytes: 11127
View all headers
On 5/21/22 5:48 PM, olcott wrote:
Halting problem undecidability and infinitely nested simulation (V5)

This is an explanation of a key new insight into the halting problem provided in the language of software engineering. Technical computer science terms are explained using software engineering terms.

To fully understand this paper a software engineer must be an expert in: the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is. No knowledge of the halting problem is required.

The computer science term “halting” means that a Turing Machine terminated normally reaching its last instruction known as its “final state”. This is the same idea as when a function returns to its caller as opposed to and contrast with getting stuck in an infinite loop or infinite recursion.

      In computability theory, the halting problem is the problem of determining,
      from a description of an arbitrary computer program and an input, whether
      the program will finish running, or continue to run forever. Alan Turing proved
      in 1936 that a general algorithm to solve the halting problem for all possible
      program-input pairs cannot exist.

      For any program H that might determine if programs halt, a "pathological"
      program P, called with some input, can pass its own source and its input to
      H and then specifically do the opposite of what H predicts P will do. No H
      can exist that handles this case. https://en.wikipedia.org/wiki/Halting_problem

Technically a halt decider is a program that computes the mapping from a pair of input finite strings to its own accept or reject state based on the actual behavior specified by these finite strings.  In other words it determines whether or not its input would halt and returns 0 or 1 accordingly.

      Computable functions are the basic objects of study in computability theory.
      Computable functions are the formalized analogue of the intuitive notion of
      algorithms, in the sense that a function is computable if there exists an algorithm
      that can do the job of the function, i.e. given an input of the function domain it
      can return the corresponding output.
      https://en.wikipedia.org/wiki/Computable_function

The most definitive way to determine the actual behavior of the actual input is to simply simulate this input and watch its behavior. This is the ultimate measure of the actual behavior of the input. A simulating halt decider (SHD) simulates its input and determines the halt status of this input on the basis of the behavior of this correctly simulated of its input.

The x86utm operating system was created so that all of the details of the the halting problem counter-example could be examined at the much higher level of abstraction of the C/x86 computer languages. It is based on a very powerful x86 emulator.
The function named P was defined to do the opposite of whatever H reports that it will do. If H(P,P) reports that its input halts, P invokes an infinite loop. If H(P,P) reports that its input is non-halting, P immediately halts.

The technical computer science term "halt" means that a program will reach its last instruction technically called its final state. For P this would be its machine address [0000136c].

H simulates its input one x86 instruction at a time using an x86 emulator. As soon as H(P,P) detects the same infinitely repeating pattern (that we can all see), it aborts its simulation and rejects its input.

Anyone that is an expert in the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is can easily verify that the correctly simulated input to H(P,P) by H specifies a non-halting sequence of configurations.

Software engineering experts can reverse-engineer what the correct x86 emulation of the input to H(P,P) would be for one emulation and one nested emulation thus confirming that the provided execution trace is correct. They can do this entirely on the basis of the x86 source-code for P with no need to see the source-code or execution trace of H.

The function named H continues to simulate its input using an x86 emulator until this input either halts on its own or H detects that it would never halt. If its input halts H returns 1. If H detects that its input would never halt H returns 0.

#include <stdint.h>
#define u32 uint32_t

void P(u32 x)
{
   if (H(x, x))
     HERE: goto HERE;
   return;
}

int main()
{
   Output("Input_Halts = ", H((u32)P, (u32)P));
}

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[0000135d](05)  e840feffff      call 000011a2 // call H
[00001362](03)  83c408          add esp,+08
[00001365](02)  85c0            test eax,eax
[00001367](02)  7402            jz 0000136b
[00001369](02)  ebfe            jmp 00001369
[0000136b](01)  5d              pop ebp
[0000136c](01)  c3              ret
Size in bytes:(0027) [0000136c]

_main()
[00001372](01)  55              push ebp
[00001373](02)  8bec            mov ebp,esp
[00001375](05)  6852130000      push 00001352 // push P
[0000137a](05)  6852130000      push 00001352 // push P
[0000137f](05)  e81efeffff      call 000011a2 // call H
[00001384](03)  83c408          add esp,+08
[00001387](01)  50              push eax
[00001388](05)  6823040000      push 00000423 // "Input_Halts = "
[0000138d](05)  e8e0f0ffff      call 00000472 // call Output
[00001392](03)  83c408          add esp,+08
[00001395](02)  33c0            xor eax,eax
[00001397](01)  5d              pop ebp
[00001398](01)  c3              ret
Size in bytes:(0039) [00001398]

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[00001372][0010229e][00000000] 55         push ebp
...[00001373][0010229e][00000000] 8bec       mov ebp,esp
...[00001375][0010229a][00001352] 6852130000 push 00001352 // push P
...[0000137a][00102296][00001352] 6852130000 push 00001352 // push P
...[0000137f][00102292][00001384] e81efeffff call 000011a2 // call H

Begin Local Halt Decider Simulation   Execution Trace Stored at:212352
...[00001352][0021233e][00212342] 55         push ebp      // enter P
...[00001353][0021233e][00212342] 8bec       mov ebp,esp
...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
...[00001358][0021233a][00001352] 50         push eax      // push P
...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
...[0000135c][00212336][00001352] 51         push ecx      // push P
...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H

ERROR IN TRACE.

THE FOLLOWING DOESN'T ACTUALLY HAPPEN, AND IS A LIE>

...[00001352][0025cd66][0025cd6a] 55         push ebp      // enter P
...[00001353][0025cd66][0025cd6a] 8bec       mov ebp,esp
...[00001355][0025cd66][0025cd6a] 8b4508     mov eax,[ebp+08]
...[00001358][0025cd62][00001352] 50         push eax      // push P
...[00001359][0025cd62][00001352] 8b4d08     mov ecx,[ebp+08]
...[0000135c][0025cd5e][00001352] 51         push ecx      // push P
...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

H sees that P is calling the same function from the same machine address with identical parameters, twice in sequence. This is the infinite recursion (infinitely nested simulation) non-halting behavior pattern.

No, H is just imagining this, because it is using incorrect logic and comes up with a wrong answer.

You are just showing YOUR technical incompitence in making your claim.


...[00001384][0010229e][00000000] 83c408     add esp,+08
...[00001387][0010229a][00000000] 50         push eax
...[00001388][00102296][00000423] 6823040000 push 00000423 // "Input_Halts = "
---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call Output
Input_Halts = 0
...[00001392][0010229e][00000000] 83c408     add esp,+08
...[00001395][0010229e][00000000] 33c0       xor eax,eax
...[00001397][001022a2][00100000] 5d         pop ebp
...[00001398][001022a6][00000004] c3         ret
Number_of_User_Instructions(1)
Number of Instructions Executed(15892) = 237 pages

The correct simulation of the input to H(P,P) and the direct execution of P(P) are not computationally equivalent thus need not have the same halting behavior.


ERROR. You aren't using the correct definition of a Correct Simulation, because BY DEFINITION a correct simulation of X will exactly emulate the actual behavior of X.

Click here to read the complete article
Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Forte - www.forteinc.com
Date: Sun, 22 May 2022 01:02 UTC
References: 1 2 3
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!peer01.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx11.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220521235140.0000042c@reddwarf.jmc>
<eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 34
Message-ID: <zYfiK.28446$J0r9.11872@fx11.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 21:02:23 -0400
X-Received-Bytes: 2511
View all headers
On 5/21/22 6:55 PM, olcott wrote:
On 5/21/2022 5:51 PM, Mr Flibble wrote:
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote:

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and rejects
its input.

There is no infinitely repeating pattern except the one you are making
up in your head based on your misunderstanding of the halting problem
theorem proof. How many times do you have to be told this? You've got
nothing.

/Flibble


Clearly you do not have the technical competence to evaluate my paper:

To fully understand this paper a software engineer must be an expert in: the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is. No knowledge of the halting problem is required.

and the ability to recognize infinite recursion at the x86 assembly language level.


You don't have the technical competenct to write a correct paper, or the ability to correctly recognize infinite recursion at the x86 assembly level, since you have shown that P(P) Halts, and thus CAN'T have infinite recursion, because your H incorrectly aborts its simulation and says it is not Halting.


Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sun, 22 May 2022 01:03 UTC
References: 1 2 3 4
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 20:03:53 -0500
Date: Sat, 21 May 2022 20:03:52 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220521235140.0000042c@reddwarf.jmc>
<eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
<zYfiK.28446$J0r9.11872@fx11.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <zYfiK.28446$J0r9.11872@fx11.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <WKydnZFQmbVnFhT_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 47
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-v0vI/WZRBNlkB03N6emm38Kf8v4TN69JzUsGUDnj0Lm8WlAFVl5kHWuWm7cY9FnLvX3MU2eQPwAx1gp!4zRDzfQRBG8lf3ZkJd2yr+xhOl4jUeAmyPmqgmNiPg0SvMbd2j+z81B8UwfXMsj2fmjk/wd5sos=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3201
View all headers
On 5/21/2022 8:02 PM, Richard Damon wrote:
On 5/21/22 6:55 PM, olcott wrote:
On 5/21/2022 5:51 PM, Mr Flibble wrote:
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote:

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and rejects
its input.

There is no infinitely repeating pattern except the one you are making
up in your head based on your misunderstanding of the halting problem
theorem proof. How many times do you have to be told this? You've got
nothing.

/Flibble


Clearly you do not have the technical competence to evaluate my paper:

To fully understand this paper a software engineer must be an expert in: the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is. No knowledge of the halting problem is required.

and the ability to recognize infinite recursion at the x86 assembly language level.


You don't have the technical competenct to write a correct paper, or the ability to correctly recognize infinite recursion at the x86 assembly level, since you have shown that P(P) Halts, and thus CAN'T have infinite recursion, because your H incorrectly aborts its simulation and says it is not Halting.

The correct simulation of the input to H(P,P) and the direct execution of P(P) are not computationally equivalent thus need not have the same halting behavior.


--
Copyright 2022 Pete Olcott

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


Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Forte - www.forteinc.com
Date: Sun, 22 May 2022 01:18 UTC
References: 1 2 3 4 5
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx44.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com> <20220521235140.0000042c@reddwarf.jmc> <eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com> <zYfiK.28446$J0r9.11872@fx11.iad> <WKydnZFQmbVnFhT_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <WKydnZFQmbVnFhT_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 50
Message-ID: <RbgiK.1051$gjlb.660@fx44.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 21:18:40 -0400
X-Received-Bytes: 3091
View all headers
On 5/21/22 9:03 PM, olcott wrote:
On 5/21/2022 8:02 PM, Richard Damon wrote:
On 5/21/22 6:55 PM, olcott wrote:
On 5/21/2022 5:51 PM, Mr Flibble wrote:
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote:

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and rejects
its input.

There is no infinitely repeating pattern except the one you are making
up in your head based on your misunderstanding of the halting problem
theorem proof. How many times do you have to be told this? You've got
nothing.

/Flibble


Clearly you do not have the technical competence to evaluate my paper:

To fully understand this paper a software engineer must be an expert in: the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is. No knowledge of the halting problem is required.

and the ability to recognize infinite recursion at the x86 assembly language level.


You don't have the technical competenct to write a correct paper, or the ability to correctly recognize infinite recursion at the x86 assembly level, since you have shown that P(P) Halts, and thus CAN'T have infinite recursion, because your H incorrectly aborts its simulation and says it is not Halting.

The correct simulation of the input to H(P,P) and the direct execution of P(P) are not computationally equivalent thus need not have the same halting behavior.


Nope. Can't be and meet the definition of Correct Simulation, at least in the context of a Halting Decider.

What is YOUR definition of a Correct Simulation, if it doesn't need to match that actual behavior of that which is simulated?

FAIL.



Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sun, 22 May 2022 01:33 UTC
References: 1 2 3 4 5 6
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 20:33:22 -0500
Date: Sat, 21 May 2022 20:33:21 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220521235140.0000042c@reddwarf.jmc>
<eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
<zYfiK.28446$J0r9.11872@fx11.iad>
<WKydnZFQmbVnFhT_nZ2dnUU7_81g4p2d@giganews.com>
<RbgiK.1051$gjlb.660@fx44.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <RbgiK.1051$gjlb.660@fx44.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <UvudnUYlhdZ_DxT_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 63
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-r56IZCRu+469466mwym7ZRiEnCLgHvTerqxgwHwAowhZRS0pUG4Mx/OpOEal21gSbscodiPoHoEeL96!OA7gAXboQUMj9KnT4VW1BLqCpeGIg89rLaZOAwLk+V8mH1A2a9Su6C03MqteNtrV3kvfsSD3qcc=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3787
View all headers
On 5/21/2022 8:18 PM, Richard Damon wrote:
On 5/21/22 9:03 PM, olcott wrote:
On 5/21/2022 8:02 PM, Richard Damon wrote:
On 5/21/22 6:55 PM, olcott wrote:
On 5/21/2022 5:51 PM, Mr Flibble wrote:
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote:

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and rejects
its input.

There is no infinitely repeating pattern except the one you are making
up in your head based on your misunderstanding of the halting problem
theorem proof. How many times do you have to be told this? You've got
nothing.

/Flibble


Clearly you do not have the technical competence to evaluate my paper:

To fully understand this paper a software engineer must be an expert in: the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is. No knowledge of the halting problem is required.

and the ability to recognize infinite recursion at the x86 assembly language level.


You don't have the technical competenct to write a correct paper, or the ability to correctly recognize infinite recursion at the x86 assembly level, since you have shown that P(P) Halts, and thus CAN'T have infinite recursion, because your H incorrectly aborts its simulation and says it is not Halting.

The correct simulation of the input to H(P,P) and the direct execution of P(P) are not computationally equivalent thus need not have the same halting behavior.


Nope. Can't be and meet the definition of Correct Simulation, at least in the context of a Halting Decider.

What is YOUR definition of a Correct Simulation,

The code does exactly what its x86 source-code specifies.

if it doesn't need to match that actual behavior of that which is simulated?

FAIL.



--
Copyright 2022 Pete Olcott

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


Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Forte - www.forteinc.com
Date: Sun, 22 May 2022 02:32 UTC
References: 1 2 3 4 5 6 7
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx46.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220521235140.0000042c@reddwarf.jmc>
<eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
<zYfiK.28446$J0r9.11872@fx11.iad>
<WKydnZFQmbVnFhT_nZ2dnUU7_81g4p2d@giganews.com>
<RbgiK.1051$gjlb.660@fx44.iad>
<UvudnUYlhdZ_DxT_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <UvudnUYlhdZ_DxT_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 81
Message-ID: <%ghiK.9437$kaDc.1420@fx46.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 22:32:26 -0400
X-Received-Bytes: 4247
View all headers
On 5/21/22 9:33 PM, olcott wrote:
On 5/21/2022 8:18 PM, Richard Damon wrote:
On 5/21/22 9:03 PM, olcott wrote:
On 5/21/2022 8:02 PM, Richard Damon wrote:
On 5/21/22 6:55 PM, olcott wrote:
On 5/21/2022 5:51 PM, Mr Flibble wrote:
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote:

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and rejects
its input.

There is no infinitely repeating pattern except the one you are making
up in your head based on your misunderstanding of the halting problem
theorem proof. How many times do you have to be told this? You've got
nothing.

/Flibble


Clearly you do not have the technical competence to evaluate my paper:

To fully understand this paper a software engineer must be an expert in: the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is. No knowledge of the halting problem is required.

and the ability to recognize infinite recursion at the x86 assembly language level.


You don't have the technical competenct to write a correct paper, or the ability to correctly recognize infinite recursion at the x86 assembly level, since you have shown that P(P) Halts, and thus CAN'T have infinite recursion, because your H incorrectly aborts its simulation and says it is not Halting.

The correct simulation of the input to H(P,P) and the direct execution of P(P) are not computationally equivalent thus need not have the same halting behavior.


Nope. Can't be and meet the definition of Correct Simulation, at least in the context of a Halting Decider.

What is YOUR definition of a Correct Simulation,

The code does exactly what its x86 source-code specifies.

Right, P(P) calls H(P,P) which is defined to simulate this input and decide that its input is non-halting, and abort its simulation and return a 0 so P(P) halts.

THAT is the behavior that the x86 source-code specifies when we add your definition of the behavior of H.

Since that is the ACTUAL behavior the source code specifies, but is NOT the behavior your "Correct Simulation" shows, it is thus, by your definition NOT a correct simulation.

That, or you are incorrect that you H(P,P) will "correctly" return 0. (which actually turns out to be incorrectly).

The other correct simulation would be to show the instructions of H being simulated, since that is what the ACTUAL x86 code specifies. (There is no grounds for no showing those instructions).



if it doesn't need to match that actual behavior of that which is simulated?

FAIL.






Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sun, 22 May 2022 02:36 UTC
References: 1 2 3 4 5 6 7 8
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 21:36:46 -0500
Date: Sat, 21 May 2022 21:36:45 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220521235140.0000042c@reddwarf.jmc>
<eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
<zYfiK.28446$J0r9.11872@fx11.iad>
<WKydnZFQmbVnFhT_nZ2dnUU7_81g4p2d@giganews.com>
<RbgiK.1051$gjlb.660@fx44.iad>
<UvudnUYlhdZ_DxT_nZ2dnUU7_83NnZ2d@giganews.com>
<%ghiK.9437$kaDc.1420@fx46.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <%ghiK.9437$kaDc.1420@fx46.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <ZMadnSJEEuIiPBT_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 72
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-TK2y472IconVdBisrireAg/uExwUaxUg7s5narUPbDT18Jj7NZwBdWXVFTcOn7UE52iKmypYxNXQauB!bp/8N/bA1/yXErd9ZNnij7dVa63UDlTpu3aNcnfvVm66YMtwdro+Civ2AHCkRn3X//ceLTBZSnw=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4242
View all headers
On 5/21/2022 9:32 PM, Richard Damon wrote:
On 5/21/22 9:33 PM, olcott wrote:
On 5/21/2022 8:18 PM, Richard Damon wrote:
On 5/21/22 9:03 PM, olcott wrote:
On 5/21/2022 8:02 PM, Richard Damon wrote:
On 5/21/22 6:55 PM, olcott wrote:
On 5/21/2022 5:51 PM, Mr Flibble wrote:
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote:

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and rejects
its input.

There is no infinitely repeating pattern except the one you are making
up in your head based on your misunderstanding of the halting problem
theorem proof. How many times do you have to be told this? You've got
nothing.

/Flibble


Clearly you do not have the technical competence to evaluate my paper:

To fully understand this paper a software engineer must be an expert in: the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is. No knowledge of the halting problem is required.

and the ability to recognize infinite recursion at the x86 assembly language level.


You don't have the technical competenct to write a correct paper, or the ability to correctly recognize infinite recursion at the x86 assembly level, since you have shown that P(P) Halts, and thus CAN'T have infinite recursion, because your H incorrectly aborts its simulation and says it is not Halting.

The correct simulation of the input to H(P,P) and the direct execution of P(P) are not computationally equivalent thus need not have the same halting behavior.


Nope. Can't be and meet the definition of Correct Simulation, at least in the context of a Halting Decider.

What is YOUR definition of a Correct Simulation,

The code does exactly what its x86 source-code specifies.

Right, P(P) calls H(P,P)

No that is not what is being analyzed.
H(P,P) simulates its input that calls H(P,P) that simulates its input.

P(P) calls H(P,P) that simulates its input has a provably entirely different execution trace.


--
Copyright 2022 Pete Olcott

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


Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Forte - www.forteinc.com
Date: Sun, 22 May 2022 03:20 UTC
References: 1 2 3 4 5 6 7 8 9
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!sewer!alphared!news.uzoreto.com!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx38.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com> <20220521235140.0000042c@reddwarf.jmc> <eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com> <zYfiK.28446$J0r9.11872@fx11.iad> <WKydnZFQmbVnFhT_nZ2dnUU7_81g4p2d@giganews.com> <RbgiK.1051$gjlb.660@fx44.iad> <UvudnUYlhdZ_DxT_nZ2dnUU7_83NnZ2d@giganews.com> <%ghiK.9437$kaDc.1420@fx46.iad> <ZMadnSJEEuIiPBT_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ZMadnSJEEuIiPBT_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 104
Message-ID: <m_hiK.1178$lW.915@fx38.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 23:20:49 -0400
X-Received-Bytes: 5040
View all headers
On 5/21/22 10:36 PM, olcott wrote:
On 5/21/2022 9:32 PM, Richard Damon wrote:
On 5/21/22 9:33 PM, olcott wrote:
On 5/21/2022 8:18 PM, Richard Damon wrote:
On 5/21/22 9:03 PM, olcott wrote:
On 5/21/2022 8:02 PM, Richard Damon wrote:
On 5/21/22 6:55 PM, olcott wrote:
On 5/21/2022 5:51 PM, Mr Flibble wrote:
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote:

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and rejects
its input.

There is no infinitely repeating pattern except the one you are making
up in your head based on your misunderstanding of the halting problem
theorem proof. How many times do you have to be told this? You've got
nothing.

/Flibble


Clearly you do not have the technical competence to evaluate my paper:

To fully understand this paper a software engineer must be an expert in: the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is. No knowledge of the halting problem is required.

and the ability to recognize infinite recursion at the x86 assembly language level.


You don't have the technical competenct to write a correct paper, or the ability to correctly recognize infinite recursion at the x86 assembly level, since you have shown that P(P) Halts, and thus CAN'T have infinite recursion, because your H incorrectly aborts its simulation and says it is not Halting.

The correct simulation of the input to H(P,P) and the direct execution of P(P) are not computationally equivalent thus need not have the same halting behavior.


Nope. Can't be and meet the definition of Correct Simulation, at least in the context of a Halting Decider.

What is YOUR definition of a Correct Simulation,

The code does exactly what its x86 source-code specifies.

Right, P(P) calls H(P,P)

No that is not what is being analyzed.
H(P,P) simulates its input that calls H(P,P) that simulates its input.

P(P) calls H(P,P) that simulates its input has a provably entirely different execution trace.


Nope.

H(P,P) always does the same thing, right? if not, H fails to be an actual computation.

Since you say the outer H(P,P) returns 0, then it MUST be true that the H that P calls also returns 0, as we KNOW from your stipulation what H(P,P) does.

All you have done is proved that you must be lying about something.

Either the H you have doesn't return 0 for this H(P,P), or

This H(P,P) isn't a computation, returning different values from different calls with the same parameter, or

H(P,P) is just wrong about its answer.

You are running into a problem of definition. You seem to be envisioning an H that uses "magic" to do the impossible.

So, which case isn't true?

Does H(P,P) not abort this simulation and return 0, or
Do different calls to H(P,P) have different behaviors (showing it is not a computation)? or

Is H(P,P) just wrong, because the CORRECT (and thus one that doesn't abort) simulation of its input will halt.

You are assuming that H does a correct simulation, when it can't, and answer non-halting correctly at the same time for this input.

FAIL.




Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sun, 22 May 2022 03:34 UTC
References: 1 2 3 4 5 6 7 8 9 10
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 22:34:10 -0500
Date: Sat, 21 May 2022 22:34:09 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220521235140.0000042c@reddwarf.jmc>
<eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
<zYfiK.28446$J0r9.11872@fx11.iad>
<WKydnZFQmbVnFhT_nZ2dnUU7_81g4p2d@giganews.com>
<RbgiK.1051$gjlb.660@fx44.iad>
<UvudnUYlhdZ_DxT_nZ2dnUU7_83NnZ2d@giganews.com>
<%ghiK.9437$kaDc.1420@fx46.iad>
<ZMadnSJEEuIiPBT_nZ2dnUU7_8xh4p2d@giganews.com> <m_hiK.1178$lW.915@fx38.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <m_hiK.1178$lW.915@fx38.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <RrSdnaznM62vMhT_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 95
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-9fdJ5YlzeqHMtnzjPgfsKQWXrt9L4HW2qpqnl95yXgjfJ2NFA0osuDVHN9MRHYXePXv28Ws618/FfZF!hgwkqf+GvHa0E1hPkuzFYZ5Ix3EgeBZ1fCtDIQ28U/WuWCUL6zhOrRaD3nT2mB1a5y0/+u5tkrk=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5336
View all headers
On 5/21/2022 10:20 PM, Richard Damon wrote:
On 5/21/22 10:36 PM, olcott wrote:
On 5/21/2022 9:32 PM, Richard Damon wrote:
On 5/21/22 9:33 PM, olcott wrote:
On 5/21/2022 8:18 PM, Richard Damon wrote:
On 5/21/22 9:03 PM, olcott wrote:
On 5/21/2022 8:02 PM, Richard Damon wrote:
On 5/21/22 6:55 PM, olcott wrote:
On 5/21/2022 5:51 PM, Mr Flibble wrote:
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote:

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and rejects
its input.

There is no infinitely repeating pattern except the one you are making
up in your head based on your misunderstanding of the halting problem
theorem proof. How many times do you have to be told this? You've got
nothing.

/Flibble


Clearly you do not have the technical competence to evaluate my paper:

To fully understand this paper a software engineer must be an expert in: the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is. No knowledge of the halting problem is required.

and the ability to recognize infinite recursion at the x86 assembly language level.


You don't have the technical competenct to write a correct paper, or the ability to correctly recognize infinite recursion at the x86 assembly level, since you have shown that P(P) Halts, and thus CAN'T have infinite recursion, because your H incorrectly aborts its simulation and says it is not Halting.

The correct simulation of the input to H(P,P) and the direct execution of P(P) are not computationally equivalent thus need not have the same halting behavior.


Nope. Can't be and meet the definition of Correct Simulation, at least in the context of a Halting Decider.

What is YOUR definition of a Correct Simulation,

The code does exactly what its x86 source-code specifies.

Right, P(P) calls H(P,P)

No that is not what is being analyzed.
H(P,P) simulates its input that calls H(P,P) that simulates its input.

P(P) calls H(P,P) that simulates its input has a provably entirely different execution trace.


Nope.

H(P,P) always does the same thing, right? if not, H fails to be an actual computation.

Every H(P,P) that is invoked or simulated must do the same thing.
The simulated input to H(P,P) does not do the same thing as the directly executed P(P). This is an easily verifiable fact.

It gets me very angry when people disagree with easily verifiable facts.
(1) There is zero proof (none at all) of consequential election fraud in the 2020 presidential election.

(2) The two MRNA Covid-19 vaccines have proved to save very many lives and have close to zero cases of bad side effects.

(3) Very severe climate change caused by humans is real and we are quickly reaching the point of no return. If not corrected there will be very dire consequences.

--
Copyright 2022 Pete Olcott

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


Subject: Re: Halting problem undecidability and infinitely nested simulation (V5) (update)
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Forte - www.forteinc.com
Date: Sun, 22 May 2022 04:02 UTC
References: 1 2 3 4 5 6 7 8 9 10 11
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx46.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: Halting problem undecidability and infinitely nested simulation
(V5) (update)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220521235140.0000042c@reddwarf.jmc>
<eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>
<zYfiK.28446$J0r9.11872@fx11.iad>
<WKydnZFQmbVnFhT_nZ2dnUU7_81g4p2d@giganews.com>
<RbgiK.1051$gjlb.660@fx44.iad>
<UvudnUYlhdZ_DxT_nZ2dnUU7_83NnZ2d@giganews.com>
<%ghiK.9437$kaDc.1420@fx46.iad>
<ZMadnSJEEuIiPBT_nZ2dnUU7_8xh4p2d@giganews.com> <m_hiK.1178$lW.915@fx38.iad>
<RrSdnaznM62vMhT_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <RrSdnaznM62vMhT_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 130
Message-ID: <RBiiK.9439$kaDc.1365@fx46.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 22 May 2022 00:02:56 -0400
X-Received-Bytes: 6419
View all headers

On 5/21/22 11:34 PM, olcott wrote:
On 5/21/2022 10:20 PM, Richard Damon wrote:
On 5/21/22 10:36 PM, olcott wrote:
On 5/21/2022 9:32 PM, Richard Damon wrote:
On 5/21/22 9:33 PM, olcott wrote:
On 5/21/2022 8:18 PM, Richard Damon wrote:
On 5/21/22 9:03 PM, olcott wrote:
On 5/21/2022 8:02 PM, Richard Damon wrote:
On 5/21/22 6:55 PM, olcott wrote:
On 5/21/2022 5:51 PM, Mr Flibble wrote:
On Sat, 21 May 2022 16:48:26 -0500
olcott <NoOne@NoWhere.com> wrote:

H simulates its input one x86 instruction at a time using an x86
emulator. As soon as H(P,P) detects the same infinitely repeating
pattern (that we can all see), it aborts its simulation and rejects
its input.

There is no infinitely repeating pattern except the one you are making
up in your head based on your misunderstanding of the halting problem
theorem proof. How many times do you have to be told this? You've got
nothing.

/Flibble


Clearly you do not have the technical competence to evaluate my paper:

To fully understand this paper a software engineer must be an expert in: the C programming language, the x86 programming language, exactly how C translates into x86 and what an x86 processor emulator is. No knowledge of the halting problem is required.

and the ability to recognize infinite recursion at the x86 assembly language level.


You don't have the technical competenct to write a correct paper, or the ability to correctly recognize infinite recursion at the x86 assembly level, since you have shown that P(P) Halts, and thus CAN'T have infinite recursion, because your H incorrectly aborts its simulation and says it is not Halting.

The correct simulation of the input to H(P,P) and the direct execution of P(P) are not computationally equivalent thus need not have the same halting behavior.


Nope. Can't be and meet the definition of Correct Simulation, at least in the context of a Halting Decider.

What is YOUR definition of a Correct Simulation,

The code does exactly what its x86 source-code specifies.

Right, P(P) calls H(P,P)

No that is not what is being analyzed.
H(P,P) simulates its input that calls H(P,P) that simulates its input.

P(P) calls H(P,P) that simulates its input has a provably entirely different execution trace.


Nope.

H(P,P) always does the same thing, right? if not, H fails to be an actual computation.

Every H(P,P) that is invoked or simulated must do the same thing.
The simulated input to H(P,P) does not do the same thing as the directly executed P(P). This is an easily verifiable fact.

WHY? Isn't that the DEFINITION of a correct simulation.

The only possible answer is that your H isn't actually a Halt Decider and thus the input P,P doesn't actually represent P(P).

If this is because you claim it can't be given a representation of that computation, that PROVES the Halting Theorem, as if you can't ask the question, the decider can't give the right answer.


It gets me very angry when people disagree with easily verifiable facts.
(1) There is zero proof (none at all) of consequential election fraud in the 2020 presidential election.

What does that have to do with this? MORE RED HERRING


(2) The two MRNA Covid-19 vaccines have proved to save very many lives and have close to zero cases of bad side effects.

What does that have to do with this? MORE RED HERRING


(3) Very severe climate change caused by humans is real and we are quickly reaching the point of no return. If not corrected there will be very dire consequences.


What does that have to do with this? MORE RED HERRING

You claim it is easily verified, and then don't actually show a verification.

This implies that you really can't show what you claim.

You didn't answer ANY of the questions I put to you, which implies that you don't have answers, because you are caught in your lie,

Your claimed rebutal doesn't meet the definiton of the problem, so is invalid.

You must follow the rules to be in the game, don't follow the rules, and you can't be actually playing in the game, and you arguement is meaningless.

Someday you may find this out the hard way. You don't get to change the rules to a game you didn't create and still be playing it.

That is like bringing a rifle to an archery contest and wondering why you are disqualified even though you put every shot in the bullseye.


1
rocksolid light 0.7.2
clearneti2ptor