Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Dijkstra probably hates me. -- Linus Torvalds, in kernel/sched.c


computers / comp.ai.philosophy / Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]

SubjectAuthor
* Anyone wanting an actual honestly dialogue on the proof that H(P,P)==0 is correcolcott
+* Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
|`* Re: Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
| +* Re: Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
| |`- Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
| +* Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
| |`* Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
| | `* Re: Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
| |  `- Re: Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
| +- Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]olcott
| `- Re: Honest dialogue on the proof that H(P,P)==0 is correct [proofolcott
`* Re: Honest dialogue on the proof that H(P,P)==0 is correctolcott
 `* Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
  `* Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
   `* Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott
    `- Re: Honest dialogue on the proof that H(P,P)==0 is correct [ easy asolcott

1
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/computers/article-flat.php?id=7216&group=comp.ai.philosophy#7216

 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

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/computers/article-flat.php?id=7218&group=comp.ai.philosophy#7218

 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

<JOCdnfw1VaEaDZP8nZ2dnUU7-YPNnZ2d@giganews.com>

 copy mid

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

 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 [ easy as 1,2,3 ]

<q7ydnRnqSvJBO5P8nZ2dnUU7-avNnZ2d@giganews.com>

 copy mid

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

 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 ]

<Kqudna8HOpsQJZP8nZ2dnUU78fednZ2d@giganews.com>

 copy mid

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

 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 ]

<8v6dnTrkQ_4qd5P8nZ2dnUU7-LfNnZ2d@giganews.com>

 copy mid

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

 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 ]

<8PmdnaQYrtbBapP8nZ2dnUU78IHNnZ2d@giganews.com>

 copy mid

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

 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

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

<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>

 copy mid

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

 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: Mon, 09 Aug 2021 11:57:11 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
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>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 11:57:10 -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: <sep914$6pc$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>
Lines: 220
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Gt4MQfEDhezofSWn2YNJLGeEsUFjK6Q3I32uNwyAakogChEU+x/KNs9B+eqNloNEoCAUwnMq5mGu4h4!AGLclol1jvlGHwNc+L040aGPcLcpIfIEYo7BlsmWQfV+jOedYRSL093i/hyrFTOf82oDduDrMQ==
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: 10819
 by: olcott - Mon, 9 Aug 2021 16:57 UTC

On 8/8/2021 1:50 PM, André G. Isaak wrote:
> On 2021-08-06 22:23, olcott wrote:
>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>> On 2021-08-06 09:59, olcott wrote:
>
>>> 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 ?
>
> Your H is not a pure simulator
>

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

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

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
....[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

The fact that the execution trace of the simulation of P(P) on page 6
perfectly matches its source-code on page 5 conclusively proves that
this execution trace performed by H is a pure simulation of P(P). There
is no correct basis for disagreement, therefore anyone disagreeing
either does not know the x86 language or they are simply lying.

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

>>>> (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.
>
> Nothing you write above has anything to do with validity or sound
> deductive inference.
>
> The truth table you give above is for AND. Olympia is the capital of
> Washington. Salem is the capital of Oregon. It is certainly *not* the
> case the either of these statements can 'prove' the other, but according
> to your table.
>
> Salem is the capital of Oregon PROVES Olympia is the capital of Washington.
>
>>>> 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)
>
> So [PROVES] is your synomym for and and is now also equivalent to 'if
> and only if'? You need to go back to logic 101.
>
> And since P ⊢ C means something entirely different from P ⊢□C, you need
> to justify how that '□' magically appears. But since you don't know what
> it means that's going to be difficult for you.
>
>>> 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"
>
> Gee thanks. I already new that. And once again that conveys absolutely
> no information unless you explain what you mean by 'necessarily'. The
> fact that you don't understand what is being asked here just confirms my
> point that you have no idea what □ means and therefore shouldn't be
> using it.
>
> There are *many* different modal logics. In all of them □ is referred to
> as a necessity operator, but it *means* entirely different things. You
> can't just start throwing modal operators around unless you specify
> *which* type of modal logic you are using.
>>>
>>> *All* of the errors which have been pointed out to you have been
>>> errors in the actual argument.
>>
>> No you always make sure to avoid that part.
>>
>> This code proves that P has no escape from infinitely nested simulation.
>> The escape that exists is not in P. In both cases escape/no escape P
>> never reaches its final state of 0xc3f, therefore P never halts.
>
> No, it does not. In P(P) P creates a simulation of P. That simulation is
> eventually aborted and control returns to the outermost P which then halts.
>
> Since your trace completely skips over the call to 955 that abort code
> is not seen which means the the return of control to the outermost P is
> also not seen.
>
> There is *no* justification for not including the code of H in this trace.
>
>> _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 to simulate 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]
>
>
> André
>
>


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

<yIOdnSFYVobgGoz8nZ2dnUU7-SnNnZ2d@giganews.com>

 copy mid

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

 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: Mon, 09 Aug 2021 14:52:29 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
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>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me>
<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>
<2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 14:52:28 -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: <2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <yIOdnSFYVobgGoz8nZ2dnUU7-SnNnZ2d@giganews.com>
Lines: 99
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-K7oBmf+jiX0rYPQ44UdbSoxzedqc/IYuiu0tAHGHntsXcRzM6wHE8oSzOTJziblhu3jC82ncJWMUWIn!z4q13saofv+pjQGG4XKlm+zVrGJ4cdg4zHyI9kMFtlxRMdqHdQch61crL2bphUlKm6GyOZlKSw==
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: 6187
 by: olcott - Mon, 9 Aug 2021 19:52 UTC

On 8/9/2021 12:30 PM, Malcolm McLean wrote:
> On Monday, 9 August 2021 at 17:57:18 UTC+1, olcott wrote:
>> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>>> On 2021-08-06 22:23, olcott wrote:
>>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>>> On 2021-08-06 09:59, olcott wrote:
>>>
>>>>> 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 ?
>>>
>>> Your H is not a pure simulator
>>>
>> // Simplified Linz Ĥ (Linz:1990:319)
>> // Strachey(1965) CPL translated to C
>> void P(u32 x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> }
>> _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]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> ...[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
>> The fact that the execution trace of the simulation of P(P) on page 6
>> perfectly matches its source-code on page 5 conclusively proves that
>> this execution trace performed by H is a pure simulation of P(P). There
>> is no correct basis for disagreement, therefore anyone disagreeing
>> either does not know the x86 language or they are simply lying.
>>
> It's unclear to me exactly how H is a "simulator", given this execution trace.

I don't see what could possibly be unclear about it to anyone knowing
the x86 language well enough. The trace shows exactly what P would do if
it was simulated by a pure simulator with itself as input.

> Normally a simulator creates a virtual machine with a virtual address space
> and virtual instructions. The execution trace of the simulator looks nothing
> like the execution trace of the simulated code - basically the simulator does
> a big switch on the op code of the virtual machine's instruction, then updates
> memory and registers, with special rules for IO.
>

Those details only serve to get people confused. The fact that the x86
code of P acts exactly as if it was simulated by a pure simulator proves
beyond all possible doubt that H does simulate P on input P as a pure
simulator.

> You don't seem to be using this model for H.
>
> However iif P(P) halts, then any execution trace which shows it P(P) as non-halting
> must have a mistake in it somewhere, either in the simulator or in the interpretation
> of the trace.
>

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

<-4idnXdW5JWtB4z8nZ2dnUU7-W_NnZ2d@giganews.com>

 copy mid

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

 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!feeder1.feed.usenet.farm!feed.usenet.farm!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.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: Mon, 09 Aug 2021 16:12:16 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
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> <DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me> <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <ses089$7io$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 16:12:15 -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: <ses089$7io$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <-4idnXdW5JWtB4z8nZ2dnUU7-W_NnZ2d@giganews.com>
Lines: 107
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-nHjzLM/BmaFNBsqiwQGLCoaBsfC6s6roWEHhJAWy6aqKUohWZht0ZFOyNyfAUonlcXaORKYRezXCWPl!4pX8H7w/PjFAQOmchXsb4VsjscIcBBbklAMrW6IxPbU48MNpEaQ+VDpQZDZe62BulllV2ypnJw==
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: 6675
 by: olcott - Mon, 9 Aug 2021 21:12 UTC

On 8/9/2021 2:38 PM, André G. Isaak wrote:
> On 2021-08-09 10:57, olcott wrote:
>> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>>> On 2021-08-06 22:23, olcott wrote:
>>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>>> On 2021-08-06 09:59, olcott wrote:
>>>
>>>>> 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 ?
>>>
>>> Your H is not a pure simulator
>>>
>>
>> // Simplified Linz Ĥ (Linz:1990:319)
>> // Strachey(1965) CPL translated to C
>> void P(u32 x)
>> {
>>    if (H(x, x))
>>      HERE: goto HERE;
>> }
>>
>> _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]
>>
>>      machine   stack     stack     machine     assembly
>>      address   address   data      code        language
>>      ========  ========  ========  =========   =============
>> ...[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
>>
>> The fact that the execution trace of the simulation of P(P) on page 6
>> perfectly matches its source-code on page 5 conclusively proves that
>> this execution trace performed by H is a pure simulation of P(P).
>> There is no correct basis for disagreement, therefore anyone
>> disagreeing either does not know the x86 language or they are simply
>> lying.
>
> You have a *partial trace* and *partial source code*. Neither shows what
> happens at B82.
>

if int add(int x, int y) returns 5 on add(2,3) we know for sure that add
was correct on that input.

If every line of the execution trace of the simulation of P on input P
behaves exactly as its x86 source-code specifies that it must behave
then we know with 100% perfectly justified logical certainty that H did
perform a pure simulation of P on input P.

Do you care about the truth or will you continue to argue when you know
that you are wrong?

> Your trace ends with the cryptic message "Local Halt Decider: Infinite
> Recursion Detected Simulation Stopped" which doesn't indicate *which*
> invocation of H aborted *which* simulation and to where control was
> transferred once that simulation was aborted.
>
> Amdré
>

All that matters it that it is perfectly obvious to anyone knowing the
x86 language well enough that the input to H does specifies infinitely
nested simulation. This proves that whatever H aborted whichever P was
correct in its never halting decision.

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

<q6mdnffhc4WHPYz8nZ2dnUU7-InNnZ2d@giganews.com>

 copy mid

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

 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!feeder1.feed.usenet.farm!feed.usenet.farm!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: Mon, 09 Aug 2021 16:37:30 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
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> <DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me> <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com> <yIOdnSFYVobgGoz8nZ2dnUU7-SnNnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 16:37:29 -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: <yIOdnSFYVobgGoz8nZ2dnUU7-SnNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <q6mdnffhc4WHPYz8nZ2dnUU7-InNnZ2d@giganews.com>
Lines: 130
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-plqN2GfYe4NcgebR2aiAdAxL1K5bxT8JRY//rQiiMehbF8ngXSq3ALthodiTbFcVdsFo2voJ9L3qZ7f!DmV6oEe9f7Z2QcVENoxgS8XYyG4+LAMbPtPVIp9Q3THkURP0zOaOLufn7RLSlv21/6rgeHsugA==
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: 7440
 by: olcott - Mon, 9 Aug 2021 21:37 UTC

On 8/9/2021 2:52 PM, olcott wrote:
> On 8/9/2021 12:30 PM, Malcolm McLean wrote:
>> On Monday, 9 August 2021 at 17:57:18 UTC+1, olcott wrote:
>>> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>>>> On 2021-08-06 22:23, olcott wrote:
>>>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>>>> On 2021-08-06 09:59, olcott wrote:
>>>>
>>>>>> 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 ?
>>>>
>>>> Your H is not a pure simulator
>>>>
>>> // Simplified Linz Ĥ (Linz:1990:319)
>>> // Strachey(1965) CPL translated to C
>>> void P(u32 x)
>>> {
>>> if (H(x, x))
>>> HERE: goto HERE;
>>> }
>>> _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]
>>>
>>> machine stack stack machine assembly
>>> address address data code language
>>> ======== ======== ======== ========= =============
>>> ...[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
>>> The fact that the execution trace of the simulation of P(P) on page 6
>>> perfectly matches its source-code on page 5 conclusively proves that
>>> this execution trace performed by H is a pure simulation of P(P). There
>>> is no correct basis for disagreement, therefore anyone disagreeing
>>> either does not know the x86 language or they are simply lying.
>>>
>> It's unclear to me exactly how H is a "simulator", given this
>> execution trace.
>
> I don't see what could possibly be unclear about it to anyone knowing
> the x86 language well enough. The trace shows exactly what P would do if
> it was simulated by a pure simulator with itself as input.
>

Since everyone is finding it next to impossible to understand what the
behavior of seven lines of code would be while H acts as a pure
simulator of its input adding thousands of more lines of code cannot
possibly help their understanding:

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
....[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

>> Normally a simulator creates a virtual machine with a virtual address
>> space
>> and virtual instructions. The execution trace of the simulator looks
>> nothing
>> like the execution trace of the simulated code - basically the
>> simulator does
>> a big switch on the op code of the virtual machine's instruction, then
>> updates
>> memory and registers, with special rules for IO.
>>
>
> Those details only serve to get people confused. The fact that the x86
> code of P acts exactly as if it was simulated by a pure simulator proves
> beyond all possible doubt that H does simulate P on input P as a pure
> simulator.
>
>> You don't seem to be using this model for H.
>>
>> However iif P(P) halts, then any execution trace which shows it P(P)
>> as non-halting
>> must have a mistake in it somewhere, either in the simulator or in the
>> interpretation
>> of the trace.
>>
>
>

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

<bcWdne-_8KvrN4z8nZ2dnUU7-dnNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
Path: i2pn2.org!i2pn.org!paganini.bofh.team!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!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 09 Aug 2021 17:21:42 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
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> <DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me> <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <ses089$7io$1@dont-email.me> <-4idnXdW5JWtB4z8nZ2dnUU7-W_NnZ2d@giganews.com> <ses9ha$37f$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 17:21:41 -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: <ses9ha$37f$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <bcWdne-_8KvrN4z8nZ2dnUU7-dnNnZ2d@giganews.com>
Lines: 101
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-vqWEdeWK5G9MAwsc60bM4fdbCSN0mzPPmSUpHEYw/2KgsaNCugvA4LtSWaVWbGPxvcs6jRs8GZRYwoE!cVN3eSr5byu67HqIAHIgGXW6XdppAU/yGDvp3RGweY6itpHzvk2R1OC1N+FnaH5zjKKr6CKrvw==
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: 6648
 by: olcott - Mon, 9 Aug 2021 22:21 UTC

On 8/9/2021 5:17 PM, André G. Isaak wrote:
> On 2021-08-09 15:12, olcott wrote:
>> On 8/9/2021 2:38 PM, André G. Isaak wrote:
>>> On 2021-08-09 10:57, olcott wrote:
>>>> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>>>>> On 2021-08-06 22:23, olcott wrote:
>>>>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>>>>> On 2021-08-06 09:59, olcott wrote:
>>>>>
>>>>>>> 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 ?
>>>>>
>>>>> Your H is not a pure simulator
>>>>>
>>>>
>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>> // Strachey(1965) CPL translated to C
>>>> void P(u32 x)
>>>> {
>>>>    if (H(x, x))
>>>>      HERE: goto HERE;
>>>> }
>>>>
>>>> _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]
>>>>
>>>>      machine   stack     stack     machine     assembly
>>>>      address   address   data      code        language
>>>>      ========  ========  ========  =========   =============
>>>> ...[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
>>>>
>>>> The fact that the execution trace of the simulation of P(P) on page
>>>> 6 perfectly matches its source-code on page 5 conclusively proves
>>>> that this execution trace performed by H is a pure simulation of
>>>> P(P). There is no correct basis for disagreement, therefore anyone
>>>> disagreeing either does not know the x86 language or they are simply
>>>> lying.
>>>
>>> You have a *partial trace* and *partial source code*. Neither shows
>>> what happens at B82.
>>>
>>
>> if int add(int x, int y) returns 5 on add(2,3) we know for sure that
>> add was correct on that input.
>
> That is a poor analogy since 5 actually *is* the correct answer to 2+3.
>
> We know that P(P) *does* halt, which means that if H(P, P) returns false
> we know for sure that H was *incorrect* on that input.

P(P) only halts because H(P,P) correctly decides that its input never
halts and aborts this input on that basis.

Until you pay enough attention to see and acknowledge this I will simply
assume that you are dishonest.

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 [proof defined]

<55SdneGopb-TLYz8nZ2dnUU7-UHNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!tr3.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: Mon, 09 Aug 2021 17:45:34 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
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> <DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me> <mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com> <87h7fyjlwq.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 9 Aug 2021 17:45:33 -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: <87h7fyjlwq.fsf@bsb.me.uk>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <55SdneGopb-TLYz8nZ2dnUU7-UHNnZ2d@giganews.com>
Lines: 115
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-o9G8brj/FjNnrG/nq/nb4Fq58y6D9+eanskk0kRvzZstPYe4+81ML1cMNLcHgjA3osplHscmWlbf3fA!WPP13qATsCqG2ZsZ2JUqjxOqF4XqgeJSkMiNFZuiwaH3IhpXjS2i/zp5k9BPSbSBvEKBRCqP0Q==
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: 7580
 by: olcott - Mon, 9 Aug 2021 22:45 UTC

On 8/9/2021 5:25 PM, Ben Bacarisse wrote:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>
>> It's unclear to me exactly how H is a "simulator", given this
>> execution trace. Normally a simulator creates a virtual machine with
>> a virtual address space and virtual instructions. The execution trace
>> of the simulator looks nothing like the execution trace of the
>> simulated code - basically the simulator does a big switch on the op
>> code of the virtual machine's instruction, then updates memory and
>> registers, with special rules for IO.
>
> He makes the same mistake about TMs as well. Because the classic
> construction of H^ from H used in proofs like Linz's makes H^ duplicate
> the input string (into a pair, if the that needs to be specially
> encoded) and then "behave like H", he thinks that if H is a UTM the
> resulting endless looping causes the input to be endlessly duplicated.
> He's even started to give these copies names: <H^[1]> and <H^[2]> etc.
>
> But this is because he's never studied, much less written, a UTM. The
> UTM has to use the tape to encode the sate and the tape of the TM being
> simulated, and that means the neat fiction of endless copies of the
> encoding of UTM^ (i.e. <UTM^>) does not occur. The execution is
> endless, but the strings on the tape are way more complex than he
> thinks. He reads Linz's notation in a sort of metaphorical way, whereas
> it is intended to show exactly what's on the tape.
>
> I've glossed over this as best I can because he loves people getting
> bogged down in the details whereas he's been clear that his plan is
> wrong for the simplest, high-level reasons.
>
>> You don't seem to be using this model for H.
>
> Indeed. I've thought for some time that he has not been able invoke the
> x86 emulator he's found inline as a nested instance. My guess is that
> his H just calls its argument function and the "detection" of the
> recursion (which is now, of course, a reality) occurs outside. He
> probably just thinks that it /could/ be brought into H without making
> any difference. Part of the evidence for this comes from his briefly
> talking about the "OS as the halt decider".
>
> The game would be up if he ever published H, hence the need to keep it
> secret.
>
You cannot even possibly post any hypothetical scenario that could
possibly refute the analysis shown below.

It is just like I am saying that we know that int add(int y, int x) is
correct on input (2,3) because add(2,3) returns 5 and you say that we do
not know that add(2,3)==5 is correct.

*You have no place to hide from this correct reasoning*

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

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
....[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

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.

It is obvious that the execution trace of the simulation of P perfectly
acts as if H was its pure simulator thus proving that H does perform its
pure simulation of P on input P correctly.

The only possible "rebuttals" to this are double-talk and irrelevant
rhetoric. Anyone knowing the x86 language moderately well will confirm
that a pure simulation of P on input P is correctly performed by H
because the behavior of P on input P is exactly as its x86 source-code
specifies.

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 [proof defined]

<7K2dnTQBLqm-C4_8nZ2dnUU7-f3NnZ2d@giganews.com>

 copy mid

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

 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: Tue, 10 Aug 2021 10:07:15 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
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>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me>
<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <ses089$7io$1@dont-email.me>
<-4idnXdW5JWtB4z8nZ2dnUU7-W_NnZ2d@giganews.com> <ses9ha$37f$1@dont-email.me>
<bcWdne-_8KvrN4z8nZ2dnUU7-dnNnZ2d@giganews.com> <sesb21$h6$1@dont-email.me>
<55SdneCopb8ELYz8nZ2dnUU7-UGdnZ2d@giganews.com> <seslrh$abb$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Tue, 10 Aug 2021 10:07:13 -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: <seslrh$abb$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <7K2dnTQBLqm-C4_8nZ2dnUU7-f3NnZ2d@giganews.com>
Lines: 229
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-EJOnq8thBMvAEiQBrvGby7YjJnovHLYYSoqeiFYYTFKRBuq0s/L8uaZcq5gyFai5KdCVI7WsxM3qoC7!rAb4iUpBy/RwcRZz6kXbGcrAzxMYfsoJfUBarG/MMCpGvecljLswFC0wK/0+oAnEvKB27BPJ7g==
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: 12231
 by: olcott - Tue, 10 Aug 2021 15:07 UTC

On 8/9/2021 8:47 PM, André G. Isaak wrote:
> On 2021-08-09 16:47, olcott wrote:
>> On 8/9/2021 5:43 PM, André G. Isaak wrote:
>>> On 2021-08-09 16:21, olcott wrote:
>>>> On 8/9/2021 5:17 PM, André G. Isaak wrote:
>>>>> On 2021-08-09 15:12, olcott wrote:
>>>>>> On 8/9/2021 2:38 PM, André G. Isaak wrote:
>>>>>>> On 2021-08-09 10:57, olcott wrote:
>>>>>>>> On 8/8/2021 1:50 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-08-06 22:23, olcott wrote:
>>>>>>>>>> On 8/6/2021 10:55 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-08-06 09:59, olcott wrote:
>>>>>>>>>
>>>>>>>>>>> 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 ?
>>>>>>>>>
>>>>>>>>> Your H is not a pure simulator
>>>>>>>>>
>>>>>>>>
>>>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>>>>> // Strachey(1965) CPL translated to C
>>>>>>>> void P(u32 x)
>>>>>>>> {
>>>>>>>>    if (H(x, x))
>>>>>>>>      HERE: goto HERE;
>>>>>>>> }
>>>>>>>>
>>>>>>>> _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]
>>>>>>>>
>>>>>>>>      machine   stack     stack     machine     assembly
>>>>>>>>      address   address   data      code        language
>>>>>>>>      ========  ========  ========  =========   =============
>>>>>>>> ...[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
>>>>>>>>
>>>>>>>> The fact that the execution trace of the simulation of P(P) on
>>>>>>>> page 6 perfectly matches its source-code on page 5 conclusively
>>>>>>>> proves that this execution trace performed by H is a pure
>>>>>>>> simulation of P(P). There is no correct basis for disagreement,
>>>>>>>> therefore anyone disagreeing either does not know the x86
>>>>>>>> language or they are simply lying.
>>>>>>>
>>>>>>> You have a *partial trace* and *partial source code*. Neither
>>>>>>> shows what happens at B82.
>>>>>>>
>>>>>>
>>>>>> if int add(int x, int y) returns 5 on add(2,3) we know for sure
>>>>>> that add was correct on that input.
>>>>>
>>>>> That is a poor analogy since 5 actually *is* the correct answer to
>>>>> 2+3.
>>>>>
>>>>> We know that P(P) *does* halt, which means that if H(P, P) returns
>>>>> false we know for sure that H was *incorrect* on that input.
>>>>
>>>> P(P) only halts because H(P,P) correctly decides that its input
>>>> never halts and aborts this input on that basis.
>>>
>>> X only halts because Y IMPLIES that X halts. That's basic logic.
>>>
>>> The definition of halting does not refer at all to the *reason* why a
>>> particular computation halts.
>>>
>>
>> The P that halts seems to contradict that H(P,P)==0 is correct yet it
>> is verifiable that H(P,P)==0 is correct.
>
> P(P) is either in the set of halting computations or it is not. It can't
> be both.
>
> Since halting is a property defined *solely* in terms of the behaviour
> of the *actual* computation in question, we know that P(P) is in this
> set. Therefore H(P, P) == 0 *cannot* be verifiably correct.
>
>> That you keep ignoring this means that you are dishonest.
>
> I am not ignoring this. I am asserting that it is false.
>

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

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
....[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


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

<deWdncIXmMTtLY_8nZ2dnUU78YHNnZ2d@giganews.com>

 copy mid

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

 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: Tue, 10 Aug 2021 11:59:28 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
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>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me>
<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com> <ses089$7io$1@dont-email.me>
<-4idnXdW5JWtB4z8nZ2dnUU7-W_NnZ2d@giganews.com> <ses9ha$37f$1@dont-email.me>
<bcWdne-_8KvrN4z8nZ2dnUU7-dnNnZ2d@giganews.com> <sesb21$h6$1@dont-email.me>
<55SdneCopb8ELYz8nZ2dnUU7-UGdnZ2d@giganews.com> <seslrh$abb$1@dont-email.me>
<7K2dnTQBLqm-C4_8nZ2dnUU7-f3NnZ2d@giganews.com> <seu5uc$dgq$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Tue, 10 Aug 2021 11:59:26 -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: <seu5uc$dgq$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <deWdncIXmMTtLY_8nZ2dnUU78YHNnZ2d@giganews.com>
Lines: 125
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-92eJF2m19pcTntBpa60BS/n2HRRxvIXzFj63/n3gIlyLEomTGke/cQaDnXigaP5lLx/iuzhiSGF/iQw!0DOgwDjGjbw6p7mNDTZQTdlpT9ov4E//1shIgGUGvg2TFjNb3I4JrKPmh/L1AA9vvI3bdXlZ9A==
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: 7844
 by: olcott - Tue, 10 Aug 2021 16:59 UTC

On 8/10/2021 10:28 AM, André G. Isaak wrote:
> On 2021-08-10 09:07, olcott wrote:
>> On 8/9/2021 8:47 PM, André G. Isaak wrote:
>>> On 2021-08-09 16:47, olcott wrote:
>
>>>> The P that halts seems to contradict that H(P,P)==0 is correct yet
>>>> it is verifiable that H(P,P)==0 is correct.
>>>
>>> P(P) is either in the set of halting computations or it is not. It
>>> can't be both.
>>>
>>> Since halting is a property defined *solely* in terms of the
>>> behaviour of the *actual* computation in question, we know that P(P)
>>> is in this set. Therefore H(P, P) == 0 *cannot* be verifiably correct.
>>>
>>>> That you keep ignoring this means that you are dishonest.
>>>
>>> I am not ignoring this. I am asserting that it is false.
>>>
>>
>>
>>
>> _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]
>>
>>      machine   stack     stack     machine     assembly
>>      address   address   data      code        language
>>      ========  ========  ========  =========   =============
>> ...[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
>>
>> We can see that the above is a pure simulation of P on input P.
>
> It *isn't* a pure simulation since a pure simulation cannot abort its
> input.
>

Yet another dishonest dodge. The above is a pure simulation, Only
*AFTER* the above is there any aborting of the simulation.

>> We can see that the above cannot possibly stop running unless H aborts
>> its simulation of P on input P.
>
> Except you are aborting in the *wrong* place. That cannot be seen in the
> above trace since you don't actually *show* the code at B82, and your
> message that the simulation was stopped doesn't tell us *which*
> invocation of H aborted *which* simulation.
>

It does not matter which simulation was aborted and you know this. You
are nit picking at irrelevant details because you have no actual rebuttal.

> When P(P) is computed, it is the H contained in the outermost P which
> aborts the simulation, and control is then returned to that H and then
> to P which halts.
>

This also does not matter, thus yet another dishonest dodge. What
matters is that unless the input to H(P,P) is aborted it never stops
running thus conclusively proving that the decision of some H to abort
the simulation of some P was correct.

There is no correct rebuttal to this.

> When you run H(P, P) it is the *outermost* H which aborts the simulation
> of P *rather* than the H contained in the outermost P. This means your
> "simulation" is not an accurate one since it does something different
> from when the computation is performed independently.
>
> You keep stressing that a simulation is "equivalent" to the computation
> itself. That means your simulation must actually do *exactly* the same
> thing as the actual computation which yours does not, which means your
> "simulation" cannot be used to demonstrate anything about the actual
> computation under consideration.
>
>> We can see that even if H does aborts its simulation of P on input P
>> that P never reaches its final state, thus never halts even though its
>> stops running.
>>
>> Until you acknowledge these things or prove that the above P does
>> reach its final state you are simply a liar. Proving that a different
>> P reaches its final state is a dishonest dodge, thus also dishonest.
>
> What do you mean by "a different P"? There is only one Turing Machine P
> under consideration, and that Turing Machine clearly halts when given
> its own representation as an input.
>
> André
>

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

<xtOdnfvFV95aTo78nZ2dnUU7-efNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.lang.semantics comp.software-eng
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: Wed, 11 Aug 2021 08:42:31 -0500
Subject: Re: Honest dialogue on the proof that H(P,P)==0 is correct [proof
defined]
Newsgroups: comp.theory,comp.ai.philosophy,sci.lang.semantics,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>
<a82dnc_0ypriwZD8nZ2dnUU7-QHNnZ2d@giganews.com> <sel07d$pcf$1@dont-email.me>
<DdCdnaOAJLE3l5P8nZ2dnUU7-enNnZ2d@giganews.com> <sep914$6pc$1@dont-email.me>
<mdKdncO0j8L6w4z8nZ2dnUU7-S_NnZ2d@giganews.com>
<2cf7b09a-b3a2-4ede-b33f-c57a3736e9a7n@googlegroups.com>
<87h7fyjlwq.fsf@bsb.me.uk> <DMidnTrYO5dmm478nZ2dnUU7-cHNnZ2d@giganews.com>
<5c09c6ba-5094-4382-8a3f-195439311541n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
Date: Wed, 11 Aug 2021 08:42:30 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <5c09c6ba-5094-4382-8a3f-195439311541n@googlegroups.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <xtOdnfvFV95aTo78nZ2dnUU7-efNnZ2d@giganews.com>
Lines: 103
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-k38trpcVk1OPvxW22g9Kzp8Oh4FBOWzTfEoVg3aHMaTrV6KakUy5bJfSWLe62stLFhasu0cwjgqw2+l!eT4m0qAvLeGWZthaEYk3X2ceDdRYqbI/mMKXmk2X3Mt4ynbcakwtbkoM+JS+WNKKHAav95j0ww==
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: 7149
 by: olcott - Wed, 11 Aug 2021 13:42 UTC

On 8/11/2021 1:51 AM, Malcolm McLean wrote:
> On Wednesday, 11 August 2021 at 00:08:50 UTC+1, olcott wrote:
>> On 8/9/2021 5:25 PM, Ben Bacarisse wrote:
>>> Malcolm McLean <malcolm.ar...@gmail.com> writes:
>>>
>>>> It's unclear to me exactly how H is a "simulator", given this
>>>> execution trace. Normally a simulator creates a virtual machine with
>>>> a virtual address space and virtual instructions. The execution trace
>>>> of the simulator looks nothing like the execution trace of the
>>>> simulated code - basically the simulator does a big switch on the op
>>>> code of the virtual machine's instruction, then updates memory and
>>>> registers, with special rules for IO.
>>>
>>> He makes the same mistake about TMs as well. Because the classic
>>> construction of H^ from H used in proofs like Linz's makes H^ duplicate
>>> the input string (into a pair, if the that needs to be specially
>>> encoded) and then "behave like H", he thinks that if H is a UTM the
>>> resulting endless looping causes the input to be endlessly duplicated.
>>> He's even started to give these copies names: <H^[1]> and <H^[2]> etc.
>>>
>>> But this is because he's never studied, much less written, a UTM. The
>>> UTM has to use the tape to encode the sate and the tape of the TM being
>>> simulated, and that means the neat fiction of endless copies of the
>>> encoding of UTM^ (i.e. <UTM^>) does not occur. The execution is
>>> endless, but the strings on the tape are way more complex than he
>>> thinks. He reads Linz's notation in a sort of metaphorical way, whereas
>>> it is intended to show exactly what's on the tape.
>>>
>> It is the case that Ĥ on input ⟨Ĥ⟩ does specify infinite recursion to
>> every simulating halt decider embedded in Ĥ.
>>
>> That you talk all around this using all kinds of rhetoric yet never use
>> any actual reasoning as a rebuttal would seem to prove that you are
>> dishonest.
>>
> You need to be clear about what you mean by "infinite recursion". We
> all get the basic idea - H is a simulating halt decider, therefore H_Hat gets
> executed multiple times under various levels of H,.

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

The fact that while H acts as a pure simulator as shown below that P
would continue to call H with itself as input forever.

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

> But you are not working with Turing machines. Turing machines don't really
> have "recursion" because it is a structured programming concept, and Turing
> machines are too low-level for structured programming.

When the state transition sequence has an infinite cycle as shown in
figure 12.4 of page 17 we have infinitely nested simulation.

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

> In C, you can call subroutines recursively, but then how is H a "simulating halt
> decider"?. Or you can create a simulation context, and another simulation
> context within the simulation context, and so on, indefinitely. This is not
> what you appear to be doing.
>
I will not say one way or the other because it has already taken very
many months to get people to begin to understand the gist of 7 lines of
x86 code. Getting into the other details would be impossibly difficult
for people that can't seem to understand 7 lines of x86 code after many
months of discussion.

--
Copyright 2021 Pete Olcott

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

1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor