Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Heisenberg might have been here.


devel / comp.theory / Re: Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correct

SubjectAuthor
* Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correcolcott
+* Anyone wanting an actual honestly dialogue on the proof thatRichard Damon
|`* Anyone wanting an actual honestly dialogue on the proof thatolcott
| `* Anyone wanting an actual honestly dialogue on the proof thatRichard Damon
|  `* Anyone wanting an actual honestly dialogue on the proof thatolcott
|   `* Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correcRichard Damon
|    `* Anyone wanting an actual honest dialogue on the proof that H(P,P)==0 is correctolcott
|     `* Anyone wanting an actual honest dialogue on the proof thatRichard Damon
|      `* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|       +* Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|       |`* Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|       | `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|       +* Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|       |`* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|       | `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|       `* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|        `* Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|         `* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|          `* Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|           +* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]Malcolm McLean
|           |+* Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|           ||+* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|           |||`* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|           ||| +- Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|           ||| `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|           ||`* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|           || `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|           |`* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]Ben Bacarisse
|           | +- Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|           | `* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|           |  +- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|           |  `* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]Malcolm McLean
|           |   `- Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|           `* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|            `* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|             +* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |`* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|             | `* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |  `* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|             |   +- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|             |   `* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |    `* Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|             |     +* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |     |`* Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|             |     | +* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |     | |`* Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
|             |     | | `* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |     | |  `* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|             |     | |   `* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |     | |    `* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|             |     | |     +* Honest dialogue on the proof that H(P,P)==0 is correct [proofAndré G. Isaak
|             |     | |     |`* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|             |     | |     | `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|             |     | |     `- Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]Malcolm McLean
|             |     | `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|             |     `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
|             `- Honest dialogue on the proof that H(P,P)==0 is correct [proofRichard Damon
`* Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correcAlan Mackenzie
 `* Honest dialogue on the proof that H(P,P)==0 is correctolcott
  +* Honest dialogue on the proof that H(P,P)==0 is correctAlan Mackenzie
  |`* Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
  | `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]Alan Mackenzie
  |  `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
  |   `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]Alan Mackenzie
  |    `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
  |     `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]Alan Mackenzie
  |      `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
  |       `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]Alan Mackenzie
  |        `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]olcott
  |         `* Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]Alan Mackenzie
  |          +- Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
  |          `- Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
  `- Honest dialogue on the proof that H(P,P)==0 is correctRichard Damon

Pages:123
Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correct

<HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19523&group=comp.theory#19523

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 05 Aug 2021 12:42:51 -0500
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
X-Mozilla-News-Host: news://news.giganews.com:119
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
Subject: Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correct
Date: Thu, 5 Aug 2021 12:42:51 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
Lines: 198
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jf0n1F9HEsjwWzQHPlYS1UyWH6BXl7FyISPAVXeZH+FwR5O578AGgNSBnpmobXlZLTyK5sBvnTkRFxW!A1rvuH8GUzqp1RJtlMHEUGu6eFMraVqdrqk9Yc9ddfqmcGx+NzY63k5SlWpn8HvC5ukbJsyZZg==
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: 10006
 by: olcott - Thu, 5 Aug 2021 17:42 UTC

The x86utm operating system was created so that the halting problem
could be examined concretely in the high level language of C. H is a
function written in C that analyzes the x86 machine language execution
trace of other functions written in C. H recognizes simple cases of
infinite recursion and infinite loops. The conventional halting problem
proof counter-example template is shown to simply be an input that does
not halt.

H simulates its input with an x86 emulator until it determines that its
input would never halt. As soon as H recognizes that its input would
never halt it stops simulating this input and returns 0. For inputs that
do halt H acts exactly as if it was an x86 emulator and simply runs its
input to completion and then returns 1.

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.
https://en.wikipedia.org/wiki/Halting_problem

Simulating partial halt decider H correctly decides that P(P) never
halts (V2)

int Simulate(u32 P, u32 I)
{ ((int(*)(int))P)(I);
return 1;
}

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{ if (H(x, x))
HERE: goto HERE;
}

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

_Simulate()
[00000ce2](01) 55 push ebp
[00000ce3](02) 8bec mov ebp,esp
[00000ce5](03) 8b450c mov eax,[ebp+0c]
[00000ce8](01) 50 push eax // push 2nd Param
[00000ce9](03) ff5508 call dword [ebp+08] // call 1st Param
[00000cec](03) 83c404 add esp,+04
[00000cef](05) b801000000 mov eax,00000001
[00000cf4](01) 5d pop ebp
[00000cf5](01) c3 ret
Size in bytes:(0020) [00000cf5]

_P()
[00000d02](01) 55 push ebp
[00000d03](02) 8bec mov ebp,esp
[00000d05](03) 8b4508 mov eax,[ebp+08]
[00000d08](01) 50 push eax // push 2nd Param
[00000d09](03) 8b4d08 mov ecx,[ebp+08]
[00000d0c](01) 51 push ecx // push 1st Param
[00000d0d](05) e870feffff call 00000b82 // call H
[00000d12](03) 83c408 add esp,+08
[00000d15](02) 85c0 test eax,eax
[00000d17](02) 7402 jz 00000d1b
[00000d19](02) ebfe jmp 00000d19
[00000d1b](01) 5d pop ebp
[00000d1c](01) c3 ret
Size in bytes:(0027) [00000d1c]

_main()
[00000d22](01) 55 push ebp
[00000d23](02) 8bec mov ebp,esp
[00000d25](05) 68020d0000 push 00000d02 // push P
[00000d2a](05) 68020d0000 push 00000d02 // push P
[00000d2f](05) e8aeffffff call 00000ce2 // call Simulate
[00000d34](03) 83c408 add esp,+08
[00000d37](01) 50 push eax
[00000d38](05) 6823030000 push 00000323
[00000d3d](05) e810f6ffff call 00000352 // call Output
[00000d42](03) 83c408 add esp,+08
[00000d45](02) 33c0 xor eax,eax
[00000d47](01) 5d pop ebp
[00000d48](01) c3 ret
Size in bytes:(0039) [00000d48]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
....[00000d22][00101851][00000000] 55 push ebp
....[00000d23][00101851][00000000] 8bec mov ebp,esp
....[00000d25][0010184d][00000d02] 68020d0000 push 00000d02 // push P
....[00000d2a][00101849][00000d02] 68020d0000 push 00000d02 // push P
....[00000d2f][00101845][00000d34] e8aeffffff call 00000ce2 // call
Simulate
....[00000ce2][00101841][00101851] 55 push ebp
....[00000ce3][00101841][00101851] 8bec mov ebp,esp
....[00000ce5][00101841][00101851] 8b450c mov eax,[ebp+0c]
....[00000ce8][0010183d][00000d02] 50 push eax
Calling:_P()
....[00000ce9][00101839][00000cec] ff5508 call dword [ebp+08]
....[00000d02][00101835][00101841] 55 push ebp
....[00000d03][00101835][00101841] 8bec mov ebp,esp
....[00000d05][00101835][00101841] 8b4508 mov eax,[ebp+08]
....[00000d08][00101831][00000d02] 50 push eax
....[00000d09][00101831][00000d02] 8b4d08 mov ecx,[ebp+08]
....[00000d0c][0010182d][00000d02] 51 push ecx
....[00000d0d][00101829][00000d12] e870feffff call 00000b82 // call H

Begin Local Halt Decider Simulation at Machine Address:d02
....[00000d02][002118f1][002118f5] 55 push ebp
....[00000d03][002118f1][002118f5] 8bec mov ebp,esp
....[00000d05][002118f1][002118f5] 8b4508 mov eax,[ebp+08]
....[00000d08][002118ed][00000d02] 50 push eax // push P
....[00000d09][002118ed][00000d02] 8b4d08 mov ecx,[ebp+08]
....[00000d0c][002118e9][00000d02] 51 push ecx // push P
....[00000d0d][002118e5][00000d12] e870feffff call 00000b82 // call H
....[00000d02][0025c319][0025c31d] 55 push ebp
....[00000d03][0025c319][0025c31d] 8bec mov ebp,esp
....[00000d05][0025c319][0025c31d] 8b4508 mov eax,[ebp+08]
....[00000d08][0025c315][00000d02] 50 push eax // push P
....[00000d09][0025c315][00000d02] 8b4d08 mov ecx,[ebp+08]
....[00000d0c][0025c311][00000d02] 51 push ecx // push P
....[00000d0d][0025c30d][00000d12] e870feffff call 00000b82 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

....[00000d12][00101835][00101841] 83c408 add esp,+08
....[00000d15][00101835][00101841] 85c0 test eax,eax
....[00000d17][00101835][00101841] 7402 jz 00000d1b
....[00000d1b][00101839][00000cec] 5d pop ebp
....[00000d1c][0010183d][00000d02] c3 ret
....[00000cec][00101841][00101851] 83c404 add esp,+04
....[00000cef][00101841][00101851] b801000000 mov eax,00000001
....[00000cf4][00101845][00000d34] 5d pop ebp
....[00000cf5][00101849][00000d02] c3 ret
....[00000d34][00101851][00000000] 83c408 add esp,+08
....[00000d37][0010184d][00000001] 50 push eax
....[00000d38][00101849][00000323] 6823030000 push 00000323
---[00000d3d][00101849][00000323] e810f6ffff call 00000352 // call Output
Input_Halts = 1
....[00000d42][00101851][00000000] 83c408 add esp,+08
....[00000d45][00101851][00000000] 33c0 xor eax,eax
....[00000d47][00101855][00100000] 5d pop ebp
....[00000d48][00101859][000000bc] c3 ret
Number_of_User_Instructions(48)
Number of Instructions Executed(23742)

Because H only acts as a pure simulator of its input until after its
halt status decision has been made it has no behavior that can possibly
effect the behavior of its input. Because of this H screens out its own
address range in every execution trace that it examines. This is why we
never see any instructions of H in any execution trace after an input
calls H.

Halting is provable on the basis that a pure simulation reaches the
final state.
P reaches its final state.

Never Halting is provable on the basis that the final state can never be
reached.

(a) We know that the x86 execution trace of the simulation of P(P) is a
pure simulation by comparing it to the source-code of P. (also see the
first paragraph).

(b) We know that whether or not H aborts its simulation of its input to
H(P,P) that this input would never reach its final state (proved by the
x86 execution trace shown above).

Because there are no control flow instructions in the execution trace
that would escape the infinite recursion the execution trace proves that
a pure simulation of the above input would never reach its final state.

(c) Because input to H(P,P) would never reach its final state we know
that it never halts.

(d) Because it never halts we know that H(P,P) correctly returns 0
indicating that its input never halts.

If there is no error in (a)(b)(c)(d) then we know H(P,P)==0 is the
correct halt status.

There may be a very high tendency to reject this latter claim
out-of-hand without sufficient review through the human fallibility of
bias. If no error exists in steps (a)(b)(c)(d) then we know that
H(P,P)==0 is the correct halt status of the input to the input to H(P,P).

If P(P) halts and H(P,P)==0 is the correct halt status of the input to
the input to H(P,P) then we have a paradox rather than a contradiction.

The full paper is published here:
https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correct

<Vs0PI.2099$xY.509@fx05.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19546&group=comp.theory#19546

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc3.netnews.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx05.iad.POSTED!not-for-mail
Subject: Re: Anyone wanting an actual honestly dialogue on the proof that
H(P,P)==0 is correct
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 200
Message-ID: <Vs0PI.2099$xY.509@fx05.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: Thu, 5 Aug 2021 20:43:16 -0500
X-Received-Bytes: 10737
 by: Richard Damon - Fri, 6 Aug 2021 01:43 UTC

On 8/5/21 12:42 PM, olcott wrote:
> The x86utm operating system was created so that the halting problem
> could be examined concretely in the high level language of C. H is a
> function written in C that analyzes the x86 machine language execution
> trace of other functions written in C. H recognizes simple cases of
> infinite recursion and infinite loops. The conventional halting problem
> proof counter-example template is shown to simply be an input that does
> not halt.
>
> H simulates its input with an x86 emulator until it determines that its
> input would never halt. As soon as H recognizes that its input would
> never halt it stops simulating this input and returns 0. For inputs that
> do halt H acts exactly as if it was an x86 emulator and simply runs its
> input to completion and then returns 1.
>
>    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.
>    https://en.wikipedia.org/wiki/Halting_problem
>
> Simulating partial halt decider H correctly decides that P(P) never
> halts (V2)
>
> int Simulate(u32 P, u32 I)
> {
>   ((int(*)(int))P)(I);
>   return 1;
> }
>
> // Simplified Linz Ĥ (Linz:1990:319)
> // Strachey(1965) CPL translated to C
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
> }
>
> int main()
> {
>   Output("Input_Halts = ", Simulate((u32)P, (u32)P));
> }
>
> _Simulate()
> [00000ce2](01)  55          push ebp
> [00000ce3](02)  8bec        mov ebp,esp
> [00000ce5](03)  8b450c      mov eax,[ebp+0c]
> [00000ce8](01)  50          push eax            // push 2nd Param
> [00000ce9](03)  ff5508      call dword [ebp+08] // call 1st Param
> [00000cec](03)  83c404      add esp,+04
> [00000cef](05)  b801000000  mov eax,00000001
> [00000cf4](01)  5d          pop ebp
> [00000cf5](01)  c3          ret
> Size in bytes:(0020) [00000cf5]
>
> _P()
> [00000d02](01)  55          push ebp
> [00000d03](02)  8bec        mov ebp,esp
> [00000d05](03)  8b4508      mov eax,[ebp+08]
> [00000d08](01)  50          push eax       // push 2nd Param
> [00000d09](03)  8b4d08      mov ecx,[ebp+08]
> [00000d0c](01)  51          push ecx       // push 1st Param
> [00000d0d](05)  e870feffff  call 00000b82  // call H
> [00000d12](03)  83c408      add esp,+08
> [00000d15](02)  85c0        test eax,eax
> [00000d17](02)  7402        jz 00000d1b
> [00000d19](02)  ebfe        jmp 00000d19
> [00000d1b](01)  5d          pop ebp
> [00000d1c](01)  c3          ret
> Size in bytes:(0027) [00000d1c]
>
> _main()
> [00000d22](01)  55          push ebp
> [00000d23](02)  8bec        mov ebp,esp
> [00000d25](05)  68020d0000  push 00000d02 // push P
> [00000d2a](05)  68020d0000  push 00000d02 // push P
> [00000d2f](05)  e8aeffffff  call 00000ce2 // call Simulate
> [00000d34](03)  83c408      add esp,+08
> [00000d37](01)  50          push eax
> [00000d38](05)  6823030000  push 00000323
> [00000d3d](05)  e810f6ffff  call 00000352 // call Output
> [00000d42](03)  83c408      add esp,+08
> [00000d45](02)  33c0        xor eax,eax
> [00000d47](01)  5d          pop ebp
> [00000d48](01)  c3          ret
> Size in bytes:(0039) [00000d48]
>
>     machine   stack     stack     machine     assembly
>     address   address   data      code        language
>     ========  ========  ========  =========   =============
> ...[00000d22][00101851][00000000] 55          push ebp
> ...[00000d23][00101851][00000000] 8bec        mov ebp,esp
> ...[00000d25][0010184d][00000d02] 68020d0000  push 00000d02  // push P
> ...[00000d2a][00101849][00000d02] 68020d0000  push 00000d02  // push P
> ...[00000d2f][00101845][00000d34] e8aeffffff  call 00000ce2  // call
> Simulate
> ...[00000ce2][00101841][00101851] 55          push ebp
> ...[00000ce3][00101841][00101851] 8bec        mov ebp,esp
> ...[00000ce5][00101841][00101851] 8b450c      mov eax,[ebp+0c]
> ...[00000ce8][0010183d][00000d02] 50          push eax
> Calling:_P()
> ...[00000ce9][00101839][00000cec] ff5508      call dword [ebp+08]
> ...[00000d02][00101835][00101841] 55          push ebp
> ...[00000d03][00101835][00101841] 8bec        mov ebp,esp
> ...[00000d05][00101835][00101841] 8b4508      mov eax,[ebp+08]
> ...[00000d08][00101831][00000d02] 50          push eax
> ...[00000d09][00101831][00000d02] 8b4d08      mov ecx,[ebp+08]
> ...[00000d0c][0010182d][00000d02] 51          push ecx
> ...[00000d0d][00101829][00000d12] e870feffff  call 00000b82  // call H
>
> Begin Local Halt Decider Simulation at Machine Address:d02
> ...[00000d02][002118f1][002118f5] 55          push ebp
> ...[00000d03][002118f1][002118f5] 8bec        mov ebp,esp
> ...[00000d05][002118f1][002118f5] 8b4508      mov eax,[ebp+08]
> ...[00000d08][002118ed][00000d02] 50          push eax       // push P
> ...[00000d09][002118ed][00000d02] 8b4d08      mov ecx,[ebp+08]
> ...[00000d0c][002118e9][00000d02] 51          push ecx       // push P
> ...[00000d0d][002118e5][00000d12] e870feffff  call 00000b82  // call H
> ...[00000d02][0025c319][0025c31d] 55          push ebp
> ...[00000d03][0025c319][0025c31d] 8bec        mov ebp,esp
> ...[00000d05][0025c319][0025c31d] 8b4508      mov eax,[ebp+08]
> ...[00000d08][0025c315][00000d02] 50          push eax       // push P
> ...[00000d09][0025c315][00000d02] 8b4d08      mov ecx,[ebp+08]
> ...[00000d0c][0025c311][00000d02] 51          push ecx       // push P
> ...[00000d0d][0025c30d][00000d12] e870feffff  call 00000b82  // call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> ...[00000d12][00101835][00101841] 83c408      add esp,+08
> ...[00000d15][00101835][00101841] 85c0        test eax,eax
> ...[00000d17][00101835][00101841] 7402        jz 00000d1b
> ...[00000d1b][00101839][00000cec] 5d          pop ebp
> ...[00000d1c][0010183d][00000d02] c3          ret
> ...[00000cec][00101841][00101851] 83c404      add esp,+04
> ...[00000cef][00101841][00101851] b801000000  mov eax,00000001
> ...[00000cf4][00101845][00000d34] 5d          pop ebp
> ...[00000cf5][00101849][00000d02] c3          ret
> ...[00000d34][00101851][00000000] 83c408      add esp,+08
> ...[00000d37][0010184d][00000001] 50          push eax
> ...[00000d38][00101849][00000323] 6823030000  push 00000323
> ---[00000d3d][00101849][00000323] e810f6ffff  call 00000352 // call Output
> Input_Halts = 1
> ...[00000d42][00101851][00000000] 83c408      add esp,+08
> ...[00000d45][00101851][00000000] 33c0        xor eax,eax
> ...[00000d47][00101855][00100000] 5d          pop ebp
> ...[00000d48][00101859][000000bc] c3          ret
> Number_of_User_Instructions(48)
> Number of Instructions Executed(23742)
>
> Because H only acts as a pure simulator of its input until after its
> halt status decision has been made it has no behavior that can possibly
> effect the behavior of its input. Because of this H screens out its own
> address range in every execution trace that it examines. This is why we
> never see any instructions of H in any execution trace after an input
> calls H.
>
> Halting is provable on the basis that a pure simulation reaches the
> final state.
> P reaches its final state.
>
> Never Halting is provable on the basis that the final state can never be
> reached.
>
> (a) We know that the x86 execution trace of the simulation of P(P) is a
> pure simulation by comparing it to the source-code of P.  (also see the
> first paragraph).
>
> (b) We know that whether or not H aborts its simulation of its input to
> H(P,P) that this input would never reach its final state (proved by the
> x86 execution trace shown above).
>
> Because there are no control flow instructions in the execution trace
> that would escape the infinite recursion the execution trace proves that
> a pure simulation of the above input would never reach its final state.
>
> (c) Because input to H(P,P) would never reach its final state we know
> that it never halts.
>
> (d) Because it never halts we know that H(P,P) correctly returns 0
> indicating that its input never halts.
>
> If there is no error in (a)(b)(c)(d) then we know H(P,P)==0 is the
> correct halt status.
>
> There may be a very high tendency to reject this latter claim
> out-of-hand without sufficient review through the human fallibility of
> bias. If no error exists in steps (a)(b)(c)(d) then we know that
> H(P,P)==0 is the correct halt status of the input to the input to H(P,P).
>
> If P(P) halts and H(P,P)==0 is the correct halt status of the input to
> the input to H(P,P) then we have a paradox rather than a contradiction.
>
> The full paper is published here:
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
>


Click here to read the complete article
Re: Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correct

<GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19548&group=comp.theory#19548

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 05 Aug 2021 20:55:37 -0500
Subject: Re: Anyone wanting an actual honestly dialogue on the proof that
H(P,P)==0 is correct
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad>
From: NoO...@NoWhere.com (olcott)
Date: Thu, 5 Aug 2021 20:55:36 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <Vs0PI.2099$xY.509@fx05.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
Lines: 226
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-lo0rLLTK3UFQhnA1t6IRzeD4x1eSDUUkur5/2Go284CZx6IxqAGrVZC4VZRdUL9QxW1HjcWuyJPeG/i!nHLuqitXaFHqyBtWGKvEvV1jfShVBTNiQ00VK2rRPM0LOKPmA9eiIRSihtXXkMvtjKqq4TwBwA==
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: 11921
 by: olcott - Fri, 6 Aug 2021 01:55 UTC

On 8/5/2021 8:43 PM, Richard Damon wrote:
> On 8/5/21 12:42 PM, olcott wrote:
>> The x86utm operating system was created so that the halting problem
>> could be examined concretely in the high level language of C. H is a
>> function written in C that analyzes the x86 machine language execution
>> trace of other functions written in C. H recognizes simple cases of
>> infinite recursion and infinite loops. The conventional halting problem
>> proof counter-example template is shown to simply be an input that does
>> not halt.
>>
>> H simulates its input with an x86 emulator until it determines that its
>> input would never halt. As soon as H recognizes that its input would
>> never halt it stops simulating this input and returns 0. For inputs that
>> do halt H acts exactly as if it was an x86 emulator and simply runs its
>> input to completion and then returns 1.
>>
>>    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.
>>    https://en.wikipedia.org/wiki/Halting_problem
>>
>> Simulating partial halt decider H correctly decides that P(P) never
>> halts (V2)
>>
>> int Simulate(u32 P, u32 I)
>> {
>>   ((int(*)(int))P)(I);
>>   return 1;
>> }
>>
>> // Simplified Linz Ĥ (Linz:1990:319)
>> // Strachey(1965) CPL translated to C
>> void P(u32 x)
>> {
>>   if (H(x, x))
>>     HERE: goto HERE;
>> }
>>
>> int main()
>> {
>>   Output("Input_Halts = ", Simulate((u32)P, (u32)P));
>> }
>>
>> _Simulate()
>> [00000ce2](01)  55          push ebp
>> [00000ce3](02)  8bec        mov ebp,esp
>> [00000ce5](03)  8b450c      mov eax,[ebp+0c]
>> [00000ce8](01)  50          push eax            // push 2nd Param
>> [00000ce9](03)  ff5508      call dword [ebp+08] // call 1st Param
>> [00000cec](03)  83c404      add esp,+04
>> [00000cef](05)  b801000000  mov eax,00000001
>> [00000cf4](01)  5d          pop ebp
>> [00000cf5](01)  c3          ret
>> Size in bytes:(0020) [00000cf5]
>>
>> _P()
>> [00000d02](01)  55          push ebp
>> [00000d03](02)  8bec        mov ebp,esp
>> [00000d05](03)  8b4508      mov eax,[ebp+08]
>> [00000d08](01)  50          push eax       // push 2nd Param
>> [00000d09](03)  8b4d08      mov ecx,[ebp+08]
>> [00000d0c](01)  51          push ecx       // push 1st Param
>> [00000d0d](05)  e870feffff  call 00000b82  // call H
>> [00000d12](03)  83c408      add esp,+08
>> [00000d15](02)  85c0        test eax,eax
>> [00000d17](02)  7402        jz 00000d1b
>> [00000d19](02)  ebfe        jmp 00000d19
>> [00000d1b](01)  5d          pop ebp
>> [00000d1c](01)  c3          ret
>> Size in bytes:(0027) [00000d1c]
>>
>> _main()
>> [00000d22](01)  55          push ebp
>> [00000d23](02)  8bec        mov ebp,esp
>> [00000d25](05)  68020d0000  push 00000d02 // push P
>> [00000d2a](05)  68020d0000  push 00000d02 // push P
>> [00000d2f](05)  e8aeffffff  call 00000ce2 // call Simulate
>> [00000d34](03)  83c408      add esp,+08
>> [00000d37](01)  50          push eax
>> [00000d38](05)  6823030000  push 00000323
>> [00000d3d](05)  e810f6ffff  call 00000352 // call Output
>> [00000d42](03)  83c408      add esp,+08
>> [00000d45](02)  33c0        xor eax,eax
>> [00000d47](01)  5d          pop ebp
>> [00000d48](01)  c3          ret
>> Size in bytes:(0039) [00000d48]
>>
>>     machine   stack     stack     machine     assembly
>>     address   address   data      code        language
>>     ========  ========  ========  =========   =============
>> ...[00000d22][00101851][00000000] 55          push ebp
>> ...[00000d23][00101851][00000000] 8bec        mov ebp,esp
>> ...[00000d25][0010184d][00000d02] 68020d0000  push 00000d02  // push P
>> ...[00000d2a][00101849][00000d02] 68020d0000  push 00000d02  // push P
>> ...[00000d2f][00101845][00000d34] e8aeffffff  call 00000ce2  // call
>> Simulate
>> ...[00000ce2][00101841][00101851] 55          push ebp
>> ...[00000ce3][00101841][00101851] 8bec        mov ebp,esp
>> ...[00000ce5][00101841][00101851] 8b450c      mov eax,[ebp+0c]
>> ...[00000ce8][0010183d][00000d02] 50          push eax
>> Calling:_P()
>> ...[00000ce9][00101839][00000cec] ff5508      call dword [ebp+08]
>> ...[00000d02][00101835][00101841] 55          push ebp
>> ...[00000d03][00101835][00101841] 8bec        mov ebp,esp
>> ...[00000d05][00101835][00101841] 8b4508      mov eax,[ebp+08]
>> ...[00000d08][00101831][00000d02] 50          push eax
>> ...[00000d09][00101831][00000d02] 8b4d08      mov ecx,[ebp+08]
>> ...[00000d0c][0010182d][00000d02] 51          push ecx
>> ...[00000d0d][00101829][00000d12] e870feffff  call 00000b82  // call H
>>
>> Begin Local Halt Decider Simulation at Machine Address:d02
>> ...[00000d02][002118f1][002118f5] 55          push ebp
>> ...[00000d03][002118f1][002118f5] 8bec        mov ebp,esp
>> ...[00000d05][002118f1][002118f5] 8b4508      mov eax,[ebp+08]
>> ...[00000d08][002118ed][00000d02] 50          push eax       // push P
>> ...[00000d09][002118ed][00000d02] 8b4d08      mov ecx,[ebp+08]
>> ...[00000d0c][002118e9][00000d02] 51          push ecx       // push P
>> ...[00000d0d][002118e5][00000d12] e870feffff  call 00000b82  // call H
>> ...[00000d02][0025c319][0025c31d] 55          push ebp
>> ...[00000d03][0025c319][0025c31d] 8bec        mov ebp,esp
>> ...[00000d05][0025c319][0025c31d] 8b4508      mov eax,[ebp+08]
>> ...[00000d08][0025c315][00000d02] 50          push eax       // push P
>> ...[00000d09][0025c315][00000d02] 8b4d08      mov ecx,[ebp+08]
>> ...[00000d0c][0025c311][00000d02] 51          push ecx       // push P
>> ...[00000d0d][0025c30d][00000d12] e870feffff  call 00000b82  // call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> ...[00000d12][00101835][00101841] 83c408      add esp,+08
>> ...[00000d15][00101835][00101841] 85c0        test eax,eax
>> ...[00000d17][00101835][00101841] 7402        jz 00000d1b
>> ...[00000d1b][00101839][00000cec] 5d          pop ebp
>> ...[00000d1c][0010183d][00000d02] c3          ret
>> ...[00000cec][00101841][00101851] 83c404      add esp,+04
>> ...[00000cef][00101841][00101851] b801000000  mov eax,00000001
>> ...[00000cf4][00101845][00000d34] 5d          pop ebp
>> ...[00000cf5][00101849][00000d02] c3          ret
>> ...[00000d34][00101851][00000000] 83c408      add esp,+08
>> ...[00000d37][0010184d][00000001] 50          push eax
>> ...[00000d38][00101849][00000323] 6823030000  push 00000323
>> ---[00000d3d][00101849][00000323] e810f6ffff  call 00000352 // call Output
>> Input_Halts = 1
>> ...[00000d42][00101851][00000000] 83c408      add esp,+08
>> ...[00000d45][00101851][00000000] 33c0        xor eax,eax
>> ...[00000d47][00101855][00100000] 5d          pop ebp
>> ...[00000d48][00101859][000000bc] c3          ret
>> Number_of_User_Instructions(48)
>> Number of Instructions Executed(23742)
>>
>> Because H only acts as a pure simulator of its input until after its
>> halt status decision has been made it has no behavior that can possibly
>> effect the behavior of its input. Because of this H screens out its own
>> address range in every execution trace that it examines. This is why we
>> never see any instructions of H in any execution trace after an input
>> calls H.
>>
>> Halting is provable on the basis that a pure simulation reaches the
>> final state.
>> P reaches its final state.
>>
>> Never Halting is provable on the basis that the final state can never be
>> reached.
>>
>> (a) We know that the x86 execution trace of the simulation of P(P) is a
>> pure simulation by comparing it to the source-code of P.  (also see the
>> first paragraph).
>>
>> (b) We know that whether or not H aborts its simulation of its input to
>> H(P,P) that this input would never reach its final state (proved by the
>> x86 execution trace shown above).
>>
>> Because there are no control flow instructions in the execution trace
>> that would escape the infinite recursion the execution trace proves that
>> a pure simulation of the above input would never reach its final state.
>>
>> (c) Because input to H(P,P) would never reach its final state we know
>> that it never halts.
>>
>> (d) Because it never halts we know that H(P,P) correctly returns 0
>> indicating that its input never halts.
>>
>> If there is no error in (a)(b)(c)(d) then we know H(P,P)==0 is the
>> correct halt status.
>>
>> There may be a very high tendency to reject this latter claim
>> out-of-hand without sufficient review through the human fallibility of
>> bias. If no error exists in steps (a)(b)(c)(d) then we know that
>> H(P,P)==0 is the correct halt status of the input to the input to H(P,P).
>>
>> If P(P) halts and H(P,P)==0 is the correct halt status of the input to
>> the input to H(P,P) then we have a paradox rather than a contradiction.
>>
>> The full paper is published here:
>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>
>>
>
> BOGUS. All this already disproven. UNSOUND logic from an UNSOUND mind.
>
> PO refuses to actually respond to rebuttals, so this is just a bunch of
> POOP.
>


Click here to read the complete article
Re: Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correct

<5Z1PI.1823$6h1.1128@fx39.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19557&group=comp.theory#19557

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx39.iad.POSTED!not-for-mail
Subject: Re: Anyone wanting an actual honestly dialogue on the proof that
H(P,P)==0 is correct
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 48
Message-ID: <5Z1PI.1823$6h1.1128@fx39.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: Thu, 5 Aug 2021 22:25:51 -0500
X-Received-Bytes: 2943
 by: Richard Damon - Fri, 6 Aug 2021 03:25 UTC

On 8/5/21 8:55 PM, olcott wrote:

> I don't refuse to respond to rebuttals. I refuse to respond to you.
>
> I also refuse to respond to dishonest dodges, changing the subject to
> avoid addressing the point at hand.
>
> As soon as I prove my point people change the subject.
> It is counter-productive for me to tolerate this.
>
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
> }
>
> It took fifty exchanges for you to pay enough attention to acknowledge
> that int main(){ P(P); } never halts when we assume that H is only a
> pure simulator.
>

No, you refuse to responde to rebuttals from me because I present
rebuttals so clear that you can't come up with an answer to them.

What you call a 'dishonest dodge' is me pointing out that the Nth time
you start an arguement, and are trying to misuse a terminology, that I
point out where you are going to in two steps change the meaning of a
word and still assume the arguement based on a different meaning still
holds.

I think you respond more to others because you can get them sie tracked
into side issues and get them off the fundamental errors in your
arguements, so you can banter with them on those, while I put you right
back on the core issues (I notice you never respond to their core issue
arguments either)

Just like you using a 'Pure Simulator' that isn't one because it will
abort its simulation (when the definition of a pure simulator is one
that NEVER aborts its simulation).

Yes, If H WAS a pure simulator, H^(H^) doesn't halt, but that doesn't
matter because H(H^,H^) never says that.

This says that when you present an argument that starts with the first
type of H and then you have the second type of H you create something
that looks like the Liars Paradox, but actually is only something that
Looks like a paradox because it has been presented by a Liar.

Re: Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correct

<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19563&group=comp.theory#19563

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!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: Thu, 05 Aug 2021 23:26:12 -0500
Subject: Re: Anyone wanting an actual honestly dialogue on the proof that
H(P,P)==0 is correct
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
From: NoO...@NoWhere.com (olcott)
Date: Thu, 5 Aug 2021 23:26:11 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <5Z1PI.1823$6h1.1128@fx39.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com>
Lines: 71
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-KM7IUM84KR+AKEWJkkvY2u5OlLOVGHQasUueAS3AcEsILBsKb2gdYBB85lRo0fq8XZaAiLSfU1lb5VE!dMzhoU+Jy1UD1rqgrwu48qwuNbQWyjWMLAa9rlNqVuXGsx6YiP9G/c/XLxSEsA1FWgfQsTLeaw==
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: 3903
 by: olcott - Fri, 6 Aug 2021 04:26 UTC

On 8/5/2021 10:25 PM, Richard Damon wrote:
> On 8/5/21 8:55 PM, olcott wrote:
>
>> I don't refuse to respond to rebuttals. I refuse to respond to you.
>>
>> I also refuse to respond to dishonest dodges, changing the subject to
>> avoid addressing the point at hand.
>>
>> As soon as I prove my point people change the subject.
>> It is counter-productive for me to tolerate this.
>>
>> void P(u32 x)
>> {
>>   if (H(x, x))
>>     HERE: goto HERE;
>> }
>>
>> It took fifty exchanges for you to pay enough attention to acknowledge
>> that int main(){ P(P); } never halts when we assume that H is only a
>> pure simulator.
>>
>
> No, you refuse to responde to rebuttals from me because I present
> rebuttals so clear that you can't come up with an answer to them.
>

All of your "rebuttals" are entirely anchored in your inability to pay
attention.

> What you call a 'dishonest dodge' is me pointing out that the Nth time
> you start an arguement, and are trying to misuse a terminology, that I

It does not freaking matter that I misuse terminology that is a freaking
dishonest dodge. What matters is that my halt decider is correct.

> point out where you are going to in two steps change the meaning of a
> word and still assume the arguement based on a different meaning still
> holds.
>

THIS IS THE ONLY FREAKING DETAIL THAT COUNTS.
H(P,P)==0 is the correct halt status of the input to H.
Everything that bypasses this point is a dishonest dodge.

> I think you respond more to others because you can get them sie tracked
> into side issues and get them off the fundamental errors in your
> arguements, so you can banter with them on those, while I put you right
> back on the core issues (I notice you never respond to their core issue
> arguments either)
>
> Just like you using a 'Pure Simulator' that isn't one because it will
> abort its simulation (when the definition of a pure simulator is one
> that NEVER aborts its simulation).
>
> Yes, If H WAS a pure simulator, H^(H^) doesn't halt, but that doesn't
> matter because H(H^,H^) never says that.
>
>
> This says that when you present an argument that starts with the first
> type of H and then you have the second type of H you create something
> that looks like the Liars Paradox, but actually is only something that
> Looks like a paradox because it has been presented by a Liar.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correct

<qb9PI.22$uV3.2@fx18.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19565&group=comp.theory#19565

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!feeder.usenetexpress.com!tr1.eu1.usenetexpress.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx18.iad.POSTED!not-for-mail
Subject: Re: Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correct
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com> <5Z1PI.1823$6h1.1128@fx39.iad> <r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 90
Message-ID: <qb9PI.22$uV3.2@fx18.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: Fri, 6 Aug 2021 06:38:59 -0500
X-Received-Bytes: 4114
 by: Richard Damon - Fri, 6 Aug 2021 11:38 UTC

On 8/5/21 11:26 PM, olcott wrote:
> On 8/5/2021 10:25 PM, Richard Damon wrote:
>> On 8/5/21 8:55 PM, olcott wrote:
>>
>>> I don't refuse to respond to rebuttals. I refuse to respond to you.
>>>
>>> I also refuse to respond to dishonest dodges, changing the subject to
>>> avoid addressing the point at hand.
>>>
>>> As soon as I prove my point people change the subject.
>>> It is counter-productive for me to tolerate this.
>>>
>>> void P(u32 x)
>>> {
>>>    if (H(x, x))
>>>      HERE: goto HERE;
>>> }
>>>
>>> It took fifty exchanges for you to pay enough attention to acknowledge
>>> that int main(){ P(P); } never halts when we assume that H is only a
>>> pure simulator.
>>>
>>
>> No, you refuse to responde to rebuttals from me because I present
>> rebuttals so clear that you can't come up with an answer to them.
>>
>
> All of your "rebuttals" are entirely anchored in your inability to pay
> attention.
>

FALSE.

You lack of responses shows you don't understand any of the theory you
are talking about.

>> What you call a 'dishonest dodge' is me pointing out that the Nth time
>> you start an arguement, and are trying to misuse a terminology, that I
>
> It does not freaking matter that I misuse terminology that is a freaking
> dishonest dodge. What matters is that my halt decider is correct.
>

Only if you are misusing the word 'correct', or is it Halting.

Misuse of terminology is Fundamentally wrong.

Glad you admit that.

It shows you utter lack of knowledge in the field.

>> point out where you are going to in two steps change the meaning of a
>> word and still assume the arguement based on a different meaning still
>> holds.
>>
>
> THIS IS THE ONLY FREAKING DETAIL THAT COUNTS.
> H(P,P)==0 is the correct halt status of the input to H.
> Everything that bypasses this point is a dishonest dodge.

Ok, IF Halting is defined to be non-halting, then H(P,P) being
non-halting could be a correct answer in your world of inconsistent logic.

>
>
>> I think you respond more to others because you can get them sie tracked
>> into side issues and get them off the fundamental errors in your
>> arguements, so you can banter with them on those, while I put you right
>> back on the core issues (I notice you never respond to their core issue
>> arguments either)
>>
>> Just like you using a 'Pure Simulator' that isn't one because it will
>> abort its simulation (when the definition of a pure simulator is one
>> that NEVER aborts its simulation).
>>
>> Yes, If H WAS a pure simulator, H^(H^) doesn't halt, but that doesn't
>> matter because H(H^,H^) never says that.
>>
>>
>> This says that when you present an argument that starts with the first
>> type of H and then you have the second type of H you create something
>> that looks like the Liars Paradox, but actually is only something that
>> Looks like a paradox because it has been presented by a Liar.
>>
>
>

Re: Anyone wanting an actual honest dialogue on the proof that H(P,P)==0 is correct

<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19566&group=comp.theory#19566

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!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: Fri, 06 Aug 2021 06:56:53 -0500
Subject: Re: Anyone wanting an actual honest dialogue on the proof that H(P,P)==0 is correct
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com> <5Z1PI.1823$6h1.1128@fx39.iad> <r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
From: NoO...@NoWhere.com (olcott)
Date: Fri, 6 Aug 2021 06:56:52 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <qb9PI.22$uV3.2@fx18.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com>
Lines: 121
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-u0ytzt4Ximt2kPCVdcisAlgmWrYWOhYJx25FcZTCkF8WLdIwrO6PQx6Vo6s/Ufsv84qNrV6OcqEyiDe!LQTNh9ktXmC4SSU68kq14pfR/2aIpgID7mC5aLodz6W+HSSzlsbQYsnUyTmBy/g6UAAEbqXbMQ==
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: 5600
 by: olcott - Fri, 6 Aug 2021 11:56 UTC

On 8/6/2021 6:38 AM, Richard Damon wrote:
> On 8/5/21 11:26 PM, olcott wrote:
>> On 8/5/2021 10:25 PM, Richard Damon wrote:
>>> On 8/5/21 8:55 PM, olcott wrote:
>>>
>>>> I don't refuse to respond to rebuttals. I refuse to respond to you.
>>>>
>>>> I also refuse to respond to dishonest dodges, changing the subject to
>>>> avoid addressing the point at hand.
>>>>
>>>> As soon as I prove my point people change the subject.
>>>> It is counter-productive for me to tolerate this.
>>>>
>>>> void P(u32 x)
>>>> {
>>>>    if (H(x, x))
>>>>      HERE: goto HERE;
>>>> }
>>>>
>>>> It took fifty exchanges for you to pay enough attention to acknowledge
>>>> that int main(){ P(P); } never halts when we assume that H is only a
>>>> pure simulator.
>>>>
>>>
>>> No, you refuse to responde to rebuttals from me because I present
>>> rebuttals so clear that you can't come up with an answer to them.
>>>
>>
>> All of your "rebuttals" are entirely anchored in your inability to pay
>> attention.
>>
>
> FALSE.
>
> You lack of responses shows you don't understand any of the theory you
> are talking about.
>
>>> What you call a 'dishonest dodge' is me pointing out that the Nth time
>>> you start an arguement, and are trying to misuse a terminology, that I
>>
>> It does not freaking matter that I misuse terminology that is a freaking
>> dishonest dodge. What matters is that my halt decider is correct.
>>
>
> Only if you are misusing the word 'correct', or is it Halting.
>
> Misuse of terminology is Fundamentally wrong.

I don't misuse those words. If I misuse terminology that it material to
my proof then there is a problem.

If my misuse of terminology is immaterial to my proof then this is an
side-issue that is irrelevant to my proof.

When people use irrelevant side-issues to avoid addressing the key point
at hand this is a dishonest dodge.

>
> Glad you admit that.
>
> It shows you utter lack of knowledge in the field.
>
>

It does not show an utter lack of knowledge in the field.

It shows a lack of complete knowledge in the field that can effect my
credibility. This lack has no effect on the validity of my proof that
H(P,P)==0 is correct.

>>> point out where you are going to in two steps change the meaning of a
>>> word and still assume the arguement based on a different meaning still
>>> holds.
>>>
>>
>> THIS IS THE ONLY FREAKING DETAIL THAT COUNTS.
>> H(P,P)==0 is the correct halt status of the input to H.
>> Everything that bypasses this point is a dishonest dodge.
>
> Ok, IF Halting is defined to be non-halting, then H(P,P) being
> non-halting could be a correct answer in your world of inconsistent logic.
>

Halting is defined as reaching the final state of the C function.

Not halting is defined as never reaching the final state of the function
while H is in pure simulator mode. Not halting must be defined in terms
of never reaching the final state of the function to distinguish it from
functions that had their simulation aborted.

>>
>>
>>> I think you respond more to others because you can get them sie tracked
>>> into side issues and get them off the fundamental errors in your
>>> arguements, so you can banter with them on those, while I put you right
>>> back on the core issues (I notice you never respond to their core issue
>>> arguments either)
>>>
>>> Just like you using a 'Pure Simulator' that isn't one because it will
>>> abort its simulation (when the definition of a pure simulator is one
>>> that NEVER aborts its simulation).
>>>
>>> Yes, If H WAS a pure simulator, H^(H^) doesn't halt, but that doesn't
>>> matter because H(H^,H^) never says that.
>>>
>>>
>>> This says that when you present an argument that starts with the first
>>> type of H and then you have the second type of H you create something
>>> that looks like the Liars Paradox, but actually is only something that
>>> Looks like a paradox because it has been presented by a Liar.
>>>
>>
>>
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Anyone wanting an actual honest dialogue on the proof that H(P,P)==0 is correct

<owaPI.297$uk4.251@fx20.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19567&group=comp.theory#19567

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx20.iad.POSTED!not-for-mail
Subject: Re: Anyone wanting an actual honest dialogue on the proof that
H(P,P)==0 is correct
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 136
Message-ID: <owaPI.297$uk4.251@fx20.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: Fri, 6 Aug 2021 08:09:38 -0500
X-Received-Bytes: 5755
 by: Richard Damon - Fri, 6 Aug 2021 13:09 UTC

On 8/6/21 6:56 AM, olcott wrote:
> On 8/6/2021 6:38 AM, Richard Damon wrote:
>> On 8/5/21 11:26 PM, olcott wrote:
>>> On 8/5/2021 10:25 PM, Richard Damon wrote:
>>>> On 8/5/21 8:55 PM, olcott wrote:
>>>>
>>>>> I don't refuse to respond to rebuttals. I refuse to respond to you.
>>>>>
>>>>> I also refuse to respond to dishonest dodges, changing the subject to
>>>>> avoid addressing the point at hand.
>>>>>
>>>>> As soon as I prove my point people change the subject.
>>>>> It is counter-productive for me to tolerate this.
>>>>>
>>>>> void P(u32 x)
>>>>> {
>>>>>     if (H(x, x))
>>>>>       HERE: goto HERE;
>>>>> }
>>>>>
>>>>> It took fifty exchanges for you to pay enough attention to acknowledge
>>>>> that int main(){ P(P); } never halts when we assume that H is only a
>>>>> pure simulator.
>>>>>
>>>>
>>>> No, you refuse to responde to rebuttals from me because I present
>>>> rebuttals so clear that you can't come up with an answer to them.
>>>>
>>>
>>> All of your "rebuttals" are entirely anchored in your inability to pay
>>> attention.
>>>
>>
>> FALSE.
>>
>> You lack of responses shows you don't understand any of the theory you
>> are talking about.
>>
>>>> What you call a 'dishonest dodge' is me pointing out that the Nth time
>>>> you start an arguement, and are trying to misuse a terminology, that I
>>>
>>> It does not freaking matter that I misuse terminology that is a freaking
>>> dishonest dodge. What matters is that my halt decider is correct.
>>>
>>
>> Only if you are misusing the word 'correct', or is it Halting.
>>
>> Misuse of terminology is Fundamentally wrong.
>
> I don't misuse those words. If I misuse terminology that it material to
> my proof then there is a problem.

Yes, words like Turing Machine, or Halting, or Correct, or Equivalent,
or even Proof.

You don't seem to really know what these are.

>
> If my misuse of terminology is immaterial to my proof then this is an
> side-issue that is irrelevant to my proof.

>
> When people use irrelevant side-issues to avoid addressing the key point
> at hand this is a dishonest dodge.

Oh, and that is another word you misuse, 'dishonest'. It is NOT
dishonest to point out an error in an arguement, even if it isn't the
point you are trying to focus on as long as it does relate to the
problem at hand.

YOU use dishonest dodges to avoid having to try to deal with the
multitude of errors in your logic.

>
>>
>> Glad you admit that.
>>
>> It shows you utter lack of knowledge in the field.
>>
>>
>
> It does not show an utter lack of knowledge in the field.

Whht, like the fact that you totally don't understand what a Turing
Machine or a Computation is? Or Haltimg, or even what a Proof is.

Not sure you really understand what is Truth.

>
> It shows a lack of complete knowledge in the field that can effect my
> credibility. This lack has no effect on the validity of my proof that
> H(P,P)==0 is correct.

Only that just about every statement in you 'proof' is invalid or unsound.

You don't seem to know enough to know how badly you are wrong.

>
>>>> point out where you are going to in two steps change the meaning of a
>>>> word and still assume the arguement based on a different meaning still
>>>> holds.
>>>>
>>>
>>> THIS IS THE ONLY FREAKING DETAIL THAT COUNTS.
>>> H(P,P)==0 is the correct halt status of the input to H.
>>> Everything that bypasses this point is a dishonest dodge.
>>
>> Ok, IF Halting is defined to be non-halting, then H(P,P) being
>> non-halting could be a correct answer in your world of inconsistent
>> logic.
>>
>
> Halting is defined as reaching the final state of the C function.

Right, and when you run P(P) is does that.
>
> Not halting is defined as never reaching the final state of the function
> while H is in pure simulator mode. Not halting must be defined in terms
> of never reaching the final state of the function to distinguish it from
> functions that had their simulation aborted.

WRONG. Not Halting is defined as never being able to reach the final
state of the function when fully run. The fact that a simulation doesn't
get there because the simulation was stopped before it happened to get
there proves nothing.

THIS sort of 'Misuse of Terminology' is why your whole arguments isn't
worth the paper it is written on.

To paraphrase Sargent Shultz, YOU KNOW NOTHING.

You don't seem to even know enough to see how idiodic your statements sound.

Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19570&group=comp.theory#19570

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.math.symbolic comp.software-eng
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!3.eu.feeder.erje.net!feeder.erje.net!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 06 Aug 2021 10:59:59 -0500
Subject: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
Newsgroups: comp.theory,comp.ai.philosophy,sci.math.symbolic,comp.software-eng
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com> <5Z1PI.1823$6h1.1128@fx39.iad> <r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad> <6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
From: NoO...@NoWhere.com (olcott)
Date: Fri, 6 Aug 2021 10:59:58 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <owaPI.297$uk4.251@fx20.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com>
Lines: 242
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-adJkIAYRNx7ES9oPz5UdDSxQaVilaaLPx9aq5U8yq2ByUTspwZz92zR2OAWOSgLoobC5U8l4RUQB6DV!UL7I31t9ekv+Jp8NgvXj4HO2Zawxasl7/L/BhRJHWcN/sl3hv4bC+Js9LEt38XVycyPZ/RKpqw==
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: 10100
 by: olcott - Fri, 6 Aug 2021 15:59 UTC

On 8/6/2021 8:09 AM, Richard Damon wrote:
> On 8/6/21 6:56 AM, olcott wrote:
>> On 8/6/2021 6:38 AM, Richard Damon wrote:
>>> On 8/5/21 11:26 PM, olcott wrote:
>>>> On 8/5/2021 10:25 PM, Richard Damon wrote:
>>>>> On 8/5/21 8:55 PM, olcott wrote:
>>>>>
>>>>>> I don't refuse to respond to rebuttals. I refuse to respond to you.
>>>>>>
>>>>>> I also refuse to respond to dishonest dodges, changing the subject to
>>>>>> avoid addressing the point at hand.
>>>>>>
>>>>>> As soon as I prove my point people change the subject.
>>>>>> It is counter-productive for me to tolerate this.
>>>>>>
>>>>>> void P(u32 x)
>>>>>> {
>>>>>>     if (H(x, x))
>>>>>>       HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> It took fifty exchanges for you to pay enough attention to acknowledge
>>>>>> that int main(){ P(P); } never halts when we assume that H is only a
>>>>>> pure simulator.
>>>>>>
>>>>>
>>>>> No, you refuse to responde to rebuttals from me because I present
>>>>> rebuttals so clear that you can't come up with an answer to them.
>>>>>
>>>>
>>>> All of your "rebuttals" are entirely anchored in your inability to pay
>>>> attention.
>>>>
>>>
>>> FALSE.
>>>
>>> You lack of responses shows you don't understand any of the theory you
>>> are talking about.
>>>
>>>>> What you call a 'dishonest dodge' is me pointing out that the Nth time
>>>>> you start an arguement, and are trying to misuse a terminology, that I
>>>>
>>>> It does not freaking matter that I misuse terminology that is a freaking
>>>> dishonest dodge. What matters is that my halt decider is correct.
>>>>
>>>
>>> Only if you are misusing the word 'correct', or is it Halting.
>>>
>>> Misuse of terminology is Fundamentally wrong.
>>
>> I don't misuse those words. If I misuse terminology that it material to
>> my proof then there is a problem.
>
> Yes, words like Turing Machine, or Halting, or Correct, or Equivalent,
> or even Proof.
>
> You don't seem to really know what these are.
>

(1) Turing Machine, I use this term correctly no errors can be pointed out.

(2) Halting, I may have adapted the original definition, or not.
According to André the final state of a computation must be reached for
a computation to be considered as having halted.

(3) Equivalent, I have adapted the original definition to apply to
subsets of computations.

(4) Correct means that the condition of a conditional expression is
satisfied.

(5) Proof, here is what I mean by proof, it is an adaptation of the
sound deductive inference model such that valid inference must only
include true preserving operations.

By proof I mean the application of truth preserving inference steps to
premises that are known to be true. Since mathematical logic has some
inference steps that are not truth preserving these are ruled out.
https://en.wikipedia.org/wiki/Principle_of_explosion
https://en.wikipedia.org/wiki/Paradoxes_of_material_implication

Validity and Soundness
A deductive argument is said to be valid if and only if it takes a form
that makes it impossible for the premises to be true and the conclusion
nevertheless to be false. Otherwise, a deductive argument is said to be
invalid.

A deductive argument is sound if and only if it is both valid, and all
of its premises are actually true. Otherwise, a deductive argument is
unsound. https://iep.utm.edu/val-snd/

// original definition of valid (same as P → C)

Material conditional
p q p → q
T T T
T F F
F T T
F F T

Transforming the above to become truth preserving:

The definition of valid is changed to:
p q p [PROVES] q
T T T
T F F
F T F
F F F

A deductive argument is said to be valid if and only if it takes a form
that the conclusion is only true if and only if the premises are true.

All of the above is summed up as
P [PROVES] C if and only if (True(P) ⊢ True(C) ∧ False(P) ⊢ False(C))

modal operators are most often interpreted
"□" for "Necessarily" and "◇" for "Possibly".
https://en.wikipedia.org/wiki/Modal_logic
(P [PROVES] C) ↔ (P ↔ □C)

H(P,P)==0 is proven to be true on the basis that truth preserving
operations are applied to premises that are verified as true: (P ↔ □C)

>>
>> If my misuse of terminology is immaterial to my proof then this is an
>> side-issue that is irrelevant to my proof.
>
>
>
>>
>> When people use irrelevant side-issues to avoid addressing the key point
>> at hand this is a dishonest dodge.
>
>
> Oh, and that is another word you misuse, 'dishonest'. It is NOT
> dishonest to point out an error in an arguement, even if it isn't the
> point you are trying to focus on as long as it does relate to the
> problem at hand.
>

If an error is pointed out in the actual argument then this if valid.
If an error is pointed that does not directly pertain to the argument
then this is a dishonest dodge away from the point at hand.

> YOU use dishonest dodges to avoid having to try to deal with the
> multitude of errors in your logic.
>
>>
>>>
>>> Glad you admit that.
>>>
>>> It shows you utter lack of knowledge in the field.
>>>
>>>
>>
>> It does not show an utter lack of knowledge in the field.
>
> Whht, like the fact that you totally don't understand what a Turing
> Machine or a Computation is? Or Haltimg, or even what a Proof is.
>
> Not sure you really understand what is Truth.
>
>>
>> It shows a lack of complete knowledge in the field that can effect my
>> credibility. This lack has no effect on the validity of my proof that
>> H(P,P)==0 is correct.
>
> Only that just about every statement in you 'proof' is invalid or unsound.
>
> You don't seem to know enough to know how badly you are wrong.
>
>>
>>>>> point out where you are going to in two steps change the meaning of a
>>>>> word and still assume the arguement based on a different meaning still
>>>>> holds.
>>>>>
>>>>
>>>> THIS IS THE ONLY FREAKING DETAIL THAT COUNTS.
>>>> H(P,P)==0 is the correct halt status of the input to H.
>>>> Everything that bypasses this point is a dishonest dodge.
>>>
>>> Ok, IF Halting is defined to be non-halting, then H(P,P) being
>>> non-halting could be a correct answer in your world of inconsistent
>>> logic.
>>>
>>
>> Halting is defined as reaching the final state of the C function.
>
> Right, and when you run P(P) is does that.

The Halting problem does not pertain to the behavior of P, it only
pertains the behavior of the input to P.

the Turing machine halting problem. Simply stated, the problem
is: given the description of a Turing machine M and an input w,
does M, when started in the initial configuration q0w, perform a
computation that eventually halts? (Linz:1990:317).

>>
>> Not halting is defined as never reaching the final state of the function
>> while H is in pure simulator mode. Not halting must be defined in terms
>> of never reaching the final state of the function to distinguish it from
>> functions that had their simulation aborted.
>
> WRONG. Not Halting is defined as never being able to reach the final
> state of the function when fully run. The fact that a simulation doesn't
> get there because the simulation was stopped before it happened to get
> there proves nothing.
>

The Halting problem does not pertain to the behavior of P, it only
pertains the behavior of the input to P.

the Turing machine halting problem. Simply stated, the problem
is: given the description of a Turing machine M and an input w,
does M, when started in the initial configuration q0w, perform a
computation that eventually halts? (Linz:1990:317).

The input to H(P,P) does not reach its final state whether or not H ever
aborts the simulation of this input.

This is where you attention deficit disorder comes in. You can't seem to
be able to pay attention to the steps that prove:


Click here to read the complete article
Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<7xmPI.10384$lK.4235@fx41.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19574&group=comp.theory#19574

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!2.eu.feeder.erje.net!feeder.erje.net!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!peer03.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx41.iad.POSTED!not-for-mail
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 393
Message-ID: <7xmPI.10384$lK.4235@fx41.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: Fri, 6 Aug 2021 22:49:38 -0400
X-Received-Bytes: 14883
 by: Richard Damon - Sat, 7 Aug 2021 02:49 UTC

On 8/6/21 10:59 AM, olcott wrote:
> On 8/6/2021 8:09 AM, Richard Damon wrote:
>> On 8/6/21 6:56 AM, olcott wrote:
>>> On 8/6/2021 6:38 AM, Richard Damon wrote:
>>>> On 8/5/21 11:26 PM, olcott wrote:
>>>>> On 8/5/2021 10:25 PM, Richard Damon wrote:
>>>>>> On 8/5/21 8:55 PM, olcott wrote:
>>>>>>
>>>>>>> I don't refuse to respond to rebuttals. I refuse to respond to you.
>>>>>>>
>>>>>>> I also refuse to respond to dishonest dodges, changing the
>>>>>>> subject to
>>>>>>> avoid addressing the point at hand.
>>>>>>>
>>>>>>> As soon as I prove my point people change the subject.
>>>>>>> It is counter-productive for me to tolerate this.
>>>>>>>
>>>>>>> void P(u32 x)
>>>>>>> {
>>>>>>>      if (H(x, x))
>>>>>>>        HERE: goto HERE;
>>>>>>> }
>>>>>>>
>>>>>>> It took fifty exchanges for you to pay enough attention to
>>>>>>> acknowledge
>>>>>>> that int main(){ P(P); } never halts when we assume that H is only a
>>>>>>> pure simulator.
>>>>>>>
>>>>>>
>>>>>> No, you refuse to responde to rebuttals from me because I present
>>>>>> rebuttals so clear that you can't come up with an answer to them.
>>>>>>
>>>>>
>>>>> All of your "rebuttals" are entirely anchored in your inability to pay
>>>>> attention.
>>>>>
>>>>
>>>> FALSE.
>>>>
>>>> You lack of responses shows you don't understand any of the theory you
>>>> are talking about.
>>>>
>>>>>> What you call a 'dishonest dodge' is me pointing out that the Nth
>>>>>> time
>>>>>> you start an arguement, and are trying to misuse a terminology,
>>>>>> that I
>>>>>
>>>>> It does not freaking matter that I misuse terminology that is a
>>>>> freaking
>>>>> dishonest dodge. What matters is that my halt decider is correct.
>>>>>
>>>>
>>>> Only if you are misusing the word 'correct', or is it Halting.
>>>>
>>>> Misuse of terminology is Fundamentally wrong.
>>>
>>> I don't misuse those words. If I misuse terminology that it material to
>>> my proof then there is a problem.
>>
>> Yes, words like Turing Machine, or Halting, or Correct, or Equivalent,
>> or even Proof.
>>
>> You don't seem to really know what these are.
>>
>
> (1) Turing Machine, I use this term correctly no errors can be pointed out.

No, you use the word, but claim things are equivalent that can not be.

For instance, you claim that the Turing Machine for the H^ Machine
doesn't include a copy of the machine H, which it must.

>
> (2) Halting, I may have adapted the original definition, or not.
> According to André the final state of a computation must be reached for
> a computation to be considered as having halted.

Right,

>
> (3) Equivalent, I have adapted the original definition to apply to
> subsets of computations.

There is no 'adapted', things either ARE equivalent or they are not.

Your 'Equivalent' to the H^ Turing machine which takes a representaion,
and makes a copy, doesn't make a copy. This makes it not the equivalent,
especially since you then use an address comparison test to find that
they are the same machine which can't actually be done in a Turing
Machine (maybe you can show your great knowledge of Truing Machine by
showing how you could do this with a REAL Turing Machine).

>
> (4) Correct means that the condition of a conditional expression is
> satisfied.

Halting == Non-Haltign is Correct???

You don't even seem to understand what is a valid premise. You have
NEVER actually quoted an accepted premise to start with, but

>
> (5) Proof, here is what I mean by proof, it is an adaptation of the
> sound deductive inference model such that valid inference must only
> include true preserving operations.

Again, 'adaptaion'? SOUND when you start from FALSE premises.

As I said above, you don't understand what is a Correct presmis.

>
> By proof I mean the application of truth preserving inference steps to
> premises that are known to be true. Since mathematical logic has some
> inference steps that are not truth preserving these are ruled out.
> https://en.wikipedia.org/wiki/Principle_of_explosion
> https://en.wikipedia.org/wiki/Paradoxes_of_material_implication

First problem, Proof need to START with accepted truths. All your proofs
have started with CLAIM, that you try to justify by strained meaning of
words.

You do understand that your concept of All Truth is Provable doesn't
work for the field of Mathematics, and in fact this leads to
inconsistent logic system which leads to you system being subject to
that Principle of explosing.

NOT using some of the

>
> Validity and Soundness
> A deductive argument is said to be valid if and only if it takes a form
> that makes it impossible for the premises to be true and the conclusion
> nevertheless to be false. Otherwise, a deductive argument is said to be
> invalid.

For a proof to be valid, you need to use accepted rules of logical
inference. You need to start with a precise list of premises, and then
combine these with

>
> A deductive argument is sound if and only if it is both valid, and all
> of its premises are actually true. Otherwise, a deductive argument is
> unsound. https://iep.utm.edu/val-snd/

And you keep on using FALSE premises, thus your arguements are UNSOUND.
You don't seem to understand this, as you never actually try to prove
your premises, thus you have no grounds to claim them to be true.

A Deductive Argument must start with PROVEN true premises, not just
claimed true.

'Actually True' means you have to be able to actually show it is true.

>
> // original definition of valid  (same as P → C)
>
> Material conditional
> p   q p → q
> T   T   T
> T   F   F
> F   T   T
> F   F   T
>
> Transforming the above to become truth preserving:
>
> The definition of valid is changed to:
> p   q   p [PROVES] q
> T   T        T
> T   F        F
> F   T        F
> F   F        F

I guess this means all your arguments are not valid, as all your
arguments start with a false premise.

Note, this confuses Valid with Soundness.

The problem with this is that the REAL definition of valid allows you to
be able to prove that an argument would be valid even without knowing if
the premises are true.

For example, This is a valid argument:

John being a Big Boy implies that John is Big.

This is a valid argument. If it turns out that John actually IS a Big
Boy, says we can then use this valid arguement to make the sound
arguement, John is a big boy, thus John is Big.

Even if we later find out that John isn't a Big Boy, the first argument
is still valid.

>
> A deductive argument is said to be valid if and only if it takes a form
> that the conclusion is only true if and only if the premises are true.

WRONG.

Kitty is a black cat, since all black cats are cats, Kitty is a cat.

This is a valid deductive argument.

There is the case that Kitty might actually be a white cat, and thus the
conclusion is True, but there was a false premise. This makes it
unsound, but not invalid.

The conclusion can be true even if the premise is not true. This is
easily true if an argument is of the form of specific to the genuine

>
> All of the above is summed up as
> P [PROVES] C if and only if (True(P) ⊢ True(C) ∧ False(P) ⊢ False(C))
>
> modal operators are most often interpreted
> "□" for "Necessarily" and "◇" for "Possibly".
> https://en.wikipedia.org/wiki/Modal_logic
> (P [PROVES] C) ↔ (P ↔ □C)
>
> H(P,P)==0 is proven to be true on the basis that truth preserving
> operations are applied to premises that are verified as true: (P ↔ □C)
>
>>>
>>> If my misuse of terminology is immaterial to my proof then this is an
>>> side-issue that is irrelevant to my proof.
>>
>>
>>
>>>
>>> When people use irrelevant side-issues to avoid addressing the key point
>>> at hand this is a dishonest dodge.
>>
>>
>> Oh, and that is another word you misuse, 'dishonest'. It is NOT
>> dishonest to point out an error in an arguement, even if it isn't the
>> point you are trying to focus on as long as it does relate to the
>> problem at hand.
>>
>
> If an error is pointed out in the actual argument then this if valid.
> If an error is pointed that does not directly pertain to the argument
> then this is a dishonest dodge away from the point at hand.
>


Click here to read the complete article
Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<gxmPI.2323$805.954@fx43.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19575&group=comp.theory#19575

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx43.iad.POSTED!not-for-mail
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 34
Message-ID: <gxmPI.2323$805.954@fx43.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: Fri, 6 Aug 2021 22:49:47 -0400
X-Received-Bytes: 2528
 by: Richard Damon - Sat, 7 Aug 2021 02:49 UTC

Pulling out one IMPORTANT arguement.

On 8/6/21 10:59 AM, olcott wrote:
>
> The Halting problem does not pertain to the behavior of P, it only
> pertains the behavior of the input to P.
>
>      the Turing machine halting problem. Simply stated, the problem
>      is: given the description of a Turing machine M and an input w,
>      does M, when started in the initial configuration q0w, perform a
>      computation that eventually halts? (Linz:1990:317).

READ THAT AGAIN,

given the description of a Turing Machine M: Thus the input is the
description, and M is the actual Turing Machine that it is the
description of.

Does M, ... perform a computation that eventually halts.

Thus, it is the behavior of the ACTUAL Machine that matters.

What is the input to H, it is the description of the Turing Machine P.
Thus what matter, the behavior of the ACTUAL Turing Machine P

Not, as you seem to want to try to claim, what happens inside the
partial simulation by H of the desciption of P.

Can you understand those words????

FAIR WARING, if you repeat this claim without showing a REAL error in
this statement, I reserve the right to just point to this message and
point out that it has been disproven.

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<WJOdnYLE8v7tnpP8nZ2dnUU7-XHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19577&group=comp.theory#19577

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 06 Aug 2021 22:52:16 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com>
<7xmPI.10384$lK.4235@fx41.iad>
From: NoO...@NoWhere.com (olcott)
Date: Fri, 6 Aug 2021 22:52:14 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <7xmPI.10384$lK.4235@fx41.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <WJOdnYLE8v7tnpP8nZ2dnUU7-XHNnZ2d@giganews.com>
Lines: 540
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-hytDWOVd0O/JoSd/VZFcHfWwigOHUgxOPV3fOnEaxdALBiKgqDKWPYfm+opCtkiKFUDdiHU6SQmq5ue!53ODdY8qtphTQ+w6kWBxTcjo4dvzmXMCuR7np9elwYt5urEPHABy/yMgJdZqtf4E8ZyL3Q6mwQ==
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: 20938
 by: olcott - Sat, 7 Aug 2021 03:52 UTC

On 8/6/2021 9:49 PM, Richard Damon wrote:
> On 8/6/21 10:59 AM, olcott wrote:
>> On 8/6/2021 8:09 AM, Richard Damon wrote:
>>> On 8/6/21 6:56 AM, olcott wrote:
>>>> On 8/6/2021 6:38 AM, Richard Damon wrote:
>>>>> On 8/5/21 11:26 PM, olcott wrote:
>>>>>> On 8/5/2021 10:25 PM, Richard Damon wrote:
>>>>>>> On 8/5/21 8:55 PM, olcott wrote:
>>>>>>>
>>>>>>>> I don't refuse to respond to rebuttals. I refuse to respond to you.
>>>>>>>>
>>>>>>>> I also refuse to respond to dishonest dodges, changing the
>>>>>>>> subject to
>>>>>>>> avoid addressing the point at hand.
>>>>>>>>
>>>>>>>> As soon as I prove my point people change the subject.
>>>>>>>> It is counter-productive for me to tolerate this.
>>>>>>>>
>>>>>>>> void P(u32 x)
>>>>>>>> {
>>>>>>>>      if (H(x, x))
>>>>>>>>        HERE: goto HERE;
>>>>>>>> }
>>>>>>>>
>>>>>>>> It took fifty exchanges for you to pay enough attention to
>>>>>>>> acknowledge
>>>>>>>> that int main(){ P(P); } never halts when we assume that H is only a
>>>>>>>> pure simulator.
>>>>>>>>
>>>>>>>
>>>>>>> No, you refuse to responde to rebuttals from me because I present
>>>>>>> rebuttals so clear that you can't come up with an answer to them.
>>>>>>>
>>>>>>
>>>>>> All of your "rebuttals" are entirely anchored in your inability to pay
>>>>>> attention.
>>>>>>
>>>>>
>>>>> FALSE.
>>>>>
>>>>> You lack of responses shows you don't understand any of the theory you
>>>>> are talking about.
>>>>>
>>>>>>> What you call a 'dishonest dodge' is me pointing out that the Nth
>>>>>>> time
>>>>>>> you start an arguement, and are trying to misuse a terminology,
>>>>>>> that I
>>>>>>
>>>>>> It does not freaking matter that I misuse terminology that is a
>>>>>> freaking
>>>>>> dishonest dodge. What matters is that my halt decider is correct.
>>>>>>
>>>>>
>>>>> Only if you are misusing the word 'correct', or is it Halting.
>>>>>
>>>>> Misuse of terminology is Fundamentally wrong.
>>>>
>>>> I don't misuse those words. If I misuse terminology that it material to
>>>> my proof then there is a problem.
>>>
>>> Yes, words like Turing Machine, or Halting, or Correct, or Equivalent,
>>> or even Proof.
>>>
>>> You don't seem to really know what these are.
>>>
>>
>> (1) Turing Machine, I use this term correctly no errors can be pointed out.
>
> No, you use the word, but claim things are equivalent that can not be.
>
> For instance, you claim that the Turing Machine for the H^ Machine
> doesn't include a copy of the machine H, which it must.
>
>

A RASP machine need not have any copy of its input.
A RASP machine is essentially a very simplified form of the x86
language.
https://en.wikipedia.org/wiki/Random-access_stored-program_machine

>
>
>>
>> (2) Halting, I may have adapted the original definition, or not.
>> According to André the final state of a computation must be reached for
>> a computation to be considered as having halted.
>
> Right,
>
>>
>> (3) Equivalent, I have adapted the original definition to apply to
>> subsets of computations.
>
> There is no 'adapted', things either ARE equivalent or they are not.
>

It is unconventional to even refer to a subset of computations as
equivalent across two different machine architectures. None-the-less the
x86 language is Turing equivalent for the subset of computations that do
not require more memory than is available.

> Your 'Equivalent' to the H^ Turing machine which takes a representaion,
> and makes a copy, doesn't make a copy. This makes it not the equivalent,
> especially since you then use an address comparison test to find that
> they are the same machine which can't actually be done in a Turing
> Machine (maybe you can show your great knowledge of Truing Machine by
> showing how you could do this with a REAL Turing Machine).
>
>>
>> (4) Correct means that the condition of a conditional expression is
>> satisfied.
>
> Halting == Non-Haltign is Correct???
>
> You don't even seem to understand what is a valid premise.

Premises are never valid, they are true or false.
If you want an honest dialogue then you will accept this correction.

> You have
> NEVER actually quoted an accepted premise to start with, but
>

I started working on getting my lingo straight today.
Until I had a solution I could not risk being boxed into a corner by
conventional concepts. I had to do all of my analysis from first
principles, creating my own private language and the basis of slightly
changing the meaning of conventional terms.

>>
>> (5) Proof, here is what I mean by proof, it is an adaptation of the
>> sound deductive inference model such that valid inference must only
>> include true preserving operations.
>
> Again, 'adaptaion'? SOUND when you start from FALSE premises.
>
> As I said above, you don't understand what is a Correct presmis.
>

A correct proof is alsmost exactly like sound deductive inference.
Mathematical logic totally screws up the notion of a correct proof in
that its valid inference rules allow non-truth preserving operations.
That is quite nuts.

>>
>> By proof I mean the application of truth preserving inference steps to
>> premises that are known to be true. Since mathematical logic has some
>> inference steps that are not truth preserving these are ruled out.
>> https://en.wikipedia.org/wiki/Principle_of_explosion
>> https://en.wikipedia.org/wiki/Paradoxes_of_material_implication
>
> First problem, Proof need to START with accepted truths. All your proofs
> have started with CLAIM, that you try to justify by strained meaning of
> words.
>

They must start with truths that are totally verified as completely true
entirely on the basis of the meaning of the expression of language.

> You do understand that your concept of All Truth is Provable doesn't
> work for the field of Mathematics, and in fact this leads to
> inconsistent logic system which leads to you system being subject to
> that Principle of explosing.
>

This is a key error in the philosphical foundation of mathematics.

https://www.researchgate.net/publication/323866366_The_Notion_of_Truth_in_Natural_and_Formal_Languages

> NOT using some of the
>
>
>>
>> Validity and Soundness
>> A deductive argument is said to be valid if and only if it takes a form
>> that makes it impossible for the premises to be true and the conclusion
>> nevertheless to be false. Otherwise, a deductive argument is said to be
>> invalid.
>
> For a proof to be valid, you need to use accepted rules of logical
> inference. You need to start with a precise list of premises, and then
> combine these with
>

I reject all of those accepted rules that are not truth preserving
operations.

>>
>> A deductive argument is sound if and only if it is both valid, and all
>> of its premises are actually true. Otherwise, a deductive argument is
>> unsound. https://iep.utm.edu/val-snd/
>
> And you keep on using FALSE premises, thus your arguements are UNSOUND.
> You don't seem to understand this, as you never actually try to prove
> your premises, thus you have no grounds to claim them to be true.
>

My premises are impossibly false because my premises are x86 code.

> A Deductive Argument must start with PROVEN true premises, not just
> claimed true.
>

Necessarily true premises.

> 'Actually True' means you have to be able to actually show it is true.
>
>>
>> // original definition of valid  (same as P → C)
>>
>> Material conditional
>> p   q p → q
>> T   T   T
>> T   F   F
>> F   T   T
>> F   F   T
>>
>> Transforming the above to become truth preserving:
>>
>> The definition of valid is changed to:
>> p   q   p [PROVES] q
>> T   T        T
>> T   F        F
>> F   T        F
>> F   F        F
>
> I guess this means all your arguments are not valid, as all your
> arguments start with a false premise.
>
> Note, this confuses Valid with Soundness.
>


Click here to read the complete article
Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<sel07d$pcf$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19578&group=comp.theory#19578

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Date: Fri, 6 Aug 2021 21:55:24 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 310
Message-ID: <sel07d$pcf$1@dont-email.me>
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 7 Aug 2021 03:55:26 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="37dafa27e6b92f175da1da930b9df6df";
logging-data="25999"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+1kqjxae+UvFhzHJjVB60B"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:B3wLlYb7sIy+px365rkUAIiM0WY=
In-Reply-To: <a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Sat, 7 Aug 2021 03:55 UTC

On 2021-08-06 09:59, olcott wrote:
> On 8/6/2021 8:09 AM, Richard Damon wrote:
>> On 8/6/21 6:56 AM, olcott wrote:
>>> On 8/6/2021 6:38 AM, Richard Damon wrote:
>>>> On 8/5/21 11:26 PM, olcott wrote:
>>>>> On 8/5/2021 10:25 PM, Richard Damon wrote:
>>>>>> On 8/5/21 8:55 PM, olcott wrote:
>>>>>>
>>>>>>> I don't refuse to respond to rebuttals. I refuse to respond to you.
>>>>>>>
>>>>>>> I also refuse to respond to dishonest dodges, changing the
>>>>>>> subject to
>>>>>>> avoid addressing the point at hand.
>>>>>>>
>>>>>>> As soon as I prove my point people change the subject.
>>>>>>> It is counter-productive for me to tolerate this.
>>>>>>>
>>>>>>> void P(u32 x)
>>>>>>> {
>>>>>>>      if (H(x, x))
>>>>>>>        HERE: goto HERE;
>>>>>>> }
>>>>>>>
>>>>>>> It took fifty exchanges for you to pay enough attention to
>>>>>>> acknowledge
>>>>>>> that int main(){ P(P); } never halts when we assume that H is only a
>>>>>>> pure simulator.
>>>>>>>
>>>>>>
>>>>>> No, you refuse to responde to rebuttals from me because I present
>>>>>> rebuttals so clear that you can't come up with an answer to them.
>>>>>>
>>>>>
>>>>> All of your "rebuttals" are entirely anchored in your inability to pay
>>>>> attention.
>>>>>
>>>>
>>>> FALSE.
>>>>
>>>> You lack of responses shows you don't understand any of the theory you
>>>> are talking about.
>>>>
>>>>>> What you call a 'dishonest dodge' is me pointing out that the Nth
>>>>>> time
>>>>>> you start an arguement, and are trying to misuse a terminology,
>>>>>> that I
>>>>>
>>>>> It does not freaking matter that I misuse terminology that is a
>>>>> freaking
>>>>> dishonest dodge. What matters is that my halt decider is correct.
>>>>>
>>>>
>>>> Only if you are misusing the word 'correct', or is it Halting.
>>>>
>>>> Misuse of terminology is Fundamentally wrong.
>>>
>>> I don't misuse those words. If I misuse terminology that it material to
>>> my proof then there is a problem.
>>
>> Yes, words like Turing Machine, or Halting, or Correct, or Equivalent,
>> or even Proof.
>>
>> You don't seem to really know what these are.
>>
>
> (1) Turing Machine, I use this term correctly no errors can be pointed out.

You've referred to C programs and to x86 programs as 'Turing Machines'.
That is definitely not correct usage/

> (2) Halting, I may have adapted the original definition, or not.
> According to André the final state of a computation must be reached for
> a computation to be considered as having halted.

Yes, but bear in mind that 'halting' refers to Turing Machines operating
on a specific input. It does not refer to simulations or what happens
inside a halting decider. It refers *only* to actual computations, i.e.
an actual Turing Machine operating on an actual input string.

> (3) Equivalent, I have adapted the original definition to apply to
> subsets of computations.

I have no idea what that's even supposed to mean.

> (4) Correct means that the condition of a conditional expression is
> satisfied.

Again, I have no idea what that's even supposed to mean.

> (5) Proof, here is what I mean by proof, it is an adaptation of the
> sound deductive inference model such that valid inference must only
> include true preserving operations.
>
> By proof I mean the application of truth preserving inference steps to
> premises that are known to be true. Since mathematical logic has some
> inference steps that are not truth preserving these are ruled out.
> https://en.wikipedia.org/wiki/Principle_of_explosion
> https://en.wikipedia.org/wiki/Paradoxes_of_material_implication
>
> Validity and Soundness
> A deductive argument is said to be valid if and only if it takes a form
> that makes it impossible for the premises to be true and the conclusion
> nevertheless to be false. Otherwise, a deductive argument is said to be
> invalid.
>
> A deductive argument is sound if and only if it is both valid, and all
> of its premises are actually true. Otherwise, a deductive argument is
> unsound. https://iep.utm.edu/val-snd/
>
> // original definition of valid  (same as P → C)
>
> Material conditional
> p   q p → q
> T   T   T
> T   F   F
> F   T   T
> F   F   T
>
> Transforming the above to become truth preserving:
>
> The definition of valid is changed to:
> p   q   p [PROVES] q
> T   T        T
> T   F        F
> F   T        F
> F   F        F

That is definitely *not* the definition of valid.

> A deductive argument is said to be valid if and only if it takes a form
> that the conclusion is only true if and only if the premises are true.
>
> All of the above is summed up as
> P [PROVES] C if and only if (True(P) ⊢ True(C) ∧ False(P) ⊢ False(C))

Again, that is definitely *not* the definition of a proof.

> modal operators are most often interpreted
> "□" for "Necessarily" and "◇" for "Possibly".
> https://en.wikipedia.org/wiki/Modal_logic
> (P [PROVES] C) ↔ (P ↔ □C)

Not only is that not the definition of proof, but your use of □ is
entirely meaningless above.

You do realise that □ conveys absolutely *no* information unless you
actually specify some sort of modal model? Unless you specify some set
of alternatives under consideration (i.e. a set of "possible worlds")
and some sort of accessibility relationship between those alternatives,
□ is completely uninterpretable.

Why do you insist on using symbols you don't understand?

> H(P,P)==0 is proven to be true on the basis that truth preserving
> operations are applied to premises that are verified as true: (P ↔ □C)

What are P and C in that example?

>>>
>>> If my misuse of terminology is immaterial to my proof then this is an
>>> side-issue that is irrelevant to my proof.
>>
>>
>>
>>>
>>> When people use irrelevant side-issues to avoid addressing the key point
>>> at hand this is a dishonest dodge.
>>
>>
>> Oh, and that is another word you misuse, 'dishonest'. It is NOT
>> dishonest to point out an error in an arguement, even if it isn't the
>> point you are trying to focus on as long as it does relate to the
>> problem at hand.
>>
>
> If an error is pointed out in the actual argument then this if valid.
> If an error is pointed that does not directly pertain to the argument
> then this is a dishonest dodge away from the point at hand.

*All* of the errors which have been pointed out to you have been errors
in the actual argument.

>> YOU use dishonest dodges to avoid having to try to deal with the
>> multitude of errors in your logic.
>>
>>>
>>>>
>>>> Glad you admit that.
>>>>
>>>> It shows you utter lack of knowledge in the field.
>>>>
>>>>
>>>
>>> It does not show an utter lack of knowledge in the field.
>>
>> Whht, like the fact that you totally don't understand what a Turing
>> Machine or a Computation is? Or Haltimg, or even what a Proof is.
>>
>> Not sure you really understand what is Truth.
>>
>>>
>>> It shows a lack of complete knowledge in the field that can effect my
>>> credibility. This lack has no effect on the validity of my proof that
>>> H(P,P)==0 is correct.
>>
>> Only that just about every statement in you 'proof' is invalid or
>> unsound.
>>
>> You don't seem to know enough to know how badly you are wrong.
>>
>>>
>>>>>> point out where you are going to in two steps change the meaning of a
>>>>>> word and still assume the arguement based on a different meaning
>>>>>> still
>>>>>> holds.
>>>>>>
>>>>>
>>>>> THIS IS THE ONLY FREAKING DETAIL THAT COUNTS.
>>>>> H(P,P)==0 is the correct halt status of the input to H.
>>>>> Everything that bypasses this point is a dishonest dodge.
>>>>
>>>> Ok, IF Halting is defined to be non-halting, then H(P,P) being
>>>> non-halting could be a correct answer in your world of inconsistent
>>>> logic.
>>>>
>>>
>>> Halting is defined as reaching the final state of the C function.
>>
>> Right, and when you run P(P) is does that.
>
> The Halting problem does not pertain to the behavior of P, it only
> pertains the behavior of the input to P.


Click here to read the complete article
Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<TaCdnU7ZFu4bmJP8nZ2dnUU7-LfNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19579&group=comp.theory#19579

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.nntp4.net!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 06 Aug 2021 23:01:10 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com> <5Z1PI.1823$6h1.1128@fx39.iad> <r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad> <6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad> <a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <gxmPI.2323$805.954@fx43.iad>
From: NoO...@NoWhere.com (olcott)
Date: Fri, 6 Aug 2021 23:01:08 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <gxmPI.2323$805.954@fx43.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <TaCdnU7ZFu4bmJP8nZ2dnUU7-LfNnZ2d@giganews.com>
Lines: 88
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Z12DjaQKZ6M9/F5kBzhSH3znQsci1KZQZBU10hT/uZ9utI39Ap0Utq2IsooDPor+mJqEHbfdfQQOBeF!c0G8zrdLk8whMsxs+T411+WK1DGWf8UDjuYkfh0G3R2WZCeqyMf1t7jis+pFaB66i5R9FrTAnA==
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: 4285
 by: olcott - Sat, 7 Aug 2021 04:01 UTC

On 8/6/2021 9:49 PM, Richard Damon wrote:
> Pulling out one IMPORTANT arguement.
>
> On 8/6/21 10:59 AM, olcott wrote:
>>
>> The Halting problem does not pertain to the behavior of P, it only
>> pertains the behavior of the input to P.
>>
>>      the Turing machine halting problem. Simply stated, the problem
>>      is: given the description of a Turing machine M and an input w,
>>      does M, when started in the initial configuration q0w, perform a
>>      computation that eventually halts? (Linz:1990:317).
>
> READ THAT AGAIN,
>
> given the description of a Turing Machine M: Thus the input is the
> description, and M is the actual Turing Machine that it is the
> description of.
>
> Does M, ... perform a computation that eventually halts.
>
> Thus, it is the behavior of the ACTUAL Machine that matters.
>

It is the behavior of the machine that is input to H that matters.
It is not the behavior of the machine executed in main() that matters.
I prove that the input to H(P,P) never reaches its final state.

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C

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

int main()
{ P((u32)P);
}

> What is the input to H, it is the description of the Turing Machine P.
> Thus what matter, the behavior of the ACTUAL Turing Machine P
>

Yes you are the only one that got this right.

> Not, as you seem to want to try to claim, what happens inside the
> partial simulation by H of the desciption of P.
>

Do you understand the x86 language well enough to see that a complete
simulation of P keeps repeating ???

_P()
[00000c25](01) 55 push ebp
[00000c26](02) 8bec mov ebp,esp
[00000c28](03) 8b4508 mov eax,[ebp+08]
[00000c2b](01) 50 push eax // push P
[00000c2c](03) 8b4d08 mov ecx,[ebp+08]
[00000c2f](01) 51 push ecx // push P
[00000c30](05) e820fdffff call 00000955 // call H that simulates P
[00000c35](03) 83c408 add esp,+08
[00000c38](02) 85c0 test eax,eax
[00000c3a](02) 7402 jz 00000c3e
[00000c3c](02) ebfe jmp 00000c3c
[00000c3e](01) 5d pop ebp
[00000c3f](01) c3 ret
Size in bytes:(0027) [00000c3f]

> Can you understand those words????
>
>
> FAIR WARING, if you repeat this claim without showing a REAL error in
> this statement, I reserve the right to just point to this message and
> point out that it has been disproven.
>

You got one key element correctly.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19580&group=comp.theory#19580

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 06 Aug 2021 23:23:06 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<Vs0PI.2099$xY.509@fx05.iad> <GLudnUM2eaoEC5H8nZ2dnUU7-evNnZ2d@giganews.com>
<5Z1PI.1823$6h1.1128@fx39.iad>
<r6idnXrkQsZ5JJH8nZ2dnUU7-V_NnZ2d@giganews.com> <qb9PI.22$uV3.2@fx18.iad>
<6radnYHwiMoYvpD8nZ2dnUU7-UPNnZ2d@giganews.com> <owaPI.297$uk4.251@fx20.iad>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Fri, 6 Aug 2021 23:23:04 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sel07d$pcf$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com>
Lines: 399
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-aoGGxIo0tj/FmAPkZoaSWsXm3JX0j8m7VOFFaixhFsVkwEVvMNVFx/2K3U15XXguFl8pjSneSD7ygdE!cyXVPJV374SOhF3UnlPv7GgPAS/x91l5+hlGqERHWx5rmS/tjn2EyfSg1+g62aArEfBlLX4G+w==
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: 16091
 by: olcott - Sat, 7 Aug 2021 04:23 UTC

On 8/6/2021 10:55 PM, André G. Isaak wrote:
> On 2021-08-06 09:59, olcott wrote:
>> On 8/6/2021 8:09 AM, Richard Damon wrote:
>>> On 8/6/21 6:56 AM, olcott wrote:
>>>> On 8/6/2021 6:38 AM, Richard Damon wrote:
>>>>> On 8/5/21 11:26 PM, olcott wrote:
>>>>>> On 8/5/2021 10:25 PM, Richard Damon wrote:
>>>>>>> On 8/5/21 8:55 PM, olcott wrote:
>>>>>>>
>>>>>>>> I don't refuse to respond to rebuttals. I refuse to respond to you.
>>>>>>>>
>>>>>>>> I also refuse to respond to dishonest dodges, changing the
>>>>>>>> subject to
>>>>>>>> avoid addressing the point at hand.
>>>>>>>>
>>>>>>>> As soon as I prove my point people change the subject.
>>>>>>>> It is counter-productive for me to tolerate this.
>>>>>>>>
>>>>>>>> void P(u32 x)
>>>>>>>> {
>>>>>>>>      if (H(x, x))
>>>>>>>>        HERE: goto HERE;
>>>>>>>> }
>>>>>>>>
>>>>>>>> It took fifty exchanges for you to pay enough attention to
>>>>>>>> acknowledge
>>>>>>>> that int main(){ P(P); } never halts when we assume that H is
>>>>>>>> only a
>>>>>>>> pure simulator.
>>>>>>>>
>>>>>>>
>>>>>>> No, you refuse to responde to rebuttals from me because I present
>>>>>>> rebuttals so clear that you can't come up with an answer to them.
>>>>>>>
>>>>>>
>>>>>> All of your "rebuttals" are entirely anchored in your inability to
>>>>>> pay
>>>>>> attention.
>>>>>>
>>>>>
>>>>> FALSE.
>>>>>
>>>>> You lack of responses shows you don't understand any of the theory you
>>>>> are talking about.
>>>>>
>>>>>>> What you call a 'dishonest dodge' is me pointing out that the Nth
>>>>>>> time
>>>>>>> you start an arguement, and are trying to misuse a terminology,
>>>>>>> that I
>>>>>>
>>>>>> It does not freaking matter that I misuse terminology that is a
>>>>>> freaking
>>>>>> dishonest dodge. What matters is that my halt decider is correct.
>>>>>>
>>>>>
>>>>> Only if you are misusing the word 'correct', or is it Halting.
>>>>>
>>>>> Misuse of terminology is Fundamentally wrong.
>>>>
>>>> I don't misuse those words. If I misuse terminology that it material to
>>>> my proof then there is a problem.
>>>
>>> Yes, words like Turing Machine, or Halting, or Correct, or Equivalent,
>>> or even Proof.
>>>
>>> You don't seem to really know what these are.
>>>
>>
>> (1) Turing Machine, I use this term correctly no errors can be pointed
>> out.
>
> You've referred to C programs and to x86 programs as 'Turing Machines'.
> That is definitely not correct usage/
>
>> (2) Halting, I may have adapted the original definition, or not.
>> According to André the final state of a computation must be reached
>> for a computation to be considered as having halted.
>
> Yes, but bear in mind that 'halting' refers to Turing Machines operating
> on a specific input. It does not refer to simulations or what happens
> inside a halting decider. It refers *only* to actual computations, i.e.
> an actual Turing Machine operating on an actual input string.
>

So yet again you prove that you are totally clueless that pure
simulations are computationally equivalent to direct executions ?

>> (3) Equivalent, I have adapted the original definition to apply to
>> subsets of computations.
>
> I have no idea what that's even supposed to mean.
>
>> (4) Correct means that the condition of a conditional expression is
>> satisfied.
>
> Again, I have no idea what that's even supposed to mean.
>
>> (5) Proof, here is what I mean by proof, it is an adaptation of the
>> sound deductive inference model such that valid inference must only
>> include true preserving operations.
>>
>> By proof I mean the application of truth preserving inference steps to
>> premises that are known to be true. Since mathematical logic has some
>> inference steps that are not truth preserving these are ruled out.
>> https://en.wikipedia.org/wiki/Principle_of_explosion
>> https://en.wikipedia.org/wiki/Paradoxes_of_material_implication
>>
>> Validity and Soundness
>> A deductive argument is said to be valid if and only if it takes a
>> form that makes it impossible for the premises to be true and the
>> conclusion nevertheless to be false. Otherwise, a deductive argument
>> is said to be invalid.
>>
>> A deductive argument is sound if and only if it is both valid, and all
>> of its premises are actually true. Otherwise, a deductive argument is
>> unsound. https://iep.utm.edu/val-snd/
>>
>> // original definition of valid  (same as P → C)
>>
>> Material conditional
>> p   q p → q
>> T   T   T
>> T   F   F
>> F   T   T
>> F   F   T
>>
>> Transforming the above to become truth preserving:
>>
>> The definition of valid is changed to:
>> p   q   p [PROVES] q
>> T   T        T
>> T   F        F
>> F   T        F
>> F   F        F
>
> That is definitely *not* the definition of valid.
>

It might be simplest to call what I consider proof simply sound
deductive inference.

>> A deductive argument is said to be valid if and only if it takes a form
>> that the conclusion is only true if and only if the premises are true.
>>
>> All of the above is summed up as
>> P [PROVES] C if and only if (True(P) ⊢ True(C) ∧ False(P) ⊢ False(C))
>
> Again, that is definitely *not* the definition of a proof.
>
>> modal operators are most often interpreted
>> "□" for "Necessarily" and "◇" for "Possibly".
>> https://en.wikipedia.org/wiki/Modal_logic
>> (P [PROVES] C) ↔ (P ↔ □C)
>
> Not only is that not the definition of proof, but your use of □ is
> entirely meaningless above.
>
> You do realise that □ conveys absolutely *no* information unless you

"□" for "Necessarily"
"□" for "Necessarily"
"□" for "Necessarily"
"□" for "Necessarily"
"□" for "Necessarily"

> actually specify some sort of modal model? Unless you specify some set
> of alternatives under consideration (i.e. a set of "possible worlds")
> and some sort of accessibility relationship between those alternatives,
> □ is completely uninterpretable.
>
> Why do you insist on using symbols you don't understand?
>

"□" for "Necessarily"
"□" for "Necessarily"
"□" for "Necessarily"
"□" for "Necessarily"
"□" for "Necessarily"

>> H(P,P)==0 is proven to be true on the basis that truth preserving
>> operations are applied to premises that are verified as true: (P ↔ □C)
>
> What are P and C in that example?

Premise/Conclusion

>
>>>>
>>>> If my misuse of terminology is immaterial to my proof then this is an
>>>> side-issue that is irrelevant to my proof.
>>>
>>>
>>>
>>>>
>>>> When people use irrelevant side-issues to avoid addressing the key
>>>> point
>>>> at hand this is a dishonest dodge.
>>>
>>>
>>> Oh, and that is another word you misuse, 'dishonest'. It is NOT
>>> dishonest to point out an error in an arguement, even if it isn't the
>>> point you are trying to focus on as long as it does relate to the
>>> problem at hand.
>>>
>>
>> If an error is pointed out in the actual argument then this if valid.
>> If an error is pointed that does not directly pertain to the argument
>> then this is a dishonest dodge away from the point at hand.
>
> *All* of the errors which have been pointed out to you have been errors
> in the actual argument.


Click here to read the complete article
Re: Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correct

<seltf3$2g9r$1@news.muc.de>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19583&group=comp.theory#19583

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.mixmin.net!news2.arglkargh.de!news.karotte.org!news.space.net!news.muc.de!.POSTED.news.muc.de!not-for-mail
From: acm...@muc.de (Alan Mackenzie)
Newsgroups: comp.theory
Subject: Re: Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correct
Date: Sat, 7 Aug 2021 12:14:27 -0000 (UTC)
Organization: muc.de e.V.
Message-ID: <seltf3$2g9r$1@news.muc.de>
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
Injection-Date: Sat, 7 Aug 2021 12:14:27 -0000 (UTC)
Injection-Info: news.muc.de; posting-host="news.muc.de:2001:608:1000::2";
logging-data="82235"; mail-complaints-to="news-admin@muc.de"
User-Agent: tin/2.4.5-20201224 ("Glen Albyn") (FreeBSD/12.2-RELEASE-p7 (amd64))
 by: Alan Mackenzie - Sat, 7 Aug 2021 12:14 UTC

In comp.theory olcott <NoOne@nowhere.com> wrote:
> The x86utm operating system was created so that the halting problem
> could be examined concretely in the high level language of C. H is a
> function written in C that analyzes the x86 machine language execution
> trace of other functions written in C. H recognizes simple cases of
> infinite recursion and infinite loops. The conventional halting
> problem proof counter-example template is shown to simply be an input
> that does not halt.

> H simulates its input with an x86 emulator until it determines that
> its input would never halt. As soon as H recognizes that its input
> would never halt it stops simulating this input and returns 0. For
> inputs that do halt H acts exactly as if it was an x86 emulator and
> simply runs its input to completion and then returns 1.

> 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. https://en.wikipedia.org/wiki/Halting_problem

> Simulating partial halt decider H correctly decides that P(P) never
> halts (V2)

If you wanted a truly honest debate about your "proof", you would make
the source code for H available, assuming it actually exists.

[ .... ]

> --
> Copyright 2021 Pete Olcott

> "Great spirits have always encountered violent opposition from mediocre
> minds." Einstein

--
Alan Mackenzie (Nuremberg, Germany).

Re: Honest dialogue on the proof that H(P,P)==0 is correct

<JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19585&group=comp.theory#19585

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 07 Aug 2021 08:54:15 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<seltf3$2g9r$1@news.muc.de>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 7 Aug 2021 08:54:07 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <seltf3$2g9r$1@news.muc.de>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com>
Lines: 61
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-MreuS2DLzZqp20Hv9KVmrdkZliqoxK1OT85T6SPITamfjzV+vhkNYR+Ip006Iq2sglJur8+hrXRGnQT!zmRWgCCtatZXdxHrAuVlfSJaLOOo9w93BtOFHNQGqAkG4oPktU0khmq+PvUoWbzcWiX4kPYGkg==
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: 3966
 by: olcott - Sat, 7 Aug 2021 13:54 UTC

On 8/7/2021 7:14 AM, Alan Mackenzie wrote:
> In comp.theory olcott <NoOne@nowhere.com> wrote:
>> The x86utm operating system was created so that the halting problem
>> could be examined concretely in the high level language of C. H is a
>> function written in C that analyzes the x86 machine language execution
>> trace of other functions written in C. H recognizes simple cases of
>> infinite recursion and infinite loops. The conventional halting
>> problem proof counter-example template is shown to simply be an input
>> that does not halt.
>
>> H simulates its input with an x86 emulator until it determines that
>> its input would never halt. As soon as H recognizes that its input
>> would never halt it stops simulating this input and returns 0. For
>> inputs that do halt H acts exactly as if it was an x86 emulator and
>> simply runs its input to completion and then returns 1.
>
>> 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. https://en.wikipedia.org/wiki/Halting_problem
>
>> Simulating partial halt decider H correctly decides that P(P) never
>> halts (V2)
>
> If you wanted a truly honest debate about your "proof", you would make
> the source code for H available, assuming it actually exists.
>

What the source-code does and how it does it can be fully proven
entirely on the basis of what has been provided.

That people insist on seeing the source-code only proves that they are
not paying enough attention.

The nested simulated calls never return whether or not they are aborted.
The infinitely nested simulations never stop unless they are aborted.

_P()
[00000d02](01) 55 push ebp
[00000d03](02) 8bec mov ebp,esp
[00000d05](03) 8b4508 mov eax,[ebp+08]
[00000d08](01) 50 push eax // push P
[00000d09](03) 8b4d08 mov ecx,[ebp+08]
[00000d0c](01) 51 push ecx // push P
[00000d0d](05) e870feffff call 00000b82 // call H that emulates P
[00000d12](03) 83c408 add esp,+08
[00000d15](02) 85c0 test eax,eax
[00000d17](02) 7402 jz 00000d1b
[00000d19](02) ebfe jmp 00000d19
[00000d1b](01) 5d pop ebp
[00000d1c](01) c3 ret
Size in bytes:(0027) [00000d1c]

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Honest dialogue on the proof that H(P,P)==0 is correct

<sem7cg$puv$1@news.muc.de>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19586&group=comp.theory#19586

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.szaf.org!news.karotte.org!news.space.net!news.muc.de!.POSTED.news.muc.de!not-for-mail
From: acm...@muc.de (Alan Mackenzie)
Newsgroups: comp.theory
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct
Date: Sat, 7 Aug 2021 15:03:44 -0000 (UTC)
Organization: muc.de e.V.
Message-ID: <sem7cg$puv$1@news.muc.de>
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <seltf3$2g9r$1@news.muc.de> <JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com>
Injection-Date: Sat, 7 Aug 2021 15:03:44 -0000 (UTC)
Injection-Info: news.muc.de; posting-host="news.muc.de:2001:608:1000::2";
logging-data="26591"; mail-complaints-to="news-admin@muc.de"
User-Agent: tin/2.4.5-20201224 ("Glen Albyn") (FreeBSD/12.2-RELEASE-p7 (amd64))
 by: Alan Mackenzie - Sat, 7 Aug 2021 15:03 UTC

[ Malicious cross posting removed. ]

In comp.theory olcott <NoOne@nowhere.com> wrote:
> On 8/7/2021 7:14 AM, Alan Mackenzie wrote:

[ .... ]

>> If you wanted a truly honest debate about your "proof", you would make
>> the source code for H available, assuming it actually exists.

> What the source-code does and how it does it can be fully proven
> entirely on the basis of what has been provided.

> That people insist on seeing the source-code only proves that they are
> not paying enough attention.

No. Maybe these people want to verify the whole truth, not just the bit
you would like them to see.

> The nested simulated calls never return whether or not they are aborted.
> The infinitely nested simulations never stop unless they are aborted.

You're clearly not interested in an honest dialogue. You want the
honesty to be on one side only, and it's not your side.

[ .... ]

> --
> Copyright 2021 Pete Olcott

> "Great spirits have always encountered violent opposition from mediocre
> minds." Einstein

--
Alan Mackenzie (Nuremberg, Germany).

Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]

<q7ydnRnqSvJBO5P8nZ2dnUU7-avNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19587&group=comp.theory#19587

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 07 Aug 2021 10:29:32 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as
1,2,3 ]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<seltf3$2g9r$1@news.muc.de> <JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com>
<sem7cg$puv$1@news.muc.de>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 7 Aug 2021 10:29:30 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sem7cg$puv$1@news.muc.de>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <q7ydnRnqSvJBO5P8nZ2dnUU7-avNnZ2d@giganews.com>
Lines: 74
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-6EpDOin4X145fB9OnJiWUsWgVCHVvU15DbE+Nox22/IrYasBwhHdAYSgdvDj+WOS5wqEd8oQQ3IZ9mq!rFV176AtSVO64DJuvZlEMkQ38sG9k45OAwhsyd4JeV27HmR9+NDLcNlU7ro+rTouKGo7nO2zfw==
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: 4118
 by: olcott - Sat, 7 Aug 2021 15:29 UTC

On 8/7/2021 10:03 AM, Alan Mackenzie wrote:
> [ Malicious cross posting removed. ]
>
> In comp.theory olcott <NoOne@nowhere.com> wrote:
>> On 8/7/2021 7:14 AM, Alan Mackenzie wrote:
>
> [ .... ]
>
>>> If you wanted a truly honest debate about your "proof", you would make
>>> the source code for H available, assuming it actually exists.
>
>> What the source-code does and how it does it can be fully proven
>> entirely on the basis of what has been provided.
>
>> That people insist on seeing the source-code only proves that they are
>> not paying enough attention.
>
> No. Maybe these people want to verify the whole truth, not just the bit
> you would like them to see.
>
>> The nested simulated calls never return whether or not they are aborted.
>> The infinitely nested simulations never stop unless they are aborted.
>
> You're clearly not interested in an honest dialogue. You want the
> honesty to be on one side only, and it's not your side.
>

(1) In other words you don't know the x86 language well enough to see
that the call to H at machine address [00000d0d] with (P,P) parameters
cannot possibly stop running unless H aborts its simulation of P?

(2) Furthermore you don't know the x86 language well enough to see that
even if this simulation is aborted that the P of this aborted simulation
cannot possibly proceed to the final state of [00000d1c] after it has
been aborted?

(3) One more thing that you apparently cannot see is that whether or not
the simulation of P is aborted the simulated P cannot possibly proceed
to the final state of [00000d1c] thus the determination that the input
to H(P,P) never halts is correct?

_P()
[00000d02](01) 55 push ebp
[00000d03](02) 8bec mov ebp,esp
[00000d05](03) 8b4508 mov eax,[ebp+08]
[00000d08](01) 50 push eax // push P
[00000d09](03) 8b4d08 mov ecx,[ebp+08]
[00000d0c](01) 51 push ecx // push P
[00000d0d](05) e870feffff call 00000b82 // call H that emulates P
[00000d12](03) 83c408 add esp,+08
[00000d15](02) 85c0 test eax,eax
[00000d17](02) 7402 jz 00000d1b
[00000d19](02) ebfe jmp 00000d19
[00000d1b](01) 5d pop ebp
[00000d1c](01) c3 ret
Size in bytes:(0027) [00000d1c]

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

> [ .... ]
>
>> --
>> Copyright 2021 Pete Olcott
>
>> "Great spirits have always encountered violent opposition from mediocre
>> minds." Einstein
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]

<semc4h$27g8$1@news.muc.de>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19588&group=comp.theory#19588

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news-peer.in.tum.de!news.muc.de!.POSTED.news.muc.de!not-for-mail
From: acm...@muc.de (Alan Mackenzie)
Newsgroups: comp.theory
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]
Date: Sat, 7 Aug 2021 16:24:49 -0000 (UTC)
Organization: muc.de e.V.
Message-ID: <semc4h$27g8$1@news.muc.de>
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <seltf3$2g9r$1@news.muc.de> <JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com> <sem7cg$puv$1@news.muc.de> <q7ydnRnqSvJBO5P8nZ2dnUU7-avNnZ2d@giganews.com>
Injection-Date: Sat, 7 Aug 2021 16:24:49 -0000 (UTC)
Injection-Info: news.muc.de; posting-host="news.muc.de:2001:608:1000::2";
logging-data="73224"; mail-complaints-to="news-admin@muc.de"
User-Agent: tin/2.4.5-20201224 ("Glen Albyn") (FreeBSD/12.2-RELEASE-p7 (amd64))
 by: Alan Mackenzie - Sat, 7 Aug 2021 16:24 UTC

[ Further malicious cross posting removed. ]

In comp.theory olcott <NoOne@nowhere.com> wrote:
> On 8/7/2021 10:03 AM, Alan Mackenzie wrote:
>> [ Malicious cross posting removed. ]

>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>>> On 8/7/2021 7:14 AM, Alan Mackenzie wrote:

>> [ .... ]

>>>> If you wanted a truly honest debate about your "proof", you would make
>>>> the source code for H available, assuming it actually exists.

>>> What the source-code does and how it does it can be fully proven
>>> entirely on the basis of what has been provided.

>>> That people insist on seeing the source-code only proves that they are
>>> not paying enough attention.

>> No. Maybe these people want to verify the whole truth, not just the bit
>> you would like them to see.

>>> The nested simulated calls never return whether or not they are aborted.
>>> The infinitely nested simulations never stop unless they are aborted.

>> You're clearly not interested in an honest dialogue. You want the
>> honesty to be on one side only, and it's not your side.

> (1) In other words you don't know the x86 language well enough to see
> that the call to H at machine address [00000d0d] with (P,P) parameters
> cannot possibly stop running unless H aborts its simulation of P?

> (2) Furthermore you don't know the x86 language well enough to see that
> even if this simulation is aborted that the P of this aborted simulation
> cannot possibly proceed to the final state of [00000d1c] after it has
> been aborted?

> (3) One more thing that you apparently cannot see is that whether or not
> the simulation of P is aborted the simulated P cannot possibly proceed
> to the final state of [00000d1c] thus the determination that the input
> to H(P,P) never halts is correct?

It's nothing to do with my competence with x86. It's to do with your
smoke and mirrors.

You're hiding what, if anything, you have, thus preventing an honest
dialogue. If you were interested in honesty, you would make it as easy
as possible to discuss your results, if any. Instead you force anybody
still interested to wade through reams of x86 code, which is woefully
incomplete.

Me, I'm not really interested. I've verified a proof of the HP theorem
and that's that. But I'd really like to see some honesty from your side.
If you were to produce the source code of H, I might even look at it.
Maybe.

I'm not actually that convinced you've even got source code for H. It
might well just be a fantasy. It still doesn't matter much. The theorem
is proved, so it would just be a matter of exposing your mistakes.

[ .... ]

> --
> Copyright 2021 Pete Olcott

> "Great spirits have always encountered violent opposition from mediocre
> minds." Einstein

--
Alan Mackenzie (Nuremberg, Germany).

Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]

<Kqudna8HOpsQJZP8nZ2dnUU78fednZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19589&group=comp.theory#19589

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!border2.nntp.ams1.giganews.com!nntp.giganews.com!buffer2.nntp.ams1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 07 Aug 2021 11:45:01 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as
1,2,3 ]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<seltf3$2g9r$1@news.muc.de> <JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com>
<sem7cg$puv$1@news.muc.de> <q7ydnRnqSvJBO5P8nZ2dnUU7-avNnZ2d@giganews.com>
<semc4h$27g8$1@news.muc.de>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 7 Aug 2021 11:45:01 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <semc4h$27g8$1@news.muc.de>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <Kqudna8HOpsQJZP8nZ2dnUU78fednZ2d@giganews.com>
Lines: 107
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-0eow4g6qTdheMPq92B1Aujd6Z+KopQe9ClKNnZEzG9gO141dZplsTGLb2WL6XwVjJgtqXCrXxrO8Lhq!U/sIl1PsYoCwwQS3r7Qbi9N+1Oz6vFZGEot3B27r9TvyHc6f3YmGx9j2I+1C43aKTCLT8hAjIw==
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: 5707
 by: olcott - Sat, 7 Aug 2021 16:45 UTC

On 8/7/2021 11:24 AM, Alan Mackenzie wrote:
> [ Further malicious cross posting removed. ]
>
> In comp.theory olcott <NoOne@nowhere.com> wrote:
>> On 8/7/2021 10:03 AM, Alan Mackenzie wrote:
>>> [ Malicious cross posting removed. ]
>
>>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>>>> On 8/7/2021 7:14 AM, Alan Mackenzie wrote:
>
>>> [ .... ]
>
>>>>> If you wanted a truly honest debate about your "proof", you would make
>>>>> the source code for H available, assuming it actually exists.
>
>>>> What the source-code does and how it does it can be fully proven
>>>> entirely on the basis of what has been provided.
>
>>>> That people insist on seeing the source-code only proves that they are
>>>> not paying enough attention.
>
>>> No. Maybe these people want to verify the whole truth, not just the bit
>>> you would like them to see.
>
>>>> The nested simulated calls never return whether or not they are aborted.
>>>> The infinitely nested simulations never stop unless they are aborted.
>
>>> You're clearly not interested in an honest dialogue. You want the
>>> honesty to be on one side only, and it's not your side.
>
>
>> (1) In other words you don't know the x86 language well enough to see
>> that the call to H at machine address [00000d0d] with (P,P) parameters
>> cannot possibly stop running unless H aborts its simulation of P?
>
>> (2) Furthermore you don't know the x86 language well enough to see that
>> even if this simulation is aborted that the P of this aborted simulation
>> cannot possibly proceed to the final state of [00000d1c] after it has
>> been aborted?
>
>> (3) One more thing that you apparently cannot see is that whether or not
>> the simulation of P is aborted the simulated P cannot possibly proceed
>> to the final state of [00000d1c] thus the determination that the input
>> to H(P,P) never halts is correct?
>

_P()
[00000d02](01) 55 push ebp
[00000d03](02) 8bec mov ebp,esp
[00000d05](03) 8b4508 mov eax,[ebp+08]
[00000d08](01) 50 push eax // push P
[00000d09](03) 8b4d08 mov ecx,[ebp+08]
[00000d0c](01) 51 push ecx // push P
[00000d0d](05) e870feffff call 00000b82 // call H that emulates P
[00000d12](03) 83c408 add esp,+08
[00000d15](02) 85c0 test eax,eax
[00000d17](02) 7402 jz 00000d1b
[00000d19](02) ebfe jmp 00000d19
[00000d1b](01) 5d pop ebp
[00000d1c](01) c3 ret
Size in bytes:(0027) [00000d1c]

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

> It's nothing to do with my competence with x86. It's to do with your
> smoke and mirrors.
>
> You're hiding what, if anything, you have, thus preventing an honest
> dialogue. If you were interested in honesty, you would make it as easy
> as possible to discuss your results, if any. Instead you force anybody
> still interested to wade through reams of x86 code, which is woefully
> incomplete.
>
> Me, I'm not really interested. I've verified a proof of the HP theorem
> and that's that. But I'd really like to see some honesty from your side.
> If you were to produce the source code of H, I might even look at it.
> Maybe.
>
> I'm not actually that convinced you've even got source code for H. It
> might well just be a fantasy. It still doesn't matter much. The theorem
> is proved, so it would just be a matter of exposing your mistakes.
>

If you have no correct rebuttal for (1)(2)(3) then they stand without
rebuttal. You are merely one of many that dismisses my proof out-of-hand
without sufficient review simply because you really really believe that
I must be incorrect.

If no correct rebuttal for (1)(2)(3) exists this proves that (1)(2)(3)
are correct which entails that H(P,P)==0 is the correct halt status for
the input to H.

> [ .... ]
>
>> --
>> Copyright 2021 Pete Olcott
>
>> "Great spirits have always encountered violent opposition from mediocre
>> minds." Einstein
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]

<semgka$27g8$2@news.muc.de>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19590&group=comp.theory#19590

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news-peer.in.tum.de!news.muc.de!.POSTED.news.muc.de!not-for-mail
From: acm...@muc.de (Alan Mackenzie)
Newsgroups: comp.theory
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]
Date: Sat, 7 Aug 2021 17:41:30 -0000 (UTC)
Organization: muc.de e.V.
Message-ID: <semgka$27g8$2@news.muc.de>
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <seltf3$2g9r$1@news.muc.de> <JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com> <sem7cg$puv$1@news.muc.de> <q7ydnRnqSvJBO5P8nZ2dnUU7-avNnZ2d@giganews.com> <semc4h$27g8$1@news.muc.de> <Kqudna8HOpsQJZP8nZ2dnUU78fednZ2d@giganews.com>
Injection-Date: Sat, 7 Aug 2021 17:41:30 -0000 (UTC)
Injection-Info: news.muc.de; posting-host="news.muc.de:2001:608:1000::2";
logging-data="73224"; mail-complaints-to="news-admin@muc.de"
User-Agent: tin/2.4.5-20201224 ("Glen Albyn") (FreeBSD/12.2-RELEASE-p7 (amd64))
 by: Alan Mackenzie - Sat, 7 Aug 2021 17:41 UTC

[ Yet more malicious cross posting removed. ]

In comp.theory olcott <NoOne@nowhere.com> wrote:
> On 8/7/2021 11:24 AM, Alan Mackenzie wrote:
>> [ Further malicious cross posting removed. ]

[ .... ]

>> It's nothing to do with my competence with x86. It's to do with your
>> smoke and mirrors.

>> You're hiding what, if anything, you have, thus preventing an honest
>> dialogue. If you were interested in honesty, you would make it as
>> easy as possible to discuss your results, if any. Instead you force
>> anybody still interested to wade through reams of x86 code, which is
>> woefully incomplete.

>> Me, I'm not really interested. I've verified a proof of the HP
>> theorem and that's that. But I'd really like to see some honesty from
>> your side. If you were to produce the source code of H, I might even
>> look at it. Maybe.

>> I'm not actually that convinced you've even got source code for H. It
>> might well just be a fantasy. It still doesn't matter much. The
>> theorem is proved, so it would just be a matter of exposing your
>> mistakes.

> If you have no correct rebuttal for (1)(2)(3) then they stand without
> rebuttal.

Garbage. They do not stand until they are proved, something beyond your
understanding and capability.

> You are merely one of many that dismisses my proof out-of-hand without
> sufficient review simply because you really really believe that I must
> be incorrect.

There's no "belief" about it. It's established mathematical proof,
something you fail to understand. You're asserting that 2 + 2 = 5. Why
should I waste time on that?

If you truly, honestly wanted review, you would post your source code.

> If no correct rebuttal for (1)(2)(3) exists this proves that (1)(2)(3)
> are correct which entails that H(P,P)==0 is the correct halt status for
> the input to H.

Garbage.

You have no interest in honest dialogue.

> --
> Copyright 2021 Pete Olcott

> "Great spirits have always encountered violent opposition from mediocre
> minds." Einstein

--
Alan Mackenzie (Nuremberg, Germany).

Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]

<8v6dnTrkQ_4qd5P8nZ2dnUU7-LfNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19592&group=comp.theory#19592

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 07 Aug 2021 15:19:03 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as
1,2,3 ]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<seltf3$2g9r$1@news.muc.de> <JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com>
<sem7cg$puv$1@news.muc.de> <q7ydnRnqSvJBO5P8nZ2dnUU7-avNnZ2d@giganews.com>
<semc4h$27g8$1@news.muc.de> <Kqudna8HOpsQJZP8nZ2dnUU78fednZ2d@giganews.com>
<semgka$27g8$2@news.muc.de>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 7 Aug 2021 15:19:03 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <semgka$27g8$2@news.muc.de>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <8v6dnTrkQ_4qd5P8nZ2dnUU7-LfNnZ2d@giganews.com>
Lines: 97
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Ler0elzDL87XoMicbx0A3ApQO8wL1xo/H49QPO1rhDvziea1Rr6aZL1JyKCzoeRSmjON0AiAV2mex2V!hV6IECzSDpy0IQRCOANwqXsp3FILouTKa2ddmrOiDItUxjOvYAjbUXKgCJj7le5Ex8QjP5wXdw==
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: 5078
 by: olcott - Sat, 7 Aug 2021 20:19 UTC

On 8/7/2021 12:41 PM, Alan Mackenzie wrote:
> [ Yet more malicious cross posting removed. ]
>
> In comp.theory olcott <NoOne@nowhere.com> wrote:
>> On 8/7/2021 11:24 AM, Alan Mackenzie wrote:
>>> [ Further malicious cross posting removed. ]
>
> [ .... ]
>
>>> It's nothing to do with my competence with x86. It's to do with your
>>> smoke and mirrors.
>
>>> You're hiding what, if anything, you have, thus preventing an honest
>>> dialogue. If you were interested in honesty, you would make it as
>>> easy as possible to discuss your results, if any. Instead you force
>>> anybody still interested to wade through reams of x86 code, which is
>>> woefully incomplete.
>
>>> Me, I'm not really interested. I've verified a proof of the HP
>>> theorem and that's that. But I'd really like to see some honesty from
>>> your side. If you were to produce the source code of H, I might even
>>> look at it. Maybe.
>
>>> I'm not actually that convinced you've even got source code for H. It
>>> might well just be a fantasy. It still doesn't matter much. The
>>> theorem is proved, so it would just be a matter of exposing your
>>> mistakes.
>
>
>> If you have no correct rebuttal for (1)(2)(3) then they stand without
>> rebuttal.
>
> Garbage. They do not stand until they are proved, something beyond your
> understanding and capability.
>

Irrefutable is another word for correct.

>> You are merely one of many that dismisses my proof out-of-hand without
>> sufficient review simply because you really really believe that I must
>> be incorrect.
>
> There's no "belief" about it. It's established mathematical proof,
> something you fail to understand. You're asserting that 2 + 2 = 5. Why
> should I waste time on that?
>
> If you truly, honestly wanted review, you would post your source code.

The following code proves beyond all possible doubt that the pure
simulation of P on its input P by H cannot possibly reach its final
state of [00000d1c] whether or not H aborts this simulation.
It seems that you are either in psychological denial or worse: (the
opposite of an honest dialogue).

_P()
[00000d02](01) 55 push ebp
[00000d03](02) 8bec mov ebp,esp
[00000d05](03) 8b4508 mov eax,[ebp+08]
[00000d08](01) 50 push eax // push P
[00000d09](03) 8b4d08 mov ecx,[ebp+08]
[00000d0c](01) 51 push ecx // push P
[00000d0d](05) e870feffff call 00000b82 // call H that emulates P
[00000d12](03) 83c408 add esp,+08
[00000d15](02) 85c0 test eax,eax
[00000d17](02) 7402 jz 00000d1b
[00000d19](02) ebfe jmp 00000d19
[00000d1b](01) 5d pop ebp
[00000d1c](01) c3 ret
Size in bytes:(0027) [00000d1c]

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

>> If no correct rebuttal for (1)(2)(3) exists this proves that (1)(2)(3)
>> are correct which entails that H(P,P)==0 is the correct halt status for
>> the input to H.
>
> Garbage.
>

Perhaps you never heard the term: "irrefutable" before?
It essentially means the same thing as "correct".

> You have no interest in honest dialogue.
>
>> --
>> Copyright 2021 Pete Olcott
>
>> "Great spirits have always encountered violent opposition from mediocre
>> minds." Einstein
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]

<sems1k$27g8$3@news.muc.de>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19593&group=comp.theory#19593

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news-peer.in.tum.de!news.muc.de!.POSTED.news.muc.de!not-for-mail
From: acm...@muc.de (Alan Mackenzie)
Newsgroups: comp.theory
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]
Date: Sat, 7 Aug 2021 20:56:20 -0000 (UTC)
Organization: muc.de e.V.
Message-ID: <sems1k$27g8$3@news.muc.de>
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com> <seltf3$2g9r$1@news.muc.de> <JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com> <sem7cg$puv$1@news.muc.de> <q7ydnRnqSvJBO5P8nZ2dnUU7-avNnZ2d@giganews.com> <semc4h$27g8$1@news.muc.de> <Kqudna8HOpsQJZP8nZ2dnUU78fednZ2d@giganews.com> <semgka$27g8$2@news.muc.de> <8v6dnTrkQ_4qd5P8nZ2dnUU7-LfNnZ2d@giganews.com>
Injection-Date: Sat, 7 Aug 2021 20:56:20 -0000 (UTC)
Injection-Info: news.muc.de; posting-host="news.muc.de:2001:608:1000::2";
logging-data="73224"; mail-complaints-to="news-admin@muc.de"
User-Agent: tin/2.4.5-20201224 ("Glen Albyn") (FreeBSD/12.2-RELEASE-p7 (amd64))
 by: Alan Mackenzie - Sat, 7 Aug 2021 20:56 UTC

[ Malicious cross posting removed. ]

In comp.theory olcott <NoOne@nowhere.com> wrote:
> On 8/7/2021 12:41 PM, Alan Mackenzie wrote:
>> [ Yet more malicious cross posting removed. ]

>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>>> On 8/7/2021 11:24 AM, Alan Mackenzie wrote:
>>>> [ Further malicious cross posting removed. ]

>> [ .... ]

>>>> It's nothing to do with my competence with x86. It's to do with your
>>>> smoke and mirrors.

>>>> You're hiding what, if anything, you have, thus preventing an honest
>>>> dialogue. If you were interested in honesty, you would make it as
>>>> easy as possible to discuss your results, if any. Instead you force
>>>> anybody still interested to wade through reams of x86 code, which is
>>>> woefully incomplete.

>>>> Me, I'm not really interested. I've verified a proof of the HP
>>>> theorem and that's that. But I'd really like to see some honesty from
>>>> your side. If you were to produce the source code of H, I might even
>>>> look at it. Maybe.

>>>> I'm not actually that convinced you've even got source code for H. It
>>>> might well just be a fantasy. It still doesn't matter much. The
>>>> theorem is proved, so it would just be a matter of exposing your
>>>> mistakes.

>>> If you have no correct rebuttal for (1)(2)(3) then they stand without
>>> rebuttal.

>> Garbage. They do not stand until they are proved, something beyond your
>> understanding and capability.

No response?

> Irrefutable is another word for correct.

It is not. They are different words with different meanings. Hint: in
English there are few pairs of words indeed with identical meanings.

>>> You are merely one of many that dismisses my proof out-of-hand without
>>> sufficient review simply because you really really believe that I must
>>> be incorrect.

>> There's no "belief" about it. It's established mathematical proof,
>> something you fail to understand. You're asserting that 2 + 2 = 5. Why
>> should I waste time on that?

>> If you truly, honestly wanted review, you would post your source code.

No answer? You don't actually have source code for an H, do you?

> The following code proves beyond all possible doubt ....

Now come nothing but lies from you. You don't honestly think that dumped
object code from ~4 lines of C source can prove _anything_ "beyond all
possible doubt", surely? You are just lying.

> .... that the pure simulation of P on its input P by H cannot possibly
> reach its final state of [00000d1c] whether or not H aborts this
> simulation. It seems that you are either in psychological denial or
> worse: (the opposite of an honest dialogue).

Until we know exactly what H does, and how, we can't have any honest
dialogue about it.

[ .... ]

> Perhaps you never heard the term: "irrefutable" before? It essentially
> means the same thing as "correct".

Wrong. It does not.

>> You have no interest in honest dialogue.

You don't. Have you actually written working source code for H?

> --
> Copyright 2021 Pete Olcott

> "Great spirits have always encountered violent opposition from mediocre
> minds." Einstein

--
Alan Mackenzie (Nuremberg, Germany).

Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as 1,2,3 ]

<8PmdnaQYrtbBapP8nZ2dnUU78IHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=19594&group=comp.theory#19594

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!2.eu.feeder.erje.net!feeder.erje.net!border1.nntp.ams1.giganews.com!nntp.giganews.com!buffer1.nntp.ams1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 07 Aug 2021 16:13:00 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy as
1,2,3 ]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <HNidndugKOWGvpH8nZ2dnUU7-fXNnZ2d@giganews.com>
<seltf3$2g9r$1@news.muc.de> <JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com>
<sem7cg$puv$1@news.muc.de> <q7ydnRnqSvJBO5P8nZ2dnUU7-avNnZ2d@giganews.com>
<semc4h$27g8$1@news.muc.de> <Kqudna8HOpsQJZP8nZ2dnUU78fednZ2d@giganews.com>
<semgka$27g8$2@news.muc.de> <8v6dnTrkQ_4qd5P8nZ2dnUU7-LfNnZ2d@giganews.com>
<sems1k$27g8$3@news.muc.de>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 7 Aug 2021 16:12:58 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.12.0
MIME-Version: 1.0
In-Reply-To: <sems1k$27g8$3@news.muc.de>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <8PmdnaQYrtbBapP8nZ2dnUU78IHNnZ2d@giganews.com>
Lines: 143
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ZKndnNflVeMp8DojMNsIOQBSVyTnDtcnW4YnuigWdRAxymtlWj8catu46EysEyMStOL0gW3pCPREKSs!zTRWpYLycZSEGomBchCxT1Nqwm1Zl3xTNVzR1hHELvaTqWINcUBQRIgeCHOpbvCxbuNTZ4qmwQ==
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: 7352
 by: olcott - Sat, 7 Aug 2021 21:12 UTC

On 8/7/2021 3:56 PM, Alan Mackenzie wrote:
> [ Malicious cross posting removed. ]
>
> In comp.theory olcott <NoOne@nowhere.com> wrote:
>> On 8/7/2021 12:41 PM, Alan Mackenzie wrote:
>>> [ Yet more malicious cross posting removed. ]
>
>>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>>>> On 8/7/2021 11:24 AM, Alan Mackenzie wrote:
>>>>> [ Further malicious cross posting removed. ]
>
>>> [ .... ]
>
>>>>> It's nothing to do with my competence with x86. It's to do with your
>>>>> smoke and mirrors.
>
>>>>> You're hiding what, if anything, you have, thus preventing an honest
>>>>> dialogue. If you were interested in honesty, you would make it as
>>>>> easy as possible to discuss your results, if any. Instead you force
>>>>> anybody still interested to wade through reams of x86 code, which is
>>>>> woefully incomplete.
>
>>>>> Me, I'm not really interested. I've verified a proof of the HP
>>>>> theorem and that's that. But I'd really like to see some honesty from
>>>>> your side. If you were to produce the source code of H, I might even
>>>>> look at it. Maybe.
>
>>>>> I'm not actually that convinced you've even got source code for H. It
>>>>> might well just be a fantasy. It still doesn't matter much. The
>>>>> theorem is proved, so it would just be a matter of exposing your
>>>>> mistakes.
>
>
>>>> If you have no correct rebuttal for (1)(2)(3) then they stand without
>>>> rebuttal.
>
>>> Garbage. They do not stand until they are proved, something beyond your
>>> understanding and capability.
>
> No response?
>
>> Irrefutable is another word for correct.
>
> It is not. They are different words with different meanings. Hint: in
> English there are few pairs of words indeed with identical meanings.
>
>>>> You are merely one of many that dismisses my proof out-of-hand without
>>>> sufficient review simply because you really really believe that I must
>>>> be incorrect.
>
>>> There's no "belief" about it. It's established mathematical proof,
>>> something you fail to understand. You're asserting that 2 + 2 = 5. Why
>>> should I waste time on that?
>
>>> If you truly, honestly wanted review, you would post your source code.
>
> No answer? You don't actually have source code for an H, do you?
>
>> The following code proves beyond all possible doubt ....
>

_P()
[00000d02](01) 55 push ebp
[00000d03](02) 8bec mov ebp,esp
[00000d05](03) 8b4508 mov eax,[ebp+08]
[00000d08](01) 50 push eax // push P
[00000d09](03) 8b4d08 mov ecx,[ebp+08]
[00000d0c](01) 51 push ecx // push P
[00000d0d](05) e870feffff call 00000b82 // call H that emulates P
[00000d12](03) 83c408 add esp,+08
[00000d15](02) 85c0 test eax,eax
[00000d17](02) 7402 jz 00000d1b
[00000d19](02) ebfe jmp 00000d19
[00000d1b](01) 5d pop ebp
[00000d1c](01) c3 ret
Size in bytes:(0027) [00000d1c]

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

> Now come nothing but lies from you. You don't honestly think that dumped
> object code from ~4 lines of C source can prove _anything_ "beyond all
> possible doubt", surely? You are just lying.
>

I am not the one that keeps deleting the code that proves that I am right.

If you think that I am wrong then show how a pure simulation of the
above code can possibly reach its final state of [00000d1c] when we know
that and can verify that H acts as a pure simulator of P(P).

>> .... that the pure simulation of P on its input P by H cannot possibly
>> reach its final state of [00000d1c] whether or not H aborts this
>> simulation. It seems that you are either in psychological denial or
>> worse: (the opposite of an honest dialogue).
>
> Until we know exactly what H does, and how, we can't have any honest
> dialogue about it.
>

We can see that H acts as a pure simulator of the above code from this
execution trace of the simulation of P by H:

Begin Local Halt Decider Simulation at Machine Address:d02
....[00000d02][002118f1][002118f5] 55 push ebp
....[00000d03][002118f1][002118f5] 8bec mov ebp,esp
....[00000d05][002118f1][002118f5] 8b4508 mov eax,[ebp+08]
....[00000d08][002118ed][00000d02] 50 push eax // push P
....[00000d09][002118ed][00000d02] 8b4d08 mov ecx,[ebp+08]
....[00000d0c][002118e9][00000d02] 51 push ecx // push P
....[00000d0d][002118e5][00000d12] e870feffff call 00000b82 // call H
....[00000d02][0025c319][0025c31d] 55 push ebp
....[00000d03][0025c319][0025c31d] 8bec mov ebp,esp
....[00000d05][0025c319][0025c31d] 8b4508 mov eax,[ebp+08]
....[00000d08][0025c315][00000d02] 50 push eax // push P
....[00000d09][0025c315][00000d02] 8b4d08 mov ecx,[ebp+08]
....[00000d0c][0025c311][00000d02] 51 push ecx // push P
....[00000d0d][0025c30d][00000d12] e870feffff call 00000b82 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

> [ .... ]
>
>> Perhaps you never heard the term: "irrefutable" before? It essentially
>> means the same thing as "correct".
>
> Wrong. It does not.
>
>>> You have no interest in honest dialogue.
>
> You don't. Have you actually written working source code for H?
>
>> --
>> Copyright 2021 Pete Olcott
>
>> "Great spirits have always encountered violent opposition from mediocre
>> minds." Einstein
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Pages:123
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor