On Tuesday, 10 May 2022 at 07:31:07 UTC+8, olcott wrote:
On 5/9/2022 6:23 PM, wij wrote:
On Tuesday, 10 May 2022 at 07:20:03 UTC+8, olcott wrote:There is no need to show the hundreds of pages of source code for H
On 5/9/2022 6:11 PM, wij wrote:
On Tuesday, 10 May 2022 at 07:03:08 UTC+8, olcott wrote:It does correctly decide the one "impossible" input basis of all of the >>>> proofs, thus refuting all of these proofs.
On 5/9/2022 5:53 PM, wij wrote:
On Tuesday, 10 May 2022 at 06:44:15 UTC+8, olcott wrote:We can verify that H(P,P) correctly emulates its input on the basis that >>>>>> the execution trace provided by H exactly matches the behavior specified >>>>>> by the x86 source-code of P.
On 5/9/2022 5:34 PM, wij wrote:
On Tuesday, 10 May 2022 at 06:18:31 UTC+8, olcott wrote:https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
On 5/9/2022 4:51 PM, wij wrote:Sorry, I don't think anyone had ever seen one.
On Tuesday, 10 May 2022 at 05:20:02 UTC+8, olcott wrote: >>>>>>>>>>>> On 5/9/2022 3:59 PM, Dennis Bush wrote:I provide all of the details proving that this H does exist. >>>>>>>>>
On Monday, May 9, 2022 at 4:51:57 PM UTC-4, olcott wrote: >>>>>>>>>>>>>> On 5/9/2022 3:27 PM, Dennis Bush wrote:Begin Local Halt Decider Simulation
On Monday, May 9, 2022 at 4:18:04 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>> On 5/9/2022 12:26 PM, Dennis Bush wrote:H and H1 are both literal byte strings that emulate their literal byte
And to complete the computation being evaluated, what is the *exact*, FIXED algorithm of H? If it is Ha, then Ha(Pa,Pa) == false is wrong as demonstrated by Hb(Pa,Pa) == true.On Monday, May 9, 2022 at 1:18:28 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>>>> On 5/9/2022 11:52 AM, Dennis Bush wrote:I am talking about the literal string of "H" being applied to this
So if H is the *specific* decider that can detect infinite simulation in Pn(Pn), then we'll refer to it as Ha to clarify that point, and we'll refer to the P that calls it as Pa to clarify.On Monday, May 9, 2022 at 12:39:59 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>>>>>> On 5/9/2022 11:30 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 12:06:01 PM UTC-4, olcott wrote:Within the context of my paper it is a complete computation for H(P,P).
Again, not a complete computation, so not enough information to decide on. You seem to think that all "P" constructs are the same no matter how different the H it is built on is.I am only talking about H(P,P) and H1(P,P) where P is this literalOn 5/9/2022 11:02 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 11:31:16 AM UTC-4, olcott wrote:So if that's enough information to decide on, then tell me if this halts:
Thee is no Pa, Pb, Pc, there is only this P: >>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3 >>>>>>>>>>>>>>>>>>>>>On 5/7/2022 9:36 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 10:20:27 PM UTC-4, olcott wrote:Not the whole system, just the computation to be decided on, and that computation includes the FIXED code of H that aborts its simulation, i.e. Ha.
I did not freaking say that this finite string specifies every freakingOn 5/7/2022 8:26 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 9:08:33 PM UTC-4, olcott wrote:
I am only referring to this literal string: >>>>>>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3On 5/7/2022 7:48 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 8:19:40 PM UTC-4, olcott wrote:
In this case it is the same as if {dogs} are defined to be {cats}.On 5/7/2022 6:35 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 7:14:57 PM UTC-4, olcott wrote:Which in the case of H(P,P) is *defined* to be P(P)
The definition of decider requires it to based its decision on whateverOn 5/7/2022 5:47 PM, Ben wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Then why do you insist that H(P,P) must return the value of H(Pn,Pn)?
return (N + M); >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }On 5/6/2022 8:07 PM, Ben wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Progress?
On 5/6/2022 7:11 PM, Ben wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The halting theorem follows, trivially, from lots of simpler theorems,
none of which have you bothered to read. In Linz, the theorem is
presented as a corollary of a simpler theorem in chapter 11.
11.3, 11.4, and 11.5. I will look at them. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Goodness! A good move. Why the change of heart?
There is enough progress now that I don't have to have an absolutely
single-minded focus. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
THIS IS AN EASILY VERIFIABLE FACT: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Both H() and H1() take the machine code of P as input parameters and
correctly compute the mapping from this input to an accept ore reject
state on the basis of the actual behavior that these inputs actually
specify.
But H does not decide the halting of P(P). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int sum(int N , int M) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
It is not supposed to in the same way that sum(3,4) is not supposed to
provide the sum of (5,7). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Why is this so difficult for you? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You know that if anyone insisted that sum(3,4) must return the value of
sum(5,7) that they are wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
its input specifies. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So no rebuttal, just a bad analogy. >>>>>>>>>>>>>>>>>>>>>>>>>>>
All that crazy bullshit about subscripted names of subscripts isWhat I was saying is that you think that H sees infinite simulation which only exists in Pn(Pn)
Both H(P,P) and H1(P,P) use this exact literal byte string as their
input therefore it seems enormously dishonest of you to refer to the
same literal string using different subscripts indicating a difference
of the same string with itself. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
extremely deceptive
No, just the opposite. It makes it clear *exactly* which computation we're talking about, so it prevents YOU from being deceptive.
I am ONLY referring to this literal string: >>>>>>>>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
as x86 machine code correctly simulated by H(P,P) and H1(P,P).
No you're not. You're also referring to the literal string which is the fixed code of H which aborts as that is part of the program P. So from here on, we'll refer to H as Ha and P as Pa to make that point clear.
as an input to H(P,P) and H1(P,P). It is 100% perfectly concrete
thus
utterly impervious to even extremely well-crafted attempts at deception
through the strawman error. Any attempt to get around this will be
construed as (and labeled) a bald-faced lie by a bald-faced liar.
That string is 100% NOT concrete because it doesn't specify the function that it is calling.
detail of the whole freaking system nitwit. This finite string as x86
code specifies every one of its own bytes. >>>>>>>>>>>>>>>>>>>>>>>
void F()
{
X()
}
string as x86 machine language:
558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3 >>>>>>>>>>>>>>>>>>>
I am updating the paper to include H1(P,P). >>>>>>>>>>>>>>>>>
literal string: 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
and
The literal string of "H1" being applied to this literal string:
558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3 >>>>>>>>>>>>>>>
If H is using some other algorithm, then specify the *exact* algorithm.
string input in pure x86 emulation mode until the behavior of this
emulated literal byte string input shows that it would never reach its
own final state (0xc3 ret instruction).
So in other words, the fixed algorithm of H looks for what it thinks is infinite simulation. So H is Ha, which means P is Pa.
Hb can then be constructed to simulate for k more steps than Ha and calculate Hb(Pa,Pa) == true, proving Ha(Pa,Pa) == false wrong.
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
...[000009d6][00211368][0021136c] 55 push ebp // enter P >>>>>>>>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08] >>>>>>>>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P >>>>>>>>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P >>>>>>>>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P >>>>>>>>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08] >>>>>>>>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P >>>>>>>>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P >>>>>>>>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped >>>>>>>>>>>>
The fact that P calls the same function from its same machine address
with identical input parameters conclusively proves that P is stuck in
infinite recursion.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
Your coding is invalid, because H is now shown to exist.
"H is here" does not mean "I provide all of the details proving that this H does exist."
Where is your H that can stand the HP test?
_P()
[00001352](01) 55 push ebp
[00001353](02) 8bec mov ebp,esp
[00001355](03) 8b4508 mov eax,[ebp+08]
[00001358](01) 50 push eax
[00001359](03) 8b4d08 mov ecx,[ebp+08]
[0000135c](01) 51 push ecx
[0000135d](05) e840feffff call 000011a2 // call H
[00001362](03) 83c408 add esp,+08
[00001365](02) 85c0 test eax,eax
[00001367](02) 7402 jz 0000136b
[00001369](02) ebfe jmp 00001369
[0000136b](01) 5d pop ebp
[0000136c](01) c3 ret
Size in bytes:(0027) [0000136c]
The execution trace that H(P,P) bases its halt status decision on
Begin Local Halt Decider Simulation Execution Trace Stored at:25cd7a >>>>>> ...[00001352][0025cd66][0025cd6a] 55 push ebp // enter P
...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
...[00001358][0025cd62][00001352] 50 push eax
...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][0025cd5e][00001352] 51 push ecx
...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H >>>>>> ...[00001352][002a778e][002a7792] 55 push ebp // enter P
...[00001353][002a778e][002a7792] 8bec mov ebp,esp
...[00001355][002a778e][002a7792] 8b4508 mov eax,[ebp+08]
...[00001358][002a778a][00001352] 50 push eax // push P
...[00001359][002a778a][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][002a7786][00001352] 51 push ecx // push P
...[0000135d][002a7782][00001362] e840feffff call 000011a2 // call H >>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped >>>>>> H sees that P is calling the same function from the same machine address >>>>>> with identical parameters, twice in sequence. This is the infinite >>>>>> recursion non-halting behavior pattern.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
This is not H (a halting decider).
"it" does not exist. Show your POOH.
To refute HP, a H has to exist to refute. If H does not exist, no real rebuttal exist.
(including the open source x86 emulator) or the hundreds of pages of
execution trace of H because it is easily verified that:
You choose to refute the conventional HP, and says that there is no need to show
the hundreds of pages of H...,etc. How do you expect the reviewer/the world to verify POOH (a claim?) by 'claim'?
H(P,P) correctly emulates its input on the basis that the execution
trace provided by H exactly matches the behavior specified by the x86
source-code of P.
It is also easy to verify that this trace specifies the infinite
behavior pattern of P:
H sees that P is calling the same function from the same machine address
with identical parameters, twice in sequence. This is the infinite
recursion non-halting behavior pattern.
Invalid claim. Because H is not shown to exist.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 297 |
Nodes: | 16 (2 / 14) |
Uptime: | 100:36:49 |
Calls: | 6,659 |
Calls today: | 1 |
Files: | 12,208 |
Messages: | 5,334,754 |