Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

You're already carrying the sphere!


computers / comp.ai.philosophy / Re: 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) (updateRichard 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) (updateRichard 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
Halting problem undecidability and infinitely nested simulation (V5) (update)

<fdqdnUSJaca2wxT_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8864&group=comp.ai.philosophy#8864

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.lang.c comp.lang.c++
Followup: comp.theory,comp.ai.philosophy,sci.logic
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
 by: olcott - Sat, 21 May 2022 21:48 UTC

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.

--
Copyright 2022 Pete Olcott

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

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<fdqdnUeJacZdwxT_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8865&group=comp.ai.philosophy#8865

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sat, 21 May 2022 21:50 UTC

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


Click here to read the complete article
Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<t6bob2$1ef2$1@gioia.aioe.org>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8866&group=comp.ai.philosophy#8866

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Mutt Buncher - Sat, 21 May 2022 22:16 UTC

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.

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<20220521235140.0000042c@reddwarf.jmc>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8867&group=comp.ai.philosophy#8867

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Mr Flibble - Sat, 21 May 2022 22:51 UTC

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

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<eOCdnRREktlK8BT_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8868&group=comp.ai.philosophy#8868

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sat, 21 May 2022 22:55 UTC

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

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<20220522000111.00006d62@reddwarf.jmc>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8869&group=comp.ai.philosophy#8869

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Mr Flibble - Sat, 21 May 2022 23:01 UTC

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

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<obKdnR7jl4MP7RT_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8870&group=comp.ai.philosophy#8870

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sat, 21 May 2022 23:06 UTC

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

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<20220522001158.000067bf@reddwarf.jmc>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8871&group=comp.ai.philosophy#8871

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Mr Flibble - Sat, 21 May 2022 23:11 UTC

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

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<WdidnWVT--Cx6RT_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8872&group=comp.ai.philosophy#8872

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sat, 21 May 2022 23:22 UTC

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

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<20220522013420.00007c03@reddwarf.jmc>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8873&group=comp.ai.philosophy#8873

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Mr Flibble - Sun, 22 May 2022 00:34 UTC

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

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<YqmdnfUYvaC5GxT_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8874&group=comp.ai.philosophy#8874

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sun, 22 May 2022 00:38 UTC

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

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<BWfiK.28445$J0r9.15509@fx11.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8876&group=comp.ai.philosophy#8876

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Richard Damon - Sun, 22 May 2022 01:00 UTC

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.


Click here to read the complete article
Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<zYfiK.28446$J0r9.11872@fx11.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8877&group=comp.ai.philosophy#8877

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Richard Damon - Sun, 22 May 2022 01:02 UTC

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.

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<WKydnZFQmbVnFhT_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8879&group=comp.ai.philosophy#8879

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sun, 22 May 2022 01:03 UTC

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

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<RbgiK.1051$gjlb.660@fx44.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8881&group=comp.ai.philosophy#8881

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Richard Damon - Sun, 22 May 2022 01:18 UTC

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.

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<UvudnUYlhdZ_DxT_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8883&group=comp.ai.philosophy#8883

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sun, 22 May 2022 01:33 UTC

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

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<%ghiK.9437$kaDc.1420@fx46.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8885&group=comp.ai.philosophy#8885

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Richard Damon - Sun, 22 May 2022 02:32 UTC

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

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<ZMadnSJEEuIiPBT_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8887&group=comp.ai.philosophy#8887

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sun, 22 May 2022 02:36 UTC

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

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<m_hiK.1178$lW.915@fx38.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8889&group=comp.ai.philosophy#8889

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Richard Damon - Sun, 22 May 2022 03:20 UTC

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.

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<RrSdnaznM62vMhT_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8891&group=comp.ai.philosophy#8891

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sun, 22 May 2022 03:34 UTC

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

Re: Halting problem undecidability and infinitely nested simulation (V5) (update)

<RBiiK.9439$kaDc.1365@fx46.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8893&group=comp.ai.philosophy#8893

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Richard Damon - Sun, 22 May 2022 04:02 UTC

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
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor