On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the behavior of
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt whenever >>>>>>>>>> it enters a final state. (Linz:1990:234)
A halt decider must compute the mapping from its inputs to an >>>>>>>>>> accept or reject state on the basis of the actual behavior of >>>>>>>>>> these actual inputs.
When a simulating halt decider rejects all inputs as
non-halting whenever it correctly detects [in a finite number >>>>>>>>>> of steps] that its correct and complete simulation of its
input would never reach [a] final state of this input then all >>>>>>>>>> [these] inputs (including pathological inputs) are decided >>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov eax,[ebp+08]
[00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08]
[00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>> [0000110a](03) 83c408 add esp,+08
[0000110d](02) 85c0 test eax,eax
[0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111
[00001113](01) 5d pop ebp
[00001114](01) c3 ret
Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2
...[000010da][00211ece][00211ed2] 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08] >>>>>>>> ...[000010e0][00211eca][000010da] 50 push eax //
push P ...[000010e1][00211eca][000010da] 8b4d08 mov
ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push >>>>>>>> ecx // push P ...[000010e5][00211ec2][000010ea] e820feffff >>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation Detected >>>>>>>> Simulation Stopped
*All technically competent software engineers* will see that
when H bases its halt status decision on whether or not its
complete and correct x86 emulation of its input would ever reach >>>>>>>> the "ret" instruction of this input that H is correct to reject >>>>>>>> this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>>> ...[000013fb][0010235b][00100000] 5d pop ebp >>>>> ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly. >>>>> QED.
/Flibble
Because it is an easily verified fact that the correct and complete
x86 emulation of the input to H(P,P) by H would never reach the "ret"
instruction of P and this is the criterion measure for H to reject
its input how do you figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we know that
X is a black cat then we know that X is a cat.
analysing what its input actually does and instead assuming that an
input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax >>> ...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct x86
emulation of its input would never reach the "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus fails to be a decider).
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the behavior of
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt whenever >>>>>>>>>>> it enters a final state. (Linz:1990:234)
A halt decider must compute the mapping from its inputs to an >>>>>>>>>>> accept or reject state on the basis of the actual behavior of >>>>>>>>>>> these actual inputs.
When a simulating halt decider rejects all inputs as
non-halting whenever it correctly detects [in a finite number >>>>>>>>>>> of steps] that its correct and complete simulation of its >>>>>>>>>>> input would never reach [a] final state of this input then all >>>>>>>>>>> [these] inputs (including pathological inputs) are decided >>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov eax,[ebp+08]
[00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08]
[00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>>> [0000110a](03) 83c408 add esp,+08
[0000110d](02) 85c0 test eax,eax
[0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111
[00001113](01) 5d pop ebp
[00001114](01) c3 ret
Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2
...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08] >>>>>>>>> ...[000010e0][00211eca][000010da] 50 push eax //
push P ...[000010e1][00211eca][000010da] 8b4d08 mov
ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push
ecx // push P ...[000010e5][00211ec2][000010ea] e820feffff >>>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation Detected >>>>>>>>> Simulation Stopped
*All technically competent software engineers* will see that >>>>>>>>> when H bases its halt status decision on whether or not its
complete and correct x86 emulation of its input would ever reach >>>>>>>>> the "ret" instruction of this input that H is correct to reject >>>>>>>>> this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>>>> ...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp >>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly. >>>>>> QED.
/Flibble
Because it is an easily verified fact that the correct and complete
x86 emulation of the input to H(P,P) by H would never reach the "ret" >>>>> instruction of P and this is the criterion measure for H to reject
its input how do you figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we know that >>>>> X is a black cat then we know that X is a cat.
analysing what its input actually does and instead assuming that an
input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>> ...[000013eb][00102353][00000000] 50 push eax >>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>> ...[000013fb][0010235b][00100000] 5d pop ebp >>>> ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct x86
emulation of its input would never reach the "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus fails to be
a decider).
Px matches this pattern that correct and complete x86 emulation of the
input to H(Px,Px) by H would never reach the "ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that H was called with.
(b) There are no instructions in Px that could possibly escape this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is invoked.
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the behavior of
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt whenever >>>>>>>>>>>> it enters a final state. (Linz:1990:234)
A halt decider must compute the mapping from its inputs to an >>>>>>>>>>>> accept or reject state on the basis of the actual behavior of >>>>>>>>>>>> these actual inputs.
When a simulating halt decider rejects all inputs as
non-halting whenever it correctly detects [in a finite number >>>>>>>>>>>> of steps] that its correct and complete simulation of its >>>>>>>>>>>> input would never reach [a] final state of this input then all >>>>>>>>>>>> [these] inputs (including pathological inputs) are decided >>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>>>> [0000110a](03) 83c408 add esp,+08
[0000110d](02) 85c0 test eax,eax
[0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111
[00001113](01) 5d pop ebp
[00001114](01) c3 ret
Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2
...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08] >>>>>>>>>> ...[000010e0][00211eca][000010da] 50 push eax //
push P ...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push
ecx // push P ...[000010e5][00211ec2][000010ea] e820feffff >>>>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation Detected >>>>>>>>>> Simulation Stopped
*All technically competent software engineers* will see that >>>>>>>>>> when H bases its halt status decision on whether or not its >>>>>>>>>> complete and correct x86 emulation of its input would ever reach >>>>>>>>>> the "ret" instruction of this input that H is correct to reject >>>>>>>>>> this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly. >>>>>>> QED.
/Flibble
Because it is an easily verified fact that the correct and complete >>>>>> x86 emulation of the input to H(P,P) by H would never reach the "ret" >>>>>> instruction of P and this is the criterion measure for H to reject >>>>>> its input how do you figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we know that >>>>>> X is a black cat then we know that X is a cat.
analysing what its input actually does and instead assuming that an
input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>>> ...[000013fb][0010235b][00100000] 5d pop ebp >>>>> ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly. >>>>> QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct x86
emulation of its input would never reach the "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus fails to be
a decider).
Px matches this pattern that correct and complete x86 emulation of the
input to H(Px,Px) by H would never reach the "ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that H
was called with.
(b) There are no instructions in Px that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is invoked.
Only if H never aborts. If H does abort, then Px(Px), whose behavior
exactly matches the CORRECT emulation of the input to H(Px,Px) BY
DEFINITION shows this.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
A halt decider must compute the mapping from its inputs >>>>>>>>>>>>>> to an accept or reject state on the basis of the actual >>>>>>>>>>>>>> behavior of these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite >>>>>>>>>>>>>> number of steps] that its correct and complete
simulation of its input would never reach [a] final >>>>>>>>>>>>>> state of this input then all [these] inputs (including >>>>>>>>>>>>>> pathological inputs) are decided correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427]
e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>> correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>>>>>> [0000110a](03) 83c408 add esp,+08
[0000110d](02) 85c0 test eax,eax >>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>> [00001113](01) 5d pop ebp
[00001114](01) c3 ret
Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2
...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov
eax,[ebp+08] ...[000010e0][00211eca][000010da] 50
push eax // push P ...[000010e1][00211eca][000010da] >>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx >>>>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] e820feffff >>>>>>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>> Detected Simulation Stopped
*All technically competent software engineers* will see >>>>>>>>>>>> that when H bases its halt status decision on whether or >>>>>>>>>>>> not its complete and correct x86 emulation of its input >>>>>>>>>>>> would ever reach the "ret" instruction of this input that >>>>>>>>>>>> H is correct to reject this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push
00000427 ---[000013f1][0010234f][00000427] e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
Because it is an easily verified fact that the correct and
complete x86 emulation of the input to H(P,P) by H would never >>>>>>>> reach the "ret" instruction of P and this is the criterion
measure for H to reject its input how do you figure that H
gets the wrong answer?
What I am saying is a logical tautology the same as when we
know that X is a black cat then we know that X is a cat.
analysing what its input actually does and instead assuming
that an input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct
x86 emulation of its input would never reach the "ret"
instruction of Px.
That is only true if H never returns ANY answer (and thus fails
to be a decider).
behavior of Px matches this pattern that correct and complete x86
emulation of the input to H(Px,Px) by H would never reach the
"ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that
H was called with.
(b) There are no instructions in Px that could possibly escape
this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is
invoked.
Only if H never aborts. If H does abort, then Px(Px), whose
behavior exactly matches the CORRECT emulation of the input to
H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct x86
emulation of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation of the
input to H(Px,Px) by H ever reach the "ret" instruction of Px.
The complete and correct x86 emulation of the input to H(Px, Px) should
be to allow Px to halt, which is what Px is defined to do:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the behavior of
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt whenever >>>>>>>>>>>> it enters a final state. (Linz:1990:234)
A halt decider must compute the mapping from its inputs to an >>>>>>>>>>>> accept or reject state on the basis of the actual behavior of >>>>>>>>>>>> these actual inputs.
When a simulating halt decider rejects all inputs as
non-halting whenever it correctly detects [in a finite number >>>>>>>>>>>> of steps] that its correct and complete simulation of its >>>>>>>>>>>> input would never reach [a] final state of this input then all >>>>>>>>>>>> [these] inputs (including pathological inputs) are decided >>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>>>> [0000110a](03) 83c408 add esp,+08
[0000110d](02) 85c0 test eax,eax
[0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111
[00001113](01) 5d pop ebp
[00001114](01) c3 ret
Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2
...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08] >>>>>>>>>> ...[000010e0][00211eca][000010da] 50 push eax //
push P ...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push
ecx // push P ...[000010e5][00211ec2][000010ea] e820feffff >>>>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation Detected >>>>>>>>>> Simulation Stopped
*All technically competent software engineers* will see that >>>>>>>>>> when H bases its halt status decision on whether or not its >>>>>>>>>> complete and correct x86 emulation of its input would ever reach >>>>>>>>>> the "ret" instruction of this input that H is correct to reject >>>>>>>>>> this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly. >>>>>>> QED.
/Flibble
Because it is an easily verified fact that the correct and complete >>>>>> x86 emulation of the input to H(P,P) by H would never reach the "ret" >>>>>> instruction of P and this is the criterion measure for H to reject >>>>>> its input how do you figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we know that >>>>>> X is a black cat then we know that X is a cat.
analysing what its input actually does and instead assuming that an
input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>>> ...[000013fb][0010235b][00100000] 5d pop ebp >>>>> ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly. >>>>> QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct x86
emulation of its input would never reach the "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus fails to be
a decider).
Px matches this pattern that correct and complete x86 emulation of the
input to H(Px,Px) by H would never reach the "ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that H
was called with.
(b) There are no instructions in Px that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is invoked.
Only if H never aborts. If H does abort, then Px(Px), whose behavior
exactly matches the CORRECT emulation of the input to H(Px,Px) BY
DEFINITION shows this.
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
A halt decider must compute the mapping from its inputs >>>>>>>>>>>> to an accept or reject state on the basis of the actual >>>>>>>>>>>> behavior of these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>> non-halting whenever it correctly detects [in a finite >>>>>>>>>>>> number of steps] that its correct and complete
simulation of its input would never reach [a] final
state of this input then all [these] inputs (including >>>>>>>>>>>> pathological inputs) are decided correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427]
e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>>>> [0000110a](03) 83c408 add esp,+08
[0000110d](02) 85c0 test eax,eax >>>>>>>>>> [0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111 >>>>>>>>>> [00001113](01) 5d pop ebp
[00001114](01) c3 ret
Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2
...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov
eax,[ebp+08] ...[000010e0][00211eca][000010da] 50
push eax // push P ...[000010e1][00211eca][000010da] >>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx >>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] e820feffff
call 00000f0a // call H Infinitely Recursive Simulation
Detected Simulation Stopped
*All technically competent software engineers* will see
that when H bases its halt status decision on whether or >>>>>>>>>> not its complete and correct x86 emulation of its input
would ever reach the "ret" instruction of this input that >>>>>>>>>> H is correct to reject this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push
00000427 ---[000013f1][0010234f][00000427] e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
Because it is an easily verified fact that the correct and
complete x86 emulation of the input to H(P,P) by H would never
reach the "ret" instruction of P and this is the criterion
measure for H to reject its input how do you figure that H
gets the wrong answer?
What I am saying is a logical tautology the same as when we
know that X is a black cat then we know that X is a cat.
analysing what its input actually does and instead assuming
that an input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct
x86 emulation of its input would never reach the "ret"
instruction of Px.
That is only true if H never returns ANY answer (and thus fails
to be a decider).
behavior of Px matches this pattern that correct and complete x86
emulation of the input to H(Px,Px) by H would never reach the
"ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that
H was called with.
(b) There are no instructions in Px that could possibly escape
this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is
invoked.
Only if H never aborts. If H does abort, then Px(Px), whose
behavior exactly matches the CORRECT emulation of the input to
H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct x86
emulation of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation of the
input to H(Px,Px) by H ever reach the "ret" instruction of Px.
On 6/19/2022 2:59 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234) >>>>>>>>>>>>>>
A halt decider must compute the mapping from its inputs >>>>>>>>>>>>>> to an accept or reject state on the basis of the actual >>>>>>>>>>>>>> behavior of these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite >>>>>>>>>>>>>> number of steps] that its correct and complete
simulation of its input would never reach [a] final >>>>>>>>>>>>>> state of this input then all [these] inputs (including >>>>>>>>>>>>>> pathological inputs) are decided correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427]
e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been
decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>>>>>> [0000110a](03) 83c408 add esp,+08 >>>>>>>>>>>> [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>> [00001114](01) c3 ret
Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov >>>>>>>>>>>> eax,[ebp+08] ...[000010e0][00211eca][000010da] 50
push eax // push P ...[000010e1][00211eca][000010da] >>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx >>>>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] e820feffff >>>>>>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>> Detected Simulation Stopped
*All technically competent software engineers* will see >>>>>>>>>>>> that when H bases its halt status decision on whether or >>>>>>>>>>>> not its complete and correct x86 emulation of its input >>>>>>>>>>>> would ever reach the "ret" instruction of this input that >>>>>>>>>>>> H is correct to reject this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
Because it is an easily verified fact that the correct and
complete x86 emulation of the input to H(P,P) by H would
never reach the "ret" instruction of P and this is the
criterion measure for H to reject its input how do you
figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we
know that X is a black cat then we know that X is a cat.
not analysing what its input actually does and instead
assuming that an input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push
00000427 ---[000013f1][0010234f][00000427] e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct
x86 emulation of its input would never reach the "ret"
instruction of Px.
That is only true if H never returns ANY answer (and thus fails
to be a decider).
behavior of Px matches this pattern that correct and complete x86
emulation of the input to H(Px,Px) by H would never reach the
"ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments
that H was called with.
(b) There are no instructions in Px that could possibly escape
this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is
invoked.
Only if H never aborts. If H does abort, then Px(Px), whose
behavior exactly matches the CORRECT emulation of the input to
H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct x86
emulation of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation of the
input to H(Px,Px) by H ever reach the "ret" instruction of Px.
The complete and correct x86 emulation of the input to H(Px, Px)
should be to allow Px to halt, which is what Px is defined to do:
You are doing the same thing Richard is doing, getting at least one
word of what I am saying incorrectly and then rebutting the incorrect paraphrase. This is the strawman error.
The complete and correct x86 emulation of the input to H(Px, Px)
BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px would
never reach its "ret" instruction. This seems to be beyond your
ordinary software engineering technical competence.
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the behavior
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt whenever >>>>>>>>>>>>> it enters a final state. (Linz:1990:234)
A halt decider must compute the mapping from its inputs to an >>>>>>>>>>>>> accept or reject state on the basis of the actual behavior of >>>>>>>>>>>>> these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite number >>>>>>>>>>>>> of steps] that its correct and complete simulation of its >>>>>>>>>>>>> input would never reach [a] final state of this input then all >>>>>>>>>>>>> [these] inputs (including pathological inputs) are decided >>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>> correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>>>>> [0000110a](03) 83c408 add esp,+08
[0000110d](02) 85c0 test eax,eax >>>>>>>>>>> [0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111 >>>>>>>>>>> [00001113](01) 5d pop ebp
[00001114](01) c3 ret
Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2
...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08] >>>>>>>>>>> ...[000010e0][00211eca][000010da] 50 push eax //
push P ...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push
ecx // push P ...[000010e5][00211ec2][000010ea] e820feffff
call 00000f0a // call H Infinitely Recursive Simulation Detected >>>>>>>>>>> Simulation Stopped
*All technically competent software engineers* will see that >>>>>>>>>>> when H bases its halt status decision on whether or not its >>>>>>>>>>> complete and correct x86 emulation of its input would ever reach >>>>>>>>>>> the "ret" instruction of this input that H is correct to reject >>>>>>>>>>> this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>>>> ...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly.
QED.
/Flibble
Because it is an easily verified fact that the correct and complete >>>>>>> x86 emulation of the input to H(P,P) by H would never reach the
"ret"
instruction of P and this is the criterion measure for H to reject >>>>>>> its input how do you figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we know >>>>>>> that
X is a black cat then we know that X is a cat.
analysing what its input actually does and instead assuming that an >>>>>> input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp >>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly. >>>>>> QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct x86
emulation of its input would never reach the "ret" instruction of Px. >>>>>
That is only true if H never returns ANY answer (and thus fails to
be a decider).
of Px matches this pattern that correct and complete x86 emulation of
the input to H(Px,Px) by H would never reach the "ret" instruction of
Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that H
was called with.
(b) There are no instructions in Px that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is invoked.
Only if H never aborts. If H does abort, then Px(Px), whose behavior
exactly matches the CORRECT emulation of the input to H(Px,Px) BY
DEFINITION shows this.
The question is: Would (future tense) the complete and correct x86
emulation of the input to H(Px,Px) by H ever reach the "ret" instruction
of Px.
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation of the input
to H(Px,Px) by H ever reach the "ret" instruction of Px.
A straw man (sometimes written as strawman) is a form of argument and an informal fallacy of having the impression of refuting an argument,
whereas the real subject of the argument was not addressed or refuted,
but instead replaced with a false one. https://en.wikipedia.org/wiki/Straw_man
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234) >>>>>>>>>>>>>>>>
A halt decider must compute the mapping from its inputs >>>>>>>>>>>>>>>> to an accept or reject state on the basis of the actual >>>>>>>>>>>>>>>> behavior of these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite >>>>>>>>>>>>>>>> number of steps] that its correct and complete >>>>>>>>>>>>>>>> simulation of its input would never reach [a] final >>>>>>>>>>>>>>>> state of this input then all [these] inputs (including >>>>>>>>>>>>>>>> pathological inputs) are decided correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>>>>>>>> [0000110a](03) 83c408 add esp,+08 >>>>>>>>>>>>>> [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>>> [00001114](01) c3 ret
Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov >>>>>>>>>>>>>> eax,[ebp+08] ...[000010e0][00211eca][000010da] 50
push eax // push P ...[000010e1][00211eca][000010da] >>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx >>>>>>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] e820feffff >>>>>>>>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>>>> Detected Simulation Stopped
*All technically competent software engineers* will see >>>>>>>>>>>>>> that when H bases its halt status decision on whether or >>>>>>>>>>>>>> not its complete and correct x86 emulation of its input >>>>>>>>>>>>>> would ever reach the "ret" instruction of this input that >>>>>>>>>>>>>> H is correct to reject this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>> correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly. QED.
/Flibble
Because it is an easily verified fact that the correct and >>>>>>>>>> complete x86 emulation of the input to H(P,P) by H would
never reach the "ret" instruction of P and this is the
criterion measure for H to reject its input how do you
figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we >>>>>>>>>> know that X is a black cat then we know that X is a cat.
not analysing what its input actually does and instead
assuming that an input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push
00000427 ---[000013f1][0010234f][00000427] e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct >>>>>>>> x86 emulation of its input would never reach the "ret"
instruction of Px.
That is only true if H never returns ANY answer (and thus fails
to be a decider).
behavior of Px matches this pattern that correct and complete x86
emulation of the input to H(Px,Px) by H would never reach the
"ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments
that H was called with.
(b) There are no instructions in Px that could possibly escape
this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is
invoked.
Only if H never aborts. If H does abort, then Px(Px), whose
behavior exactly matches the CORRECT emulation of the input to
H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct x86
emulation of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation of the
input to H(Px,Px) by H ever reach the "ret" instruction of Px.
The complete and correct x86 emulation of the input to H(Px, Px)
should be to allow Px to halt, which is what Px is defined to do:
You are doing the same thing Richard is doing, getting at least one
word of what I am saying incorrectly and then rebutting the incorrect
paraphrase. This is the strawman error.
The complete and correct x86 emulation of the input to H(Px, Px)
BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px would
never reach its "ret" instruction. This seems to be beyond your
ordinary software engineering technical competence.
Px is defined to always halt; your H gets the answer wrong saying Px
doesn't halt. QED.
/Flibble
On 6/19/2022 2:59 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not >>>>>>>> analysing what its input actually does and instead assuming
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234) >>>>>>>>>>>>>>>
A halt decider must compute the mapping from its inputs >>>>>>>>>>>>>>> to an accept or reject state on the basis of the actual >>>>>>>>>>>>>>> behavior of these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite >>>>>>>>>>>>>>> number of steps] that its correct and complete
simulation of its input would never reach [a] final >>>>>>>>>>>>>>> state of this input then all [these] inputs (including >>>>>>>>>>>>>>> pathological inputs) are decided correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>> correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>>>>>>> [0000110a](03) 83c408 add esp,+08 >>>>>>>>>>>>> [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>> [00001114](01) c3 ret
Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov >>>>>>>>>>>>> eax,[ebp+08] ...[000010e0][00211eca][000010da] 50
push eax // push P ...[000010e1][00211eca][000010da] >>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx >>>>>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] e820feffff >>>>>>>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>>> Detected Simulation Stopped
*All technically competent software engineers* will see >>>>>>>>>>>>> that when H bases its halt status decision on whether or >>>>>>>>>>>>> not its complete and correct x86 emulation of its input >>>>>>>>>>>>> would ever reach the "ret" instruction of this input that >>>>>>>>>>>>> H is correct to reject this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>> correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>> 00000427 ---[000013f1][0010234f][00000427] e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
Because it is an easily verified fact that the correct and
complete x86 emulation of the input to H(P,P) by H would never >>>>>>>>> reach the "ret" instruction of P and this is the criterion
measure for H to reject its input how do you figure that H
gets the wrong answer?
What I am saying is a logical tautology the same as when we
know that X is a black cat then we know that X is a cat.
that an input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>>>> ...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct
x86 emulation of its input would never reach the "ret"
instruction of Px.
That is only true if H never returns ANY answer (and thus fails
to be a decider).
behavior of Px matches this pattern that correct and complete x86
emulation of the input to H(Px,Px) by H would never reach the
"ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that
H was called with.
(b) There are no instructions in Px that could possibly escape
this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is
invoked.
Only if H never aborts. If H does abort, then Px(Px), whose
behavior exactly matches the CORRECT emulation of the input to
H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct x86
emulation of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation of the
input to H(Px,Px) by H ever reach the "ret" instruction of Px.
The complete and correct x86 emulation of the input to H(Px, Px) should
be to allow Px to halt, which is what Px is defined to do:
You are doing the same thing Richard is doing, getting at least one
word of what I am saying incorrectly and then rebutting the incorrect paraphrase. This is the strawman error.
The complete and correct x86 emulation of the input to H(Px, Px)
BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px would never
reach its "ret" instruction. This seems to be beyond your ordinary
software engineering technical competence.
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the behavior
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt whenever >>>>>>>>>>>>> it enters a final state. (Linz:1990:234)
A halt decider must compute the mapping from its inputs to an >>>>>>>>>>>>> accept or reject state on the basis of the actual behavior of >>>>>>>>>>>>> these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite number >>>>>>>>>>>>> of steps] that its correct and complete simulation of its >>>>>>>>>>>>> input would never reach [a] final state of this input then all >>>>>>>>>>>>> [these] inputs (including pathological inputs) are decided >>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>> correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>>>>> [0000110a](03) 83c408 add esp,+08
[0000110d](02) 85c0 test eax,eax >>>>>>>>>>> [0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111 >>>>>>>>>>> [00001113](01) 5d pop ebp
[00001114](01) c3 ret
Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2
...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08] >>>>>>>>>>> ...[000010e0][00211eca][000010da] 50 push eax //
push P ...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push
ecx // push P ...[000010e5][00211ec2][000010ea] e820feffff
call 00000f0a // call H Infinitely Recursive Simulation Detected >>>>>>>>>>> Simulation Stopped
*All technically competent software engineers* will see that >>>>>>>>>>> when H bases its halt status decision on whether or not its >>>>>>>>>>> complete and correct x86 emulation of its input would ever reach >>>>>>>>>>> the "ret" instruction of this input that H is correct to reject >>>>>>>>>>> this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>>>> ...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly.
QED.
/Flibble
Because it is an easily verified fact that the correct and complete >>>>>>> x86 emulation of the input to H(P,P) by H would never reach the
"ret"
instruction of P and this is the criterion measure for H to reject >>>>>>> its input how do you figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we know >>>>>>> that
X is a black cat then we know that X is a cat.
analysing what its input actually does and instead assuming that an >>>>>> input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp >>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly. >>>>>> QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct x86
emulation of its input would never reach the "ret" instruction of Px. >>>>>
That is only true if H never returns ANY answer (and thus fails to
be a decider).
of Px matches this pattern that correct and complete x86 emulation of
the input to H(Px,Px) by H would never reach the "ret" instruction of
Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that H
was called with.
(b) There are no instructions in Px that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is invoked.
Only if H never aborts. If H does abort, then Px(Px), whose behavior
exactly matches the CORRECT emulation of the input to H(Px,Px) BY
DEFINITION shows this.
The question is: Would (future tense) the complete and correct x86
emulation of the input to H(Px,Px) by H ever reach the "ret" instruction
of Px?
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation of the input
to H(Px,Px) by H ever reach the "ret" instruction of Px?
or
Does (present tense) the correct (and incomplete) x86 emulation of the
input to H(Px,Px) by H ever stop running?
A straw man (sometimes written as strawman) is a form of argument and an informal fallacy of having the impression of refuting an argument,
whereas the real subject of the argument was not addressed or refuted,
but instead replaced with a false one. https://en.wikipedia.org/wiki/Straw_man
On 6/19/22 3:17 PM, olcott wrote:A halt decider must always correctly determine whether or not its input
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the behavior
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>> whenever
it enters a final state. (Linz:1990:234)
A halt decider must compute the mapping from its inputs to an >>>>>>>>>>>>>> accept or reject state on the basis of the actual behavior of >>>>>>>>>>>>>> these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite number >>>>>>>>>>>>>> of steps] that its correct and complete simulation of its >>>>>>>>>>>>>> input would never reach [a] final state of this input then >>>>>>>>>>>>>> all
[these] inputs (including pathological inputs) are decided >>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>> correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>>>>>> [0000110a](03) 83c408 add esp,+08
[0000110d](02) 85c0 test eax,eax >>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>> [00001113](01) 5d pop ebp
[00001114](01) c3 ret
Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2
...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08] >>>>>>>>>>>> ...[000010e0][00211eca][000010da] 50 push eax //
push P ...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push
ecx // push P ...[000010e5][00211ec2][000010ea] e820feffff
call 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>> Detected
Simulation Stopped
*All technically competent software engineers* will see that >>>>>>>>>>>> when H bases its halt status decision on whether or not its >>>>>>>>>>>> complete and correct x86 emulation of its input would ever >>>>>>>>>>>> reach
the "ret" instruction of this input that H is correct to reject >>>>>>>>>>>> this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly.
QED.
/Flibble
Because it is an easily verified fact that the correct and complete >>>>>>>> x86 emulation of the input to H(P,P) by H would never reach the >>>>>>>> "ret"
instruction of P and this is the criterion measure for H to reject >>>>>>>> its input how do you figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we know >>>>>>>> that
X is a black cat then we know that X is a cat.
analysing what its input actually does and instead assuming that an >>>>>>> input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly. >>>>>>> QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct
x86 emulation of its input would never reach the "ret" instruction >>>>>> of Px.
That is only true if H never returns ANY answer (and thus fails to
be a decider).
of Px matches this pattern that correct and complete x86 emulation
of the input to H(Px,Px) by H would never reach the "ret"
instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that H
was called with.
(b) There are no instructions in Px that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is invoked.
Only if H never aborts. If H does abort, then Px(Px), whose behavior
exactly matches the CORRECT emulation of the input to H(Px,Px) BY
DEFINITION shows this.
The question is: Would (future tense) the complete and correct x86
emulation of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
What "Future Tense".
On 6/19/2022 3:08 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:assuming that an input that calls H is always pathological. >>>>>>>>>
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234) >>>>>>>>>>>>>>>>
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis of >>>>>>>>>>>>>>>> the actual behavior of these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a >>>>>>>>>>>>>>>> finite number of steps] that its correct and complete >>>>>>>>>>>>>>>> simulation of its input would never reach [a] final >>>>>>>>>>>>>>>> state of this input then all [these] inputs
(including pathological inputs) are decided
correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>> [00001100](01) 50 push eax // push
P [00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>> [00001104](01) 51 push ecx // push
P [00001105](05) e800feffff call 00000f0a // >>>>>>>>>>>>>> call H [0000110a](03) 83c408 add esp,+08 >>>>>>>>>>>>>> [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>>> [00001114](01) c3 ret >>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] 8b4508 >>>>>>>>>>>>>> mov eax,[ebp+08] ...[000010e0][00211eca][000010da] 50 >>>>>>>>>>>>>> push eax // push P
...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 >>>>>>>>>>>>>> push ecx // push P
...[000010e5][00211ec2][000010ea] e820feffff call >>>>>>>>>>>>>> 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>>>> Detected Simulation Stopped
*All technically competent software engineers* will see >>>>>>>>>>>>>> that when H bases its halt status decision on whether >>>>>>>>>>>>>> or not its complete and correct x86 emulation of its >>>>>>>>>>>>>> input would ever reach the "ret" instruction of this >>>>>>>>>>>>>> input that H is correct to reject this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427]
e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been
decided correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly. QED.
/Flibble
Because it is an easily verified fact that the correct and >>>>>>>>>> complete x86 emulation of the input to H(P,P) by H would >>>>>>>>>> never reach the "ret" instruction of P and this is the
criterion measure for H to reject its input how do you
figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we >>>>>>>>>> know that X is a black cat then we know that X is a cat. >>>>>>>>> We are talking about Px, not P. We are talking about your H >>>>>>>>> not analysing what its input actually does and instead
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and
correct x86 emulation of its input would never reach the
"ret" instruction of Px.
That is only true if H never returns ANY answer (and thus
fails to be a decider).
behavior of Px matches this pattern that correct and complete
x86 emulation of the input to H(Px,Px) by H would never reach
the "ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments
that H was called with.
(b) There are no instructions in Px that could possibly escape
this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is
invoked.
Only if H never aborts. If H does abort, then Px(Px), whose
behavior exactly matches the CORRECT emulation of the input to
H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct
x86 emulation of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation of
the input to H(Px,Px) by H ever reach the "ret" instruction of
Px.
The complete and correct x86 emulation of the input to H(Px, Px)
should be to allow Px to halt, which is what Px is defined to do:
You are doing the same thing Richard is doing, getting at least one
word of what I am saying incorrectly and then rebutting the
incorrect paraphrase. This is the strawman error.
The complete and correct x86 emulation of the input to H(Px, Px)
BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px would
never reach its "ret" instruction. This seems to be beyond your
ordinary software engineering technical competence.
Px is defined to always halt; your H gets the answer wrong saying Px doesn't halt. QED.
/Flibble
Every technically competent software engineer can easily confirm that
the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction of Px.
That you can not understand this proves that you are not a
sufficiently technically competent software engineer on this point.
Very good COBOL programmers might never be able to understand this.
To anyone that writes or maintains operating systems what I am
claiming would be as easy to verify as first grade arithmetic.
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:assuming that an input that calls H is always pathological. >>>>>>>>>>>
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis of >>>>>>>>>>>>>>>>>> the actual behavior of these actual inputs. >>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a >>>>>>>>>>>>>>>>>> finite number of steps] that its correct and complete >>>>>>>>>>>>>>>>>> simulation of its input would never reach [a] final >>>>>>>>>>>>>>>>>> state of this input then all [these] inputs >>>>>>>>>>>>>>>>>> (including pathological inputs) are decided >>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>> [00001100](01) 50 push eax // push
P [00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>> [00001104](01) 51 push ecx // push
P [00001105](05) e800feffff call 00000f0a // >>>>>>>>>>>>>>>> call H [0000110a](03) 83c408 add esp,+08 >>>>>>>>>>>>>>>> [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>>>>> [00001114](01) c3 ret >>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] 8b4508 >>>>>>>>>>>>>>>> mov eax,[ebp+08] ...[000010e0][00211eca][000010da] 50 >>>>>>>>>>>>>>>> push eax // push P
...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 >>>>>>>>>>>>>>>> push ecx // push P
...[000010e5][00211ec2][000010ea] e820feffff call >>>>>>>>>>>>>>>> 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>>>>>> Detected Simulation Stopped
*All technically competent software engineers* will see >>>>>>>>>>>>>>>> that when H bases its halt status decision on whether >>>>>>>>>>>>>>>> or not its complete and correct x86 emulation of its >>>>>>>>>>>>>>>> input would ever reach the "ret" instruction of this >>>>>>>>>>>>>>>> input that H is correct to reject this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427]
e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>> correctly. QED.
/Flibble
Because it is an easily verified fact that the correct and >>>>>>>>>>>> complete x86 emulation of the input to H(P,P) by H would >>>>>>>>>>>> never reach the "ret" instruction of P and this is the >>>>>>>>>>>> criterion measure for H to reject its input how do you >>>>>>>>>>>> figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we >>>>>>>>>>>> know that X is a black cat then we know that X is a cat. >>>>>>>>>>> We are talking about Px, not P. We are talking about your H >>>>>>>>>>> not analysing what its input actually does and instead
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and
correct x86 emulation of its input would never reach the
"ret" instruction of Px.
That is only true if H never returns ANY answer (and thus
fails to be a decider).
behavior of Px matches this pattern that correct and complete
x86 emulation of the input to H(Px,Px) by H would never reach
the "ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments
that H was called with.
(b) There are no instructions in Px that could possibly escape >>>>>>>> this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is
invoked.
Only if H never aborts. If H does abort, then Px(Px), whose
behavior exactly matches the CORRECT emulation of the input to
H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct
x86 emulation of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation of
the input to H(Px,Px) by H ever reach the "ret" instruction of
Px.
The complete and correct x86 emulation of the input to H(Px, Px)
should be to allow Px to halt, which is what Px is defined to do:
You are doing the same thing Richard is doing, getting at least one
word of what I am saying incorrectly and then rebutting the
incorrect paraphrase. This is the strawman error.
The complete and correct x86 emulation of the input to H(Px, Px)
BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px would
never reach its "ret" instruction. This seems to be beyond your
ordinary software engineering technical competence.
Px is defined to always halt; your H gets the answer wrong saying Px
doesn't halt. QED.
/Flibble
Every technically competent software engineer can easily confirm that
the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction of Px.
That you can not understand this proves that you are not a
sufficiently technically competent software engineer on this point.
Very good COBOL programmers might never be able to understand this.
To anyone that writes or maintains operating systems what I am
claiming would be as easy to verify as first grade arithmetic.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 ...[000013eb][00102353][00000000] 50 push eax ...[000013ec][0010234f][00000427] 6827040000 push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 ...[000013f9][00102357][00000000] 33c0 xor eax,eax ...[000013fb][0010235b][00100000] 5d pop ebp ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
On 6/19/2022 3:19 PM, Richard Damon wrote:
A halt decider must always correctly determine whether or not its input
On 6/19/22 3:17 PM, olcott wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the behavior
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not >>>>>>>> analysing what its input actually does and instead assuming that an >>>>>>>> input that calls H is always pathological.
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>>> whenever
it enters a final state. (Linz:1990:234)
A halt decider must compute the mapping from its inputs >>>>>>>>>>>>>>> to an
accept or reject state on the basis of the actual >>>>>>>>>>>>>>> behavior of
these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite >>>>>>>>>>>>>>> number
of steps] that its correct and complete simulation of its >>>>>>>>>>>>>>> input would never reach [a] final state of this input >>>>>>>>>>>>>>> then all
[these] inputs (including pathological inputs) are decided >>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>> correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>>>>>>> [0000110a](03) 83c408 add esp,+08 >>>>>>>>>>>>> [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>> [00001114](01) c3 ret
Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>> ...[000010e0][00211eca][000010da] 50 push eax //
push P ...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push
ecx // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>> e820feffff
call 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>>> Detected
Simulation Stopped
*All technically competent software engineers* will see that >>>>>>>>>>>>> when H bases its halt status decision on whether or not its >>>>>>>>>>>>> complete and correct x86 emulation of its input would ever >>>>>>>>>>>>> reach
the "ret" instruction of this input that H is correct to >>>>>>>>>>>>> reject
this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>> correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly.
QED.
/Flibble
Because it is an easily verified fact that the correct and
complete
x86 emulation of the input to H(P,P) by H would never reach the >>>>>>>>> "ret"
instruction of P and this is the criterion measure for H to reject >>>>>>>>> its input how do you figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we
know that
X is a black cat then we know that X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>>>> ...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly.
QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct
x86 emulation of its input would never reach the "ret"
instruction of Px.
That is only true if H never returns ANY answer (and thus fails to >>>>>> be a decider).
of Px matches this pattern that correct and complete x86 emulation
of the input to H(Px,Px) by H would never reach the "ret"
instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that
H was called with.
(b) There are no instructions in Px that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is invoked. >>>>>
Only if H never aborts. If H does abort, then Px(Px), whose behavior
exactly matches the CORRECT emulation of the input to H(Px,Px) BY
DEFINITION shows this.
The question is: Would (future tense) the complete and correct x86
emulation of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
What "Future Tense".
WOULD halt. If halt deciders reported what the behavior of its input
DOES then like you said it would never report on non halting inputs.
All non-simulating halt deciders can only report on what their input
WOULD do and not what their input DOES because non-simulating halt
deciders are static rather than dynamic analyzers.
On 6/19/22 4:34 PM, olcott wrote:Halt deciders must always predict what their non-halting inputs would do
On 6/19/2022 3:19 PM, Richard Damon wrote:
A halt decider must always correctly determine whether or not its
On 6/19/22 3:17 PM, olcott wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not >>>>>>>>> analysing what its input actually does and instead assuming
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>>>> whenever
it enters a final state. (Linz:1990:234)
A halt decider must compute the mapping from its inputs >>>>>>>>>>>>>>>> to an
accept or reject state on the basis of the actual >>>>>>>>>>>>>>>> behavior of
these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite >>>>>>>>>>>>>>>> number
of steps] that its correct and complete simulation of its >>>>>>>>>>>>>>>> input would never reach [a] final state of this input >>>>>>>>>>>>>>>> then all
[these] inputs (including pathological inputs) are decided >>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08
...[000013f9][00102357][00000000] 33c0 xor
eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>> correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>>>>>>>> [0000110a](03) 83c408 add esp,+08 >>>>>>>>>>>>>> [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>>> [00001114](01) c3 ret
Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push eax //
push P ...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51
push
ecx // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>> e820feffff
call 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>>>> Detected
Simulation Stopped
*All technically competent software engineers* will see that >>>>>>>>>>>>>> when H bases its halt status decision on whether or not its >>>>>>>>>>>>>> complete and correct x86 emulation of its input would ever >>>>>>>>>>>>>> reach
the "ret" instruction of this input that H is correct to >>>>>>>>>>>>>> reject
this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>> correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly.
QED.
/Flibble
Because it is an easily verified fact that the correct and >>>>>>>>>> complete
x86 emulation of the input to H(P,P) by H would never reach >>>>>>>>>> the "ret"
instruction of P and this is the criterion measure for H to >>>>>>>>>> reject
its input how do you figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we >>>>>>>>>> know that
X is a black cat then we know that X is a cat.
that an
input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly.
QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct >>>>>>>> x86 emulation of its input would never reach the "ret"
instruction of Px.
That is only true if H never returns ANY answer (and thus fails
to be a decider).
behavior of Px matches this pattern that correct and complete x86
emulation of the input to H(Px,Px) by H would never reach the
"ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that >>>>>> H was called with.
(b) There are no instructions in Px that could possibly escape
this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is invoked. >>>>>>
Only if H never aborts. If H does abort, then Px(Px), whose
behavior exactly matches the CORRECT emulation of the input to
H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct x86
emulation of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
What "Future Tense".
input WOULD halt. If halt deciders reported what the behavior of its
input
DOES then like you said it would never report on non halting inputs.
All non-simulating halt deciders can only report on what their input
WOULD do and not what their input DOES because non-simulating halt
deciders are static rather than dynamic analyzers.
Would only in the sense of condition of testing, not time.
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong saying Px
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis of >>>>>>>>>>>>>>>>>>> the actual behavior of these actual inputs. >>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a >>>>>>>>>>>>>>>>>>> finite number of steps] that its correct and complete >>>>>>>>>>>>>>>>>>> simulation of its input would never reach [a] final >>>>>>>>>>>>>>>>>>> state of this input then all [these] inputs >>>>>>>>>>>>>>>>>>> (including pathological inputs) are decided >>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>> [00001100](01) 50 push eax // push
P [00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx // push
P [00001105](05) e800feffff call 00000f0a // >>>>>>>>>>>>>>>>> call H [0000110a](03) 83c408 add esp,+08 >>>>>>>>>>>>>>>>> [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>>>>>> [00001114](01) c3 ret >>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] 8b4508 >>>>>>>>>>>>>>>>> mov eax,[ebp+08] ...[000010e0][00211eca][000010da] 50 >>>>>>>>>>>>>>>>> push eax // push P
...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 >>>>>>>>>>>>>>>>> push ecx // push P
...[000010e5][00211ec2][000010ea] e820feffff call >>>>>>>>>>>>>>>>> 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>>>>>>> Detected Simulation Stopped
*All technically competent software engineers* will see >>>>>>>>>>>>>>>>> that when H bases its halt status decision on whether >>>>>>>>>>>>>>>>> or not its complete and correct x86 emulation of its >>>>>>>>>>>>>>>>> input would ever reach the "ret" instruction of this >>>>>>>>>>>>>>>>> input that H is correct to reject this input. >>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>> correctly. QED.
/Flibble
Because it is an easily verified fact that the correct and >>>>>>>>>>>>> complete x86 emulation of the input to H(P,P) by H would >>>>>>>>>>>>> never reach the "ret" instruction of P and this is the >>>>>>>>>>>>> criterion measure for H to reject its input how do you >>>>>>>>>>>>> figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we >>>>>>>>>>>>> know that X is a black cat then we know that X is a cat. >>>>>>>>>>>> We are talking about Px, not P. We are talking about your H >>>>>>>>>>>> not analysing what its input actually does and instead >>>>>>>>>>>> assuming that an input that calls H is always pathological. >>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>> correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and
correct x86 emulation of its input would never reach the >>>>>>>>>>> "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus
fails to be a decider).
behavior of Px matches this pattern that correct and complete >>>>>>>>> x86 emulation of the input to H(Px,Px) by H would never reach >>>>>>>>> the "ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments >>>>>>>>> that H was called with.
(b) There are no instructions in Px that could possibly escape >>>>>>>>> this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is
invoked.
Only if H never aborts. If H does abort, then Px(Px), whose
behavior exactly matches the CORRECT emulation of the input to >>>>>>>> H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct
x86 emulation of the input to H(Px,Px) by H ever reach the "ret" >>>>>>> instruction of Px.
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation of
the input to H(Px,Px) by H ever reach the "ret" instruction of
Px.
The complete and correct x86 emulation of the input to H(Px, Px)
should be to allow Px to halt, which is what Px is defined to do:
You are doing the same thing Richard is doing, getting at least one
word of what I am saying incorrectly and then rebutting the
incorrect paraphrase. This is the strawman error.
The complete and correct x86 emulation of the input to H(Px, Px)
BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px would
never reach its "ret" instruction. This seems to be beyond your
ordinary software engineering technical competence.
doesn't halt. QED.
/Flibble
Every technically competent software engineer can easily confirm that
the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction of Px.
That you can not understand this proves that you are not a
sufficiently technically competent software engineer on this point.
Very good COBOL programmers might never be able to understand this.
To anyone that writes or maintains operating systems what I am
claiming would be as easy to verify as first grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
Get an operating system programmer to explain to you that the correct
and complete x86 emulation of the input to H(Px,Px) by H would never
reach the "ret" instruction of Px. *This is totally over your head*
It is like I am saying that we know that black carts are cats and you disagree saying the a black cat might be some kind of dog.
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the >>>>>>>>>> behavior of Px matches this pattern that correct and
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about >>>>>>>>>>>>> your H not analysing what its input actually does and >>>>>>>>>>>>> instead assuming that an input that calls H is always >>>>>>>>>>>>> pathological.
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:{
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will >>>>>>>>>>>>>>>>>>>> halt whenever it enters a final state. >>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis >>>>>>>>>>>>>>>>>>>> of the actual behavior of these actual inputs. >>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects all >>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly >>>>>>>>>>>>>>>>>>>> detects [in a finite number of steps] that its >>>>>>>>>>>>>>>>>>>> correct and complete simulation of its input >>>>>>>>>>>>>>>>>>>> would never reach [a] final state of this input >>>>>>>>>>>>>>>>>>>> then all [these] inputs (including pathological >>>>>>>>>>>>>>>>>>>> inputs) are decided correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>> [00001100](01) 50 push eax //
push P [00001101](03) 8b4d08 mov >>>>>>>>>>>>>>>>>> ecx,[ebp+08] [00001104](01) 51 push
ecx // push P [00001105](05) e800feffff >>>>>>>>>>>>>>>>>> call 00000f0a // call H [0000110a](03) 83c408 >>>>>>>>>>>>>>>>>> add esp,+08 [0000110d](02) 85c0 >>>>>>>>>>>>>>>>>> test eax,eax [0000110f](02) 7402 jz
00001113 [00001111](02) ebfe jmp >>>>>>>>>>>>>>>>>> 00001111 [00001113](01) 5d pop ebp
[00001114](01) c3 ret >>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push >>>>>>>>>>>>>>>>>> ebp ...[000010db][00211ece][00211ed2] 8bec >>>>>>>>>>>>>>>>>> mov ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push eax >>>>>>>>>>>>>>>>>> // push P ...[000010e1][00211eca][000010da] 8b4d08 >>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx // >>>>>>>>>>>>>>>>>> push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H Infinitely >>>>>>>>>>>>>>>>>> Recursive Simulation Detected Simulation Stopped >>>>>>>>>>>>>>>>>>
*All technically competent software engineers* >>>>>>>>>>>>>>>>>> will see that when H bases its halt status >>>>>>>>>>>>>>>>>> decision on whether or not its complete and >>>>>>>>>>>>>>>>>> correct x86 emulation of its input would ever >>>>>>>>>>>>>>>>>> reach the "ret" instruction of this input that H >>>>>>>>>>>>>>>>>> is correct to reject this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408
add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408
add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>> void Px(u32 x)
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
Because it is an easily verified fact that the correct >>>>>>>>>>>>>> and complete x86 emulation of the input to H(P,P) by H >>>>>>>>>>>>>> would never reach the "ret" instruction of P and this >>>>>>>>>>>>>> is the criterion measure for H to reject its input how >>>>>>>>>>>>>> do you figure that H gets the wrong answer?
What I am saying is a logical tautology the same as >>>>>>>>>>>>>> when we know that X is a black cat then we know that X >>>>>>>>>>>>>> is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427]
e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been
decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and >>>>>>>>>>>> correct x86 emulation of its input would never reach the >>>>>>>>>>>> "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus >>>>>>>>>>> fails to be a decider).
complete x86 emulation of the input to H(Px,Px) by H would >>>>>>>>>> never reach the "ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same
arguments that H was called with.
(b) There are no instructions in Px that could possibly
escape this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is >>>>>>>>>> invoked.
Only if H never aborts. If H does abort, then Px(Px), whose >>>>>>>>> behavior exactly matches the CORRECT emulation of the input >>>>>>>>> to H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and
correct x86 emulation of the input to H(Px,Px) by H ever
reach the "ret" instruction of Px.
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation
of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
The complete and correct x86 emulation of the input to H(Px,
Px) should be to allow Px to halt, which is what Px is
defined to do:
You are doing the same thing Richard is doing, getting at
least one word of what I am saying incorrectly and then
rebutting the incorrect paraphrase. This is the strawman error.
The complete and correct x86 emulation of the input to H(Px,
Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px
would never reach its "ret" instruction. This seems to be
beyond your ordinary software engineering technical
competence.
saying Px doesn't halt. QED.
/Flibble
Every technically competent software engineer can easily confirm
that the correct and complete x86 emulation of the input to
H(Px,Px) by H would never reach the "ret" instruction of Px.
That you can not understand this proves that you are not a
sufficiently technically competent software engineer on this
point. Very good COBOL programmers might never be able to
understand this.
To anyone that writes or maintains operating systems what I am
claiming would be as easy to verify as first grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>> ...[000013eb][00102353][00000000] 50 push eax >>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>> ...[000013fb][0010235b][00100000] 5d pop ebp >>> ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
Get an operating system programmer to explain to you that the
correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction of Px. *This is totally
over your head*
It is like I am saying that we know that black carts are cats and
you disagree saying the a black cat might be some kind of dog.
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
No, maybe you need an actual programmer to look at your logic.
First, by definition correct emulation of a program will match the behavior of the program.
When you disagree with this precisely stated verified fact you are
either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction
When you disagree the the above precisely stated verified fact by
changing its words and showing that the changed words are not true
then between liar and incompetent you prove to be a liar.
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong saying Px >>>>> doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500You are doing the same thing Richard is doing, getting at least one >>>>>> word of what I am saying incorrectly and then rebutting the
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the >>>>>>>>>> behavior of Px matches this pattern that correct and complete >>>>>>>>>> x86 emulation of the input to H(Px,Px) by H would never reach >>>>>>>>>> the "ret" instruction of Px:
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>>
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis of >>>>>>>>>>>>>>>>>>>> the actual behavior of these actual inputs. >>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a >>>>>>>>>>>>>>>>>>>> finite number of steps] that its correct and complete >>>>>>>>>>>>>>>>>>>> simulation of its input would never reach [a] final >>>>>>>>>>>>>>>>>>>> state of this input then all [these] inputs >>>>>>>>>>>>>>>>>>>> (including pathological inputs) are decided >>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>> [00001100](01) 50 push eax // push
P [00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx // push
P [00001105](05) e800feffff call 00000f0a // >>>>>>>>>>>>>>>>>> call H [0000110a](03) 83c408 add esp,+08 >>>>>>>>>>>>>>>>>> [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>>>>>>> [00001114](01) c3 ret >>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] 8b4508 >>>>>>>>>>>>>>>>>> mov eax,[ebp+08] ...[000010e0][00211eca][000010da] 50 >>>>>>>>>>>>>>>>>> push eax // push P
...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 >>>>>>>>>>>>>>>>>> push ecx // push P
...[000010e5][00211ec2][000010ea] e820feffff call >>>>>>>>>>>>>>>>>> 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>>>>>>>> Detected Simulation Stopped
*All technically competent software engineers* will see >>>>>>>>>>>>>>>>>> that when H bases its halt status decision on whether >>>>>>>>>>>>>>>>>> or not its complete and correct x86 emulation of its >>>>>>>>>>>>>>>>>> input would ever reach the "ret" instruction of this >>>>>>>>>>>>>>>>>> input that H is correct to reject this input. >>>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>> correctly. QED.
/Flibble
Because it is an easily verified fact that the correct and >>>>>>>>>>>>>> complete x86 emulation of the input to H(P,P) by H would >>>>>>>>>>>>>> never reach the "ret" instruction of P and this is the >>>>>>>>>>>>>> criterion measure for H to reject its input how do you >>>>>>>>>>>>>> figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we >>>>>>>>>>>>>> know that X is a black cat then we know that X is a cat. >>>>>>>>>>>>> We are talking about Px, not P. We are talking about your H >>>>>>>>>>>>> not analysing what its input actually does and instead >>>>>>>>>>>>> assuming that an input that calls H is always pathological. >>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>> correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and >>>>>>>>>>>> correct x86 emulation of its input would never reach the >>>>>>>>>>>> "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus >>>>>>>>>>> fails to be a decider).
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments >>>>>>>>>> that H was called with.
(b) There are no instructions in Px that could possibly escape >>>>>>>>>> this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is >>>>>>>>>> invoked.
Only if H never aborts. If H does abort, then Px(Px), whose
behavior exactly matches the CORRECT emulation of the input to >>>>>>>>> H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct >>>>>>>> x86 emulation of the input to H(Px,Px) by H ever reach the "ret" >>>>>>>> instruction of Px.
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation of >>>>>>>> the input to H(Px,Px) by H ever reach the "ret" instruction of >>>>>>>> Px.
The complete and correct x86 emulation of the input to H(Px, Px) >>>>>>> should be to allow Px to halt, which is what Px is defined to do: >>>>>>
incorrect paraphrase. This is the strawman error.
The complete and correct x86 emulation of the input to H(Px, Px)
BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px would
never reach its "ret" instruction. This seems to be beyond your
ordinary software engineering technical competence.
/Flibble
Every technically competent software engineer can easily confirm that
the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction of Px.
That you can not understand this proves that you are not a
sufficiently technically competent software engineer on this point.
Very good COBOL programmers might never be able to understand this.
To anyone that writes or maintains operating systems what I am
claiming would be as easy to verify as first grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax >>> ...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
Get an operating system programmer to explain to you that the correct
and complete x86 emulation of the input to H(Px,Px) by H would never
reach the "ret" instruction of Px. *This is totally over your head*
It is like I am saying that we know that black carts are cats and you
disagree saying the a black cat might be some kind of dog.
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
No, maybe you need an actual programmer to look at your logic.
First, by definition correct emulation of a program will match the
behavior of the program.
On 6/19/2022 3:50 PM, Richard Damon wrote:
On 6/19/22 4:34 PM, olcott wrote:Halt deciders must always predict what their non-halting inputs would do
On 6/19/2022 3:19 PM, Richard Damon wrote:
A halt decider must always correctly determine whether or not its
On 6/19/22 3:17 PM, olcott wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not >>>>>>>>>> analysing what its input actually does and instead assuming >>>>>>>>>> that an
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>>>>> whenever
it enters a final state. (Linz:1990:234)
A halt decider must compute the mapping from its inputs >>>>>>>>>>>>>>>>> to an
accept or reject state on the basis of the actual >>>>>>>>>>>>>>>>> behavior of
these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite >>>>>>>>>>>>>>>>> number
of steps] that its correct and complete simulation of its >>>>>>>>>>>>>>>>> input would never reach [a] final state of this input >>>>>>>>>>>>>>>>> then all
[these] inputs (including pathological inputs) are decided >>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>>> esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>>> esp,+08
...[000013f9][00102357][00000000] 33c0 xor
eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>>> correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H >>>>>>>>>>>>>>> [0000110a](03) 83c408 add esp,+08 >>>>>>>>>>>>>>> [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>>>> [00001114](01) c3 ret >>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov >>>>>>>>>>>>>>> eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push >>>>>>>>>>>>>>> eax //
push P ...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push >>>>>>>>>>>>>>> ecx // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>> e820feffff
call 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>>>>> Detected
Simulation Stopped
*All technically competent software engineers* will see that >>>>>>>>>>>>>>> when H bases its halt status decision on whether or not its >>>>>>>>>>>>>>> complete and correct x86 emulation of its input would >>>>>>>>>>>>>>> ever reach
the "ret" instruction of this input that H is correct to >>>>>>>>>>>>>>> reject
this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>> correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>> correctly.
QED.
/Flibble
Because it is an easily verified fact that the correct and >>>>>>>>>>> complete
x86 emulation of the input to H(P,P) by H would never reach >>>>>>>>>>> the "ret"
instruction of P and this is the criterion measure for H to >>>>>>>>>>> reject
its input how do you figure that H gets the wrong answer? >>>>>>>>>>>
What I am saying is a logical tautology the same as when we >>>>>>>>>>> know that
X is a black cat then we know that X is a cat.
input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly.
QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and correct >>>>>>>>> x86 emulation of its input would never reach the "ret"
instruction of Px.
That is only true if H never returns ANY answer (and thus fails >>>>>>>> to be a decider).
behavior of Px matches this pattern that correct and complete x86 >>>>>>> emulation of the input to H(Px,Px) by H would never reach the
"ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments
that H was called with.
(b) There are no instructions in Px that could possibly escape
this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is invoked. >>>>>>>
Only if H never aborts. If H does abort, then Px(Px), whose
behavior exactly matches the CORRECT emulation of the input to
H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct x86
emulation of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
What "Future Tense".
input WOULD halt. If halt deciders reported what the behavior of its
input
DOES then like you said it would never report on non halting inputs.
All non-simulating halt deciders can only report on what their input
WOULD do and not what their input DOES because non-simulating halt
deciders are static rather than dynamic analyzers.
Would only in the sense of condition of testing, not time.
in the future if they were executed.
They can never report on the non-halting behavior of what their inputs
did do in the past.
You have been confused about this for your last 1000 messages.
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the >>>>>>>>>>>> behavior of Px matches this pattern that correct and
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about >>>>>>>>>>>>>>> your H not analysing what its input actually does and >>>>>>>>>>>>>>> instead assuming that an input that calls H is always >>>>>>>>>>>>>>> pathological.
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:{
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will >>>>>>>>>>>>>>>>>>>>>> halt whenever it enters a final state. >>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis >>>>>>>>>>>>>>>>>>>>>> of the actual behavior of these actual inputs. >>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects all >>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly >>>>>>>>>>>>>>>>>>>>>> detects [in a finite number of steps] that its >>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of its input >>>>>>>>>>>>>>>>>>>>>> would never reach [a] final state of this input >>>>>>>>>>>>>>>>>>>>>> then all [these] inputs (including pathological >>>>>>>>>>>>>>>>>>>>>> inputs) are decided correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>> [00001100](01) 50 push eax //
push P [00001101](03) 8b4d08 mov >>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [00001104](01) 51 push
ecx // push P [00001105](05) e800feffff >>>>>>>>>>>>>>>>>>>> call 00000f0a // call H [0000110a](03) 83c408 >>>>>>>>>>>>>>>>>>>> add esp,+08 [0000110d](02) 85c0 >>>>>>>>>>>>>>>>>>>> test eax,eax [0000110f](02) 7402 jz
00001113 [00001111](02) ebfe jmp >>>>>>>>>>>>>>>>>>>> 00001111 [00001113](01) 5d pop ebp
[00001114](01) c3 ret >>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push >>>>>>>>>>>>>>>>>>>> ebp ...[000010db][00211ece][00211ed2] 8bec >>>>>>>>>>>>>>>>>>>> mov ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push eax >>>>>>>>>>>>>>>>>>>> // push P ...[000010e1][00211eca][000010da] 8b4d08 >>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx // >>>>>>>>>>>>>>>>>>>> push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H Infinitely >>>>>>>>>>>>>>>>>>>> Recursive Simulation Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>>> will see that when H bases its halt status >>>>>>>>>>>>>>>>>>>> decision on whether or not its complete and >>>>>>>>>>>>>>>>>>>> correct x86 emulation of its input would ever >>>>>>>>>>>>>>>>>>>> reach the "ret" instruction of this input that H >>>>>>>>>>>>>>>>>>>> is correct to reject this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>>> void Px(u32 x)
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
Because it is an easily verified fact that the correct >>>>>>>>>>>>>>>> and complete x86 emulation of the input to H(P,P) by H >>>>>>>>>>>>>>>> would never reach the "ret" instruction of P and this >>>>>>>>>>>>>>>> is the criterion measure for H to reject its input how >>>>>>>>>>>>>>>> do you figure that H gets the wrong answer?
What I am saying is a logical tautology the same as >>>>>>>>>>>>>>>> when we know that X is a black cat then we know that X >>>>>>>>>>>>>>>> is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427]
e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and >>>>>>>>>>>>>> correct x86 emulation of its input would never reach the >>>>>>>>>>>>>> "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus >>>>>>>>>>>>> fails to be a decider).
complete x86 emulation of the input to H(Px,Px) by H would >>>>>>>>>>>> never reach the "ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same
arguments that H was called with.
(b) There are no instructions in Px that could possibly >>>>>>>>>>>> escape this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is >>>>>>>>>>>> invoked.
Only if H never aborts. If H does abort, then Px(Px), whose >>>>>>>>>>> behavior exactly matches the CORRECT emulation of the input >>>>>>>>>>> to H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and
correct x86 emulation of the input to H(Px,Px) by H ever
reach the "ret" instruction of Px.
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation >>>>>>>>>> of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
The complete and correct x86 emulation of the input to H(Px, >>>>>>>>> Px) should be to allow Px to halt, which is what Px is
defined to do:
You are doing the same thing Richard is doing, getting at
least one word of what I am saying incorrectly and then
rebutting the incorrect paraphrase. This is the strawman error. >>>>>>>>
The complete and correct x86 emulation of the input to H(Px,
Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px
would never reach its "ret" instruction. This seems to be
beyond your ordinary software engineering technical
competence.
saying Px doesn't halt. QED.
/Flibble
Every technically competent software engineer can easily confirm
that the correct and complete x86 emulation of the input to
H(Px,Px) by H would never reach the "ret" instruction of Px.
That you can not understand this proves that you are not a
sufficiently technically competent software engineer on this
point. Very good COBOL programmers might never be able to
understand this.
To anyone that writes or maintains operating systems what I am
claiming would be as easy to verify as first grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>>> ...[000013fb][0010235b][00100000] 5d pop ebp >>>>> ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
Get an operating system programmer to explain to you that the
correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction of Px. *This is totally
over your head*
It is like I am saying that we know that black carts are cats and
you disagree saying the a black cat might be some kind of dog.
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
No, maybe you need an actual programmer to look at your logic.
First, by definition correct emulation of a program will match the
behavior of the program.
When you disagree with this precisely stated verified fact you are
either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction
When you disagree the the above precisely stated verified fact by
changing its words and showing that the changed words are not true
then between liar and incompetent you prove to be a liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 ...[000013eb][00102353][00000000] 50 push eax ...[000013ec][0010234f][00000427] 6827040000 push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 ...[000013f9][00102357][00000000] 33c0 xor eax,eax ...[000013fb][0010235b][00100000] 5d pop ebp ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong saying Px >>>>>> doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500You are doing the same thing Richard is doing, getting at least one >>>>>>> word of what I am saying incorrectly and then rebutting the
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the >>>>>>>>>>> behavior of Px matches this pattern that correct and complete >>>>>>>>>>> x86 emulation of the input to H(Px,Px) by H would never reach >>>>>>>>>>> the "ret" instruction of Px:
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:{
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500void Px(u32 x)
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>>>
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis of >>>>>>>>>>>>>>>>>>>>> the actual behavior of these actual inputs. >>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a >>>>>>>>>>>>>>>>>>>>> finite number of steps] that its correct and complete >>>>>>>>>>>>>>>>>>>>> simulation of its input would never reach [a] final >>>>>>>>>>>>>>>>>>>>> state of this input then all [these] inputs >>>>>>>>>>>>>>>>>>>>> (including pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>> [00001100](01) 50 push eax // push
P [00001101](03) 8b4d08 mov ecx,[ebp+08]
[00001104](01) 51 push ecx // push
P [00001105](05) e800feffff call 00000f0a // >>>>>>>>>>>>>>>>>>> call H [0000110a](03) 83c408 add esp,+08
[0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>>>>>>>> [00001114](01) c3 ret >>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] 8b4508 >>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] ...[000010e0][00211eca][000010da] 50 >>>>>>>>>>>>>>>>>>> push eax // push P
...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 >>>>>>>>>>>>>>>>>>> push ecx // push P
...[000010e5][00211ec2][000010ea] e820feffff call >>>>>>>>>>>>>>>>>>> 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>>>>>>>>> Detected Simulation Stopped
*All technically competent software engineers* will see >>>>>>>>>>>>>>>>>>> that when H bases its halt status decision on whether >>>>>>>>>>>>>>>>>>> or not its complete and correct x86 emulation of its >>>>>>>>>>>>>>>>>>> input would ever reach the "ret" instruction of this >>>>>>>>>>>>>>>>>>> input that H is correct to reject this input. >>>>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>> void Px(u32 x)
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>>> correctly. QED.
/Flibble
Because it is an easily verified fact that the correct and >>>>>>>>>>>>>>> complete x86 emulation of the input to H(P,P) by H would >>>>>>>>>>>>>>> never reach the "ret" instruction of P and this is the >>>>>>>>>>>>>>> criterion measure for H to reject its input how do you >>>>>>>>>>>>>>> figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we >>>>>>>>>>>>>>> know that X is a black cat then we know that X is a cat. >>>>>>>>>>>>>> We are talking about Px, not P. We are talking about your H >>>>>>>>>>>>>> not analysing what its input actually does and instead >>>>>>>>>>>>>> assuming that an input that calls H is always pathological. >>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>> correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and >>>>>>>>>>>>> correct x86 emulation of its input would never reach the >>>>>>>>>>>>> "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus >>>>>>>>>>>> fails to be a decider).
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments >>>>>>>>>>> that H was called with.
(b) There are no instructions in Px that could possibly escape >>>>>>>>>>> this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is >>>>>>>>>>> invoked.
Only if H never aborts. If H does abort, then Px(Px), whose >>>>>>>>>> behavior exactly matches the CORRECT emulation of the input to >>>>>>>>>> H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct >>>>>>>>> x86 emulation of the input to H(Px,Px) by H ever reach the "ret" >>>>>>>>> instruction of Px.
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation of >>>>>>>>> the input to H(Px,Px) by H ever reach the "ret" instruction of >>>>>>>>> Px.
The complete and correct x86 emulation of the input to H(Px, Px) >>>>>>>> should be to allow Px to halt, which is what Px is defined to do: >>>>>>>
incorrect paraphrase. This is the strawman error.
The complete and correct x86 emulation of the input to H(Px, Px) >>>>>>> BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px would >>>>>>> never reach its "ret" instruction. This seems to be beyond your
ordinary software engineering technical competence.
/Flibble
Every technically competent software engineer can easily confirm that >>>>> the correct and complete x86 emulation of the input to H(Px,Px) by H >>>>> would never reach the "ret" instruction of Px.
That you can not understand this proves that you are not a
sufficiently technically competent software engineer on this point.
Very good COBOL programmers might never be able to understand this.
To anyone that writes or maintains operating systems what I am
claiming would be as easy to verify as first grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>> ...[000013eb][00102353][00000000] 50 push eax >>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>> ...[000013fb][0010235b][00100000] 5d pop ebp >>>> ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
Get an operating system programmer to explain to you that the correct
and complete x86 emulation of the input to H(Px,Px) by H would never
reach the "ret" instruction of Px. *This is totally over your head*
It is like I am saying that we know that black carts are cats and you
disagree saying the a black cat might be some kind of dog.
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
No, maybe you need an actual programmer to look at your logic.
First, by definition correct emulation of a program will match the
behavior of the program.
When you disagree with this precisely stated verified fact you are
either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction
When you disagree the the above precisely stated verified fact by
changing its words and showing that the changed words are not true then between liar and incompetent you prove to be a liar.
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:void Px(u32 x)
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the >>>>>>>>>>>>> behavior of Px matches this pattern that correct and >>>>>>>>>>>>> complete x86 emulation of the input to H(Px,Px) by H would >>>>>>>>>>>>> never reach the "ret" instruction of Px:
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about >>>>>>>>>>>>>>>> your H not analysing what its input actually does and >>>>>>>>>>>>>>>> instead assuming that an input that calls H is always >>>>>>>>>>>>>>>> pathological.
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500{
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine will >>>>>>>>>>>>>>>>>>>>>>> halt whenever it enters a final state. >>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis >>>>>>>>>>>>>>>>>>>>>>> of the actual behavior of these actual inputs. >>>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects all >>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly >>>>>>>>>>>>>>>>>>>>>>> detects [in a finite number of steps] that its >>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of its input >>>>>>>>>>>>>>>>>>>>>>> would never reach [a] final state of this input >>>>>>>>>>>>>>>>>>>>>>> then all [these] inputs (including pathological >>>>>>>>>>>>>>>>>>>>>>> inputs) are decided correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08]
[00001100](01) 50 push eax //
push P [00001101](03) 8b4d08 mov >>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [00001104](01) 51 push
ecx // push P [00001105](05) e800feffff >>>>>>>>>>>>>>>>>>>>> call 00000f0a // call H [0000110a](03) 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 [0000110d](02) 85c0 >>>>>>>>>>>>>>>>>>>>> test eax,eax [0000110f](02) 7402 jz
00001113 [00001111](02) ebfe jmp >>>>>>>>>>>>>>>>>>>>> 00001111 [00001113](01) 5d pop ebp
[00001114](01) c3 ret >>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push >>>>>>>>>>>>>>>>>>>>> ebp ...[000010db][00211ece][00211ed2] 8bec >>>>>>>>>>>>>>>>>>>>> mov ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push eax >>>>>>>>>>>>>>>>>>>>> // push P ...[000010e1][00211eca][000010da] 8b4d08 >>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx // >>>>>>>>>>>>>>>>>>>>> push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H Infinitely >>>>>>>>>>>>>>>>>>>>> Recursive Simulation Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>>>> will see that when H bases its halt status >>>>>>>>>>>>>>>>>>>>> decision on whether or not its complete and >>>>>>>>>>>>>>>>>>>>> correct x86 emulation of its input would ever >>>>>>>>>>>>>>>>>>>>> reach the "ret" instruction of this input that H >>>>>>>>>>>>>>>>>>>>> is correct to reject this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>>>> void Px(u32 x)
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
Because it is an easily verified fact that the correct >>>>>>>>>>>>>>>>> and complete x86 emulation of the input to H(P,P) by H >>>>>>>>>>>>>>>>> would never reach the "ret" instruction of P and this >>>>>>>>>>>>>>>>> is the criterion measure for H to reject its input how >>>>>>>>>>>>>>>>> do you figure that H gets the wrong answer?
What I am saying is a logical tautology the same as >>>>>>>>>>>>>>>>> when we know that X is a black cat then we know that X >>>>>>>>>>>>>>>>> is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and >>>>>>>>>>>>>>> correct x86 emulation of its input would never reach the >>>>>>>>>>>>>>> "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus >>>>>>>>>>>>>> fails to be a decider).
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same
arguments that H was called with.
(b) There are no instructions in Px that could possibly >>>>>>>>>>>>> escape this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is >>>>>>>>>>>>> invoked.
Only if H never aborts. If H does abort, then Px(Px), whose >>>>>>>>>>>> behavior exactly matches the CORRECT emulation of the input >>>>>>>>>>>> to H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and
correct x86 emulation of the input to H(Px,Px) by H ever >>>>>>>>>>> reach the "ret" instruction of Px.
You always change this question to a different question: >>>>>>>>>>>
Does (present tense) the complete and correct x86 emulation >>>>>>>>>>> of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
The complete and correct x86 emulation of the input to H(Px, >>>>>>>>>> Px) should be to allow Px to halt, which is what Px is
defined to do:
You are doing the same thing Richard is doing, getting at
least one word of what I am saying incorrectly and then
rebutting the incorrect paraphrase. This is the strawman error. >>>>>>>>>
The complete and correct x86 emulation of the input to H(Px, >>>>>>>>> Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px
would never reach its "ret" instruction. This seems to be
beyond your ordinary software engineering technical
competence.
saying Px doesn't halt. QED.
/Flibble
Every technically competent software engineer can easily confirm >>>>>>> that the correct and complete x86 emulation of the input to
H(Px,Px) by H would never reach the "ret" instruction of Px.
That you can not understand this proves that you are not a
sufficiently technically competent software engineer on this
point. Very good COBOL programmers might never be able to
understand this.
To anyone that writes or maintains operating systems what I am
claiming would be as easy to verify as first grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp >>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
Get an operating system programmer to explain to you that the
correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction of Px. *This is totally
over your head*
It is like I am saying that we know that black carts are cats and
you disagree saying the a black cat might be some kind of dog.
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
No, maybe you need an actual programmer to look at your logic.
First, by definition correct emulation of a program will match the
behavior of the program.
When you disagree with this precisely stated verified fact you are
either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction
When you disagree the the above precisely stated verified fact by
changing its words and showing that the changed words are not true
then between liar and incompetent you prove to be a liar.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction
On 6/19/22 5:17 PM, olcott wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong saying Px >>>>>>> doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500You are doing the same thing Richard is doing, getting at least one >>>>>>>> word of what I am saying incorrectly and then rebutting the
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the >>>>>>>>>>>> behavior of Px matches this pattern that correct and complete >>>>>>>>>>>> x86 emulation of the input to H(Px,Px) by H would never reach >>>>>>>>>>>> the "ret" instruction of Px:
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:{
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500void Px(u32 x)
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>>>>
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis of >>>>>>>>>>>>>>>>>>>>>> the actual behavior of these actual inputs. >>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a >>>>>>>>>>>>>>>>>>>>>> finite number of steps] that its correct and complete >>>>>>>>>>>>>>>>>>>>>> simulation of its input would never reach [a] final >>>>>>>>>>>>>>>>>>>>>> state of this input then all [these] inputs >>>>>>>>>>>>>>>>>>>>>> (including pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>> [00001100](01) 50 push eax // push
P [00001101](03) 8b4d08 mov ecx,[ebp+08]
[00001104](01) 51 push ecx // push
P [00001105](05) e800feffff call 00000f0a // >>>>>>>>>>>>>>>>>>>> call H [0000110a](03) 83c408 add esp,+08
[0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>>>>>>>>> [00001114](01) c3 ret >>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] 8b4508 >>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] ...[000010e0][00211eca][000010da] 50 >>>>>>>>>>>>>>>>>>>> push eax // push P
...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 >>>>>>>>>>>>>>>>>>>> push ecx // push P
...[000010e5][00211ec2][000010ea] e820feffff call >>>>>>>>>>>>>>>>>>>> 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped
*All technically competent software engineers* will see >>>>>>>>>>>>>>>>>>>> that when H bases its halt status decision on whether >>>>>>>>>>>>>>>>>>>> or not its complete and correct x86 emulation of its >>>>>>>>>>>>>>>>>>>> input would ever reach the "ret" instruction of this >>>>>>>>>>>>>>>>>>>> input that H is correct to reject this input. >>>>>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>>> void Px(u32 x)
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>>>> correctly. QED.
/Flibble
Because it is an easily verified fact that the correct and >>>>>>>>>>>>>>>> complete x86 emulation of the input to H(P,P) by H would >>>>>>>>>>>>>>>> never reach the "ret" instruction of P and this is the >>>>>>>>>>>>>>>> criterion measure for H to reject its input how do you >>>>>>>>>>>>>>>> figure that H gets the wrong answer?
What I am saying is a logical tautology the same as when we >>>>>>>>>>>>>>>> know that X is a black cat then we know that X is a cat. >>>>>>>>>>>>>>> We are talking about Px, not P. We are talking about your H >>>>>>>>>>>>>>> not analysing what its input actually does and instead >>>>>>>>>>>>>>> assuming that an input that calls H is always pathological. >>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>> correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and >>>>>>>>>>>>>> correct x86 emulation of its input would never reach the >>>>>>>>>>>>>> "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus >>>>>>>>>>>>> fails to be a decider).
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments >>>>>>>>>>>> that H was called with.
(b) There are no instructions in Px that could possibly escape >>>>>>>>>>>> this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is >>>>>>>>>>>> invoked.
Only if H never aborts. If H does abort, then Px(Px), whose >>>>>>>>>>> behavior exactly matches the CORRECT emulation of the input to >>>>>>>>>>> H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct >>>>>>>>>> x86 emulation of the input to H(Px,Px) by H ever reach the "ret" >>>>>>>>>> instruction of Px.
You always change this question to a different question:
Does (present tense) the complete and correct x86 emulation of >>>>>>>>>> the input to H(Px,Px) by H ever reach the "ret" instruction of >>>>>>>>>> Px.
The complete and correct x86 emulation of the input to H(Px, Px) >>>>>>>>> should be to allow Px to halt, which is what Px is defined to do: >>>>>>>>
incorrect paraphrase. This is the strawman error.
The complete and correct x86 emulation of the input to H(Px, Px) >>>>>>>> BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px would >>>>>>>> never reach its "ret" instruction. This seems to be beyond your >>>>>>>> ordinary software engineering technical competence.
/Flibble
Every technically competent software engineer can easily confirm that >>>>>> the correct and complete x86 emulation of the input to H(Px,Px) by H >>>>>> would never reach the "ret" instruction of Px.
That you can not understand this proves that you are not a
sufficiently technically competent software engineer on this point. >>>>>> Very good COBOL programmers might never be able to understand this. >>>>>>
To anyone that writes or maintains operating systems what I am
claiming would be as easy to verify as first grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>>> ...[000013fb][0010235b][00100000] 5d pop ebp >>>>> ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly. >>>>> QED.
/Flibble
Get an operating system programmer to explain to you that the
correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction of Px. *This is totally over
your head*
It is like I am saying that we know that black carts are cats and
you disagree saying the a black cat might be some kind of dog.
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
No, maybe you need an actual programmer to look at your logic.
First, by definition correct emulation of a program will match the
behavior of the program.
When you disagree with this precisely stated verified fact you are
either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction
When did you verify this statment for an H that returns 0?
On 6/19/22 4:55 PM, olcott wrote:
On 6/19/2022 3:50 PM, Richard Damon wrote:
On 6/19/22 4:34 PM, olcott wrote:Halt deciders must always predict what their non-halting inputs would
On 6/19/2022 3:19 PM, Richard Damon wrote:
A halt decider must always correctly determine whether or not its
On 6/19/22 3:17 PM, olcott wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not >>>>>>>>>>> analysing what its input actually does and instead assuming >>>>>>>>>>> that an
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>>>>>> whenever
it enters a final state. (Linz:1990:234)
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>> inputs to an
accept or reject state on the basis of the actual >>>>>>>>>>>>>>>>>> behavior of
these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite >>>>>>>>>>>>>>>>>> number
of steps] that its correct and complete simulation of its >>>>>>>>>>>>>>>>>> input would never reach [a] final state of this input >>>>>>>>>>>>>>>>>> then all
[these] inputs (including pathological inputs) are >>>>>>>>>>>>>>>>>> decided
correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add
esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08
...[000013f9][00102357][00000000] 33c0 xor
eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>>>> correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H
[0000110a](03) 83c408 add esp,+08 >>>>>>>>>>>>>>>> [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>>>>> [00001114](01) c3 ret >>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp >>>>>>>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov >>>>>>>>>>>>>>>> eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push >>>>>>>>>>>>>>>> eax //
push P ...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push >>>>>>>>>>>>>>>> ecx // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>> e820feffff
call 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>>>>>> Detected
Simulation Stopped
*All technically competent software engineers* will see >>>>>>>>>>>>>>>> that
when H bases its halt status decision on whether or not its >>>>>>>>>>>>>>>> complete and correct x86 emulation of its input would >>>>>>>>>>>>>>>> ever reach
the "ret" instruction of this input that H is correct to >>>>>>>>>>>>>>>> reject
this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08
...[000013f9][00102357][00000000] 33c0 xor
eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>> correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>> correctly.
QED.
/Flibble
Because it is an easily verified fact that the correct and >>>>>>>>>>>> complete
x86 emulation of the input to H(P,P) by H would never reach >>>>>>>>>>>> the "ret"
instruction of P and this is the criterion measure for H to >>>>>>>>>>>> reject
its input how do you figure that H gets the wrong answer? >>>>>>>>>>>>
What I am saying is a logical tautology the same as when we >>>>>>>>>>>> know that
X is a black cat then we know that X is a cat.
input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly.
QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and
correct x86 emulation of its input would never reach the "ret" >>>>>>>>>> instruction of Px.
That is only true if H never returns ANY answer (and thus fails >>>>>>>>> to be a decider).
behavior of Px matches this pattern that correct and complete
x86 emulation of the input to H(Px,Px) by H would never reach
the "ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments
that H was called with.
(b) There are no instructions in Px that could possibly escape >>>>>>>> this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is
invoked.
Only if H never aborts. If H does abort, then Px(Px), whose
behavior exactly matches the CORRECT emulation of the input to
H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct x86 >>>>>> emulation of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
What "Future Tense".
input WOULD halt. If halt deciders reported what the behavior of its
input
DOES then like you said it would never report on non halting inputs.
All non-simulating halt deciders can only report on what their input
WOULD do and not what their input DOES because non-simulating halt
deciders are static rather than dynamic analyzers.
Would only in the sense of condition of testing, not time.
do in the future if they were executed.
Why?
There is no actual requirement to execute the machine, only know what
would happen if at some point we did do that execution either in the
past or the future.
They can never report on the non-halting behavior of what their inputs
did do in the past.
Why not?
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when >>>>>>>>>>>> the behavior of Px matches this pattern that correct and >>>>>>>>>>>> complete x86 emulation of the input to H(Px,Px) by H >>>>>>>>>>>> would never reach the "ret" instruction of Px:
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about >>>>>>>>>>>>>>> your H not analysing what its input actually does and >>>>>>>>>>>>>>> instead assuming that an input that calls H is always >>>>>>>>>>>>>>> pathological.
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500{
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine >>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state. >>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
A halt decider must compute the mapping from >>>>>>>>>>>>>>>>>>>>>> its inputs to an accept or reject state on the >>>>>>>>>>>>>>>>>>>>>> basis of the actual behavior of these actual >>>>>>>>>>>>>>>>>>>>>> inputs.
When a simulating halt decider rejects all >>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly >>>>>>>>>>>>>>>>>>>>>> detects [in a finite number of steps] that its >>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of its input >>>>>>>>>>>>>>>>>>>>>> would never reach [a] final state of this input >>>>>>>>>>>>>>>>>>>>>> then all [these] inputs (including pathological >>>>>>>>>>>>>>>>>>>>>> inputs) are decided correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08]
[00001100](01) 50 push eax //
push P [00001101](03) 8b4d08 mov >>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [00001104](01) 51 push
ecx // push P [00001105](05) e800feffff >>>>>>>>>>>>>>>>>>>> call 00000f0a // call H [0000110a](03) 83c408 >>>>>>>>>>>>>>>>>>>> add esp,+08 [0000110d](02) 85c0 >>>>>>>>>>>>>>>>>>>> test eax,eax [0000110f](02) 7402 jz
00001113 [00001111](02) ebfe jmp >>>>>>>>>>>>>>>>>>>> 00001111 [00001113](01) 5d pop ebp
[00001114](01) c3 ret >>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>> at:211ee2 ...[000010da][00211ece][00211ed2] 55 >>>>>>>>>>>>>>>>>>>> push ebp ...[000010db][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
...[000010dd][00211ece][00211ed2] 8b4508 mov >>>>>>>>>>>>>>>>>>>> eax,[ebp+08] ...[000010e0][00211eca][000010da] >>>>>>>>>>>>>>>>>>>> 50 push eax // push P
...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] >>>>>>>>>>>>>>>>>>>> 51 push ecx // push P
...[000010e5][00211ec2][000010ea] e820feffff >>>>>>>>>>>>>>>>>>>> call 00000f0a // call H Infinitely Recursive >>>>>>>>>>>>>>>>>>>> Simulation Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>>> will see that when H bases its halt status >>>>>>>>>>>>>>>>>>>> decision on whether or not its complete and >>>>>>>>>>>>>>>>>>>> correct x86 emulation of its input would ever >>>>>>>>>>>>>>>>>>>> reach the "ret" instruction of this input that H >>>>>>>>>>>>>>>>>>>> is correct to reject this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>>> void Px(u32 x)
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408
add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408
add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
Because it is an easily verified fact that the >>>>>>>>>>>>>>>> correct and complete x86 emulation of the input to >>>>>>>>>>>>>>>> H(P,P) by H would never reach the "ret" instruction >>>>>>>>>>>>>>>> of P and this is the criterion measure for H to >>>>>>>>>>>>>>>> reject its input how do you figure that H gets the >>>>>>>>>>>>>>>> wrong answer?
What I am saying is a logical tautology the same as >>>>>>>>>>>>>>>> when we know that X is a black cat then we know that >>>>>>>>>>>>>>>> X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and >>>>>>>>>>>>>> correct x86 emulation of its input would never reach >>>>>>>>>>>>>> the "ret" instruction of Px.
That is only true if H never returns ANY answer (and >>>>>>>>>>>>> thus fails to be a decider).
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same
arguments that H was called with.
(b) There are no instructions in Px that could possibly >>>>>>>>>>>> escape this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H >>>>>>>>>>>> is invoked.
Only if H never aborts. If H does abort, then Px(Px),
whose behavior exactly matches the CORRECT emulation of >>>>>>>>>>> the input to H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and
correct x86 emulation of the input to H(Px,Px) by H ever >>>>>>>>>> reach the "ret" instruction of Px.
You always change this question to a different question: >>>>>>>>>>
Does (present tense) the complete and correct x86 emulation >>>>>>>>>> of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
The complete and correct x86 emulation of the input to H(Px, >>>>>>>>> Px) should be to allow Px to halt, which is what Px is
defined to do:
You are doing the same thing Richard is doing, getting at
least one word of what I am saying incorrectly and then
rebutting the incorrect paraphrase. This is the strawman
error.
The complete and correct x86 emulation of the input to H(Px, >>>>>>>> Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px
would never reach its "ret" instruction. This seems to be
beyond your ordinary software engineering technical
competence.
saying Px doesn't halt. QED.
/Flibble
Every technically competent software engineer can easily
confirm that the correct and complete x86 emulation of the
input to H(Px,Px) by H would never reach the "ret" instruction
of Px.
That you can not understand this proves that you are not a
sufficiently technically competent software engineer on this
point. Very good COBOL programmers might never be able to
understand this.
To anyone that writes or maintains operating systems what I am
claiming would be as easy to verify as first grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
Get an operating system programmer to explain to you that the
correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction of Px. *This is totally
over your head*
It is like I am saying that we know that black carts are cats and
you disagree saying the a black cat might be some kind of dog.
My whole system is now wrapped in 131K zip file as a Visual
Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your logic.
First, by definition correct emulation of a program will match the
behavior of the program.
When you disagree with this precisely stated verified fact you are
either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px) by
H would never reach the "ret" instruction
When you disagree the the above precisely stated verified fact by
changing its words and showing that the changed words are not true
then between liar and incompetent you prove to be a liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 ...[000013eb][00102353][00000000] 50 push eax ...[000013ec][0010234f][00000427] 6827040000 push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 ...[000013f9][00102357][00000000] 33c0 xor eax,eax ...[000013fb][0010235b][00100000] 5d pop ebp ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction
On 6/19/2022 4:30 PM, Richard Damon wrote:
On 6/19/22 5:17 PM, olcott wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong
On Sun, 19 Jun 2022 14:17:42 -0500You are doing the same thing Richard is doing, getting at least >>>>>>>>> one
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the >>>>>>>>>>>>> behavior of Px matches this pattern that correct and complete >>>>>>>>>>>>> x86 emulation of the input to H(Px,Px) by H would never reach >>>>>>>>>>>>> the "ret" instruction of Px:
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500{
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine will >>>>>>>>>>>>>>>>>>>>>>> haltvoid Px(u32 x)
whenever it enters a final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>>>>>
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis of >>>>>>>>>>>>>>>>>>>>>>> the actual behavior of these actual inputs. >>>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a >>>>>>>>>>>>>>>>>>>>>>> finite number of steps] that its correct and >>>>>>>>>>>>>>>>>>>>>>> complete
simulation of its input would never reach [a] final >>>>>>>>>>>>>>>>>>>>>>> state of this input then all [these] inputs >>>>>>>>>>>>>>>>>>>>>>> (including pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08]
[00001100](01) 50 push eax // push
P [00001101](03) 8b4d08 mov ecx,[ebp+08]
[00001104](01) 51 push ecx // push
P [00001105](05) e800feffff call 00000f0a //
call H [0000110a](03) 83c408 add esp,+08
[0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>>>>>>>>>> [00001114](01) c3 ret >>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] 8b4508 >>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] ...[000010e0][00211eca][000010da] 50 >>>>>>>>>>>>>>>>>>>>> push eax // push P
...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 >>>>>>>>>>>>>>>>>>>>> push ecx // push P
...[000010e5][00211ec2][000010ea] e820feffff call >>>>>>>>>>>>>>>>>>>>> 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped
*All technically competent software engineers* will >>>>>>>>>>>>>>>>>>>>> see
that when H bases its halt status decision on whether >>>>>>>>>>>>>>>>>>>>> or not its complete and correct x86 emulation of its >>>>>>>>>>>>>>>>>>>>> input would ever reach the "ret" instruction of this >>>>>>>>>>>>>>>>>>>>> input that H is correct to reject this input. >>>>>>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>>>> void Px(u32 x)
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>> e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>>>>> correctly. QED.
/Flibble
Because it is an easily verified fact that the correct and >>>>>>>>>>>>>>>>> complete x86 emulation of the input to H(P,P) by H would >>>>>>>>>>>>>>>>> never reach the "ret" instruction of P and this is the >>>>>>>>>>>>>>>>> criterion measure for H to reject its input how do you >>>>>>>>>>>>>>>>> figure that H gets the wrong answer?
What I am saying is a logical tautology the same as >>>>>>>>>>>>>>>>> when we
know that X is a black cat then we know that X is a cat. >>>>>>>>>>>>>>>> We are talking about Px, not P. We are talking about your H >>>>>>>>>>>>>>>> not analysing what its input actually does and instead >>>>>>>>>>>>>>>> assuming that an input that calls H is always pathological. >>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>>> correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and >>>>>>>>>>>>>>> correct x86 emulation of its input would never reach the >>>>>>>>>>>>>>> "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus >>>>>>>>>>>>>> fails to be a decider).
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments >>>>>>>>>>>>> that H was called with.
(b) There are no instructions in Px that could possibly escape >>>>>>>>>>>>> this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is >>>>>>>>>>>>> invoked.
Only if H never aborts. If H does abort, then Px(Px), whose >>>>>>>>>>>> behavior exactly matches the CORRECT emulation of the input to >>>>>>>>>>>> H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct >>>>>>>>>>> x86 emulation of the input to H(Px,Px) by H ever reach the "ret" >>>>>>>>>>> instruction of Px.
You always change this question to a different question: >>>>>>>>>>>
Does (present tense) the complete and correct x86 emulation of >>>>>>>>>>> the input to H(Px,Px) by H ever reach the "ret" instruction of >>>>>>>>>>> Px.
The complete and correct x86 emulation of the input to H(Px, Px) >>>>>>>>>> should be to allow Px to halt, which is what Px is defined to do: >>>>>>>>>
word of what I am saying incorrectly and then rebutting the
incorrect paraphrase. This is the strawman error.
The complete and correct x86 emulation of the input to H(Px, Px) >>>>>>>>> BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px would >>>>>>>>> never reach its "ret" instruction. This seems to be beyond your >>>>>>>>> ordinary software engineering technical competence.
saying Px
doesn't halt. QED.
/Flibble
Every technically competent software engineer can easily confirm >>>>>>> that
the correct and complete x86 emulation of the input to H(Px,Px) by H >>>>>>> would never reach the "ret" instruction of Px.
That you can not understand this proves that you are not a
sufficiently technically competent software engineer on this point. >>>>>>> Very good COBOL programmers might never be able to understand this. >>>>>>>
To anyone that writes or maintains operating systems what I am
claiming would be as easy to verify as first grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp >>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly. >>>>>> QED.
/Flibble
Get an operating system programmer to explain to you that the
correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction of Px. *This is totally
over your head*
It is like I am saying that we know that black carts are cats and
you disagree saying the a black cat might be some kind of dog.
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
No, maybe you need an actual programmer to look at your logic.
First, by definition correct emulation of a program will match the
behavior of the program.
When you disagree with this precisely stated verified fact you are
either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction
When did you verify this statment for an H that returns 0?
When X is a cat then we know that X is an animal.
What if X is a white cat?
the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction
This is a truism thus remains true under all possible conditions.
On 6/19/2022 4:23 PM, Richard Damon wrote:
On 6/19/22 4:55 PM, olcott wrote:
On 6/19/2022 3:50 PM, Richard Damon wrote:
On 6/19/22 4:34 PM, olcott wrote:Halt deciders must always predict what their non-halting inputs would
On 6/19/2022 3:19 PM, Richard Damon wrote:
A halt decider must always correctly determine whether or not its
On 6/19/22 3:17 PM, olcott wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H not >>>>>>>>>>>> analysing what its input actually does and instead assuming >>>>>>>>>>>> that an
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will halt >>>>>>>>>>>>>>>>>>> whenever
it enters a final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>>> inputs to an
accept or reject state on the basis of the actual >>>>>>>>>>>>>>>>>>> behavior of
these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a >>>>>>>>>>>>>>>>>>> finite number
of steps] that its correct and complete simulation of >>>>>>>>>>>>>>>>>>> its
input would never reach [a] final state of this input >>>>>>>>>>>>>>>>>>> then all
[these] inputs (including pathological inputs) are >>>>>>>>>>>>>>>>>>> decided
correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add
esp,+08
...[000013eb][00102353][00000000] 50 push
eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08
...[000013f9][00102357][00000000] 33c0 xor
eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>>>>> correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H
[0000110a](03) 83c408 add esp,+08 >>>>>>>>>>>>>>>>> [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>>>>>> [00001114](01) c3 ret >>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp >>>>>>>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp
...[000010dd][00211ece][00211ed2] 8b4508 mov >>>>>>>>>>>>>>>>> eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push >>>>>>>>>>>>>>>>> eax //
push P ...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push >>>>>>>>>>>>>>>>> ecx // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>> e820feffff
call 00000f0a // call H Infinitely Recursive Simulation >>>>>>>>>>>>>>>>> Detected
Simulation Stopped
*All technically competent software engineers* will see >>>>>>>>>>>>>>>>> that
when H bases its halt status decision on whether or not >>>>>>>>>>>>>>>>> its
complete and correct x86 emulation of its input would >>>>>>>>>>>>>>>>> ever reach
the "ret" instruction of this input that H is correct >>>>>>>>>>>>>>>>> to reject
this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>>> esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>>> esp,+08
...[000013f9][00102357][00000000] 33c0 xor
eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>>> correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>> correctly.
QED.
/Flibble
Because it is an easily verified fact that the correct and >>>>>>>>>>>>> complete
x86 emulation of the input to H(P,P) by H would never reach >>>>>>>>>>>>> the "ret"
instruction of P and this is the criterion measure for H to >>>>>>>>>>>>> reject
its input how do you figure that H gets the wrong answer? >>>>>>>>>>>>>
What I am saying is a logical tautology the same as when we >>>>>>>>>>>>> know that
X is a black cat then we know that X is a cat.
input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>> correctly.
QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and
correct x86 emulation of its input would never reach the >>>>>>>>>>> "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus
fails to be a decider).
behavior of Px matches this pattern that correct and complete >>>>>>>>> x86 emulation of the input to H(Px,Px) by H would never reach >>>>>>>>> the "ret" instruction of Px:
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments >>>>>>>>> that H was called with.
(b) There are no instructions in Px that could possibly escape >>>>>>>>> this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is
invoked.
Only if H never aborts. If H does abort, then Px(Px), whose
behavior exactly matches the CORRECT emulation of the input to >>>>>>>> H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct
x86 emulation of the input to H(Px,Px) by H ever reach the "ret" >>>>>>> instruction of Px.
What "Future Tense".
input WOULD halt. If halt deciders reported what the behavior of
its input
DOES then like you said it would never report on non halting inputs. >>>>>
All non-simulating halt deciders can only report on what their input >>>>> WOULD do and not what their input DOES because non-simulating halt
deciders are static rather than dynamic analyzers.
Would only in the sense of condition of testing, not time.
do in the future if they were executed.
Why?
There is no actual requirement to execute the machine, only know what
would happen if at some point we did do that execution either in the
past or the future.
They can never report on the non-halting behavior of what their
inputs did do in the past.
Why not?
If they are simulating halt deciders they can
never report on
never report on
never report on
never report on
never report on
the non-halting behavior
the non-halting behavior
the non-halting behavior
the non-halting behavior
the non-halting behavior
of what their inputs did do in the past
of what their inputs did do in the past
of what their inputs did do in the past
of what their inputs did do in the past
of what their inputs did do in the past
Because as you have said 1000 times they would be
stuck simulating this non-halting input forever.
If they are not simulating halt deciders they can
never report on
never report on
never report on
never report on
never report on
the non-halting behavior
the non-halting behavior
the non-halting behavior
the non-halting behavior
the non-halting behavior
Because they are not even examining behavior they are
only static analyzers that do not look at dynamic behavior.
Therefore halt deciders can never report on the non-halting behavior of
what their inputs did do in the past.
Therefore halt deciders can never report on the non-halting behavior of
what their inputs did do in the past.
Therefore halt deciders can never report on the non-halting behavior of
what their inputs did do in the past.
Therefore halt deciders can never report on the non-halting behavior of
what their inputs did do in the past.
Therefore halt deciders can never report on the non-halting behavior of
what their inputs did do in the past.
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
On 2022-06-19 14:43, olcott wrote:
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
I see no link anywhere.
On 2022-06-19 14:43, olcott wrote:
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
I see no link anywhere.
André
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when >>>>>>>>>>>>>> the behavior of Px matches this pattern that correct and >>>>>>>>>>>>>> complete x86 emulation of the input to H(Px,Px) by H >>>>>>>>>>>>>> would never reach the "ret" instruction of Px:
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about >>>>>>>>>>>>>>>>> your H not analysing what its input actually does and >>>>>>>>>>>>>>>>> instead assuming that an input that calls H is always >>>>>>>>>>>>>>>>> pathological.
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500{
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine >>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state. >>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
A halt decider must compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>> its inputs to an accept or reject state on the >>>>>>>>>>>>>>>>>>>>>>>> basis of the actual behavior of these actual >>>>>>>>>>>>>>>>>>>>>>>> inputs.
When a simulating halt decider rejects all >>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly >>>>>>>>>>>>>>>>>>>>>>>> detects [in a finite number of steps] that its >>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of its input >>>>>>>>>>>>>>>>>>>>>>>> would never reach [a] final state of this input >>>>>>>>>>>>>>>>>>>>>>>> then all [these] inputs (including pathological >>>>>>>>>>>>>>>>>>>>>>>> inputs) are decided correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08]
[00001100](01) 50 push eax //
push P [00001101](03) 8b4d08 mov >>>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [00001104](01) 51 push
ecx // push P [00001105](05) e800feffff >>>>>>>>>>>>>>>>>>>>>> call 00000f0a // call H [0000110a](03) 83c408 >>>>>>>>>>>>>>>>>>>>>> add esp,+08 [0000110d](02) 85c0 >>>>>>>>>>>>>>>>>>>>>> test eax,eax [0000110f](02) 7402 jz
00001113 [00001111](02) ebfe jmp >>>>>>>>>>>>>>>>>>>>>> 00001111 [00001113](01) 5d pop ebp
[00001114](01) c3 ret >>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>> at:211ee2 ...[000010da][00211ece][00211ed2] 55 >>>>>>>>>>>>>>>>>>>>>> push ebp ...[000010db][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
...[000010dd][00211ece][00211ed2] 8b4508 mov >>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] ...[000010e0][00211eca][000010da] >>>>>>>>>>>>>>>>>>>>>> 50 push eax // push P
...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] >>>>>>>>>>>>>>>>>>>>>> 51 push ecx // push P
...[000010e5][00211ec2][000010ea] e820feffff >>>>>>>>>>>>>>>>>>>>>> call 00000f0a // call H Infinitely Recursive >>>>>>>>>>>>>>>>>>>>>> Simulation Detected Simulation Stopped >>>>>>>>>>>>>>>>>>>>>>
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>>>>> will see that when H bases its halt status >>>>>>>>>>>>>>>>>>>>>> decision on whether or not its complete and >>>>>>>>>>>>>>>>>>>>>> correct x86 emulation of its input would ever >>>>>>>>>>>>>>>>>>>>>> reach the "ret" instruction of this input that H >>>>>>>>>>>>>>>>>>>>>> is correct to reject this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>> void Px(u32 x)
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
Because it is an easily verified fact that the >>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input to >>>>>>>>>>>>>>>>>> H(P,P) by H would never reach the "ret" instruction >>>>>>>>>>>>>>>>>> of P and this is the criterion measure for H to >>>>>>>>>>>>>>>>>> reject its input how do you figure that H gets the >>>>>>>>>>>>>>>>>> wrong answer?
What I am saying is a logical tautology the same as >>>>>>>>>>>>>>>>>> when we know that X is a black cat then we know that >>>>>>>>>>>>>>>>>> X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>> ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and >>>>>>>>>>>>>>>> correct x86 emulation of its input would never reach >>>>>>>>>>>>>>>> the "ret" instruction of Px.
That is only true if H never returns ANY answer (and >>>>>>>>>>>>>>> thus fails to be a decider).
H knows its own machine address and on this basis: >>>>>>>>>>>>>> (a) H recognizes that Px is calling H with the same >>>>>>>>>>>>>> arguments that H was called with.
(b) There are no instructions in Px that could possibly >>>>>>>>>>>>>> escape this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H >>>>>>>>>>>>>> is invoked.
Only if H never aborts. If H does abort, then Px(Px), >>>>>>>>>>>>> whose behavior exactly matches the CORRECT emulation of >>>>>>>>>>>>> the input to H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and >>>>>>>>>>>> correct x86 emulation of the input to H(Px,Px) by H ever >>>>>>>>>>>> reach the "ret" instruction of Px.
You always change this question to a different question: >>>>>>>>>>>>
Does (present tense) the complete and correct x86 emulation >>>>>>>>>>>> of the input to H(Px,Px) by H ever reach the "ret"
instruction of Px.
The complete and correct x86 emulation of the input to H(Px, >>>>>>>>>>> Px) should be to allow Px to halt, which is what Px is
defined to do:
You are doing the same thing Richard is doing, getting at
least one word of what I am saying incorrectly and then
rebutting the incorrect paraphrase. This is the strawman
error.
The complete and correct x86 emulation of the input to H(Px, >>>>>>>>>> Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px >>>>>>>>>> would never reach its "ret" instruction. This seems to be
beyond your ordinary software engineering technical
competence.
saying Px doesn't halt. QED.
/Flibble
Every technically competent software engineer can easily
confirm that the correct and complete x86 emulation of the
input to H(Px,Px) by H would never reach the "ret" instruction >>>>>>>> of Px.
That you can not understand this proves that you are not a
sufficiently technically competent software engineer on this
point. Very good COBOL programmers might never be able to
understand this.
To anyone that writes or maintains operating systems what I am >>>>>>>> claiming would be as easy to verify as first grade arithmetic. >>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
Get an operating system programmer to explain to you that the
correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction of Px. *This is totally
over your head*
It is like I am saying that we know that black carts are cats and
you disagree saying the a black cat might be some kind of dog.
My whole system is now wrapped in 131K zip file as a Visual
Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your logic.
First, by definition correct emulation of a program will match the
behavior of the program.
When you disagree with this precisely stated verified fact you are
either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px) by
H would never reach the "ret" instruction
When you disagree the the above precisely stated verified fact by
changing its words and showing that the changed words are not true
then between liar and incompetent you prove to be a liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 ...[000013eb][00102353][00000000] 50 push eax ...[000013ec][0010234f][00000427] 6827040000 push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 ...[000013f9][00102357][00000000] 33c0 xor eax,eax ...[000013fb][0010235b][00100000] 5d pop ebp ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
On 6/19/22 5:34 PM, olcott wrote:
On 6/19/2022 4:23 PM, Richard Damon wrote:
On 6/19/22 4:55 PM, olcott wrote:
On 6/19/2022 3:50 PM, Richard Damon wrote:
On 6/19/22 4:34 PM, olcott wrote:Halt deciders must always predict what their non-halting inputs
On 6/19/2022 3:19 PM, Richard Damon wrote:
A halt decider must always correctly determine whether or not its
On 6/19/22 3:17 PM, olcott wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the >>>>>>>>>> behavior of Px matches this pattern that correct and complete >>>>>>>>>> x86 emulation of the input to H(Px,Px) by H would never reach >>>>>>>>>> the "ret" instruction of Px:
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your H >>>>>>>>>>>>> not
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote:
On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will >>>>>>>>>>>>>>>>>>>> halt whenever
it enters a final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>>
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>>>> inputs to an
accept or reject state on the basis of the actual >>>>>>>>>>>>>>>>>>>> behavior of
these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a >>>>>>>>>>>>>>>>>>>> finite number
of steps] that its correct and complete simulation >>>>>>>>>>>>>>>>>>>> of its
input would never reach [a] final state of this >>>>>>>>>>>>>>>>>>>> input then all
[these] inputs (including pathological inputs) are >>>>>>>>>>>>>>>>>>>> decided
correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add
esp,+08
...[000013eb][00102353][00000000] 50
push eax
...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>>>>>>>> push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>> call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08
...[000013f9][00102357][00000000] 33c0 xor
eax,eax
...[000013fb][0010235b][00100000] 5d pop
ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>> decided
correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H
[0000110a](03) 83c408 add esp,+08 >>>>>>>>>>>>>>>>>> [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>>>>>>> [00001114](01) c3 ret >>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov ebp,esp
...[000010dd][00211ece][00211ed2] 8b4508 mov >>>>>>>>>>>>>>>>>> eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push >>>>>>>>>>>>>>>>>> eax //
push P ...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push >>>>>>>>>>>>>>>>>> ecx // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>> e820feffff
call 00000f0a // call H Infinitely Recursive >>>>>>>>>>>>>>>>>> Simulation Detected
Simulation Stopped
*All technically competent software engineers* will >>>>>>>>>>>>>>>>>> see that
when H bases its halt status decision on whether or >>>>>>>>>>>>>>>>>> not its
complete and correct x86 emulation of its input would >>>>>>>>>>>>>>>>>> ever reach
the "ret" instruction of this input that H is correct >>>>>>>>>>>>>>>>>> to reject
this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add
esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08
...[000013f9][00102357][00000000] 33c0 xor
eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>>>> correctly. QED.
/Flibble
*All technically competent software engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>> esp,+08
...[000013f9][00102357][00000000] 33c0 xor
eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>> correctly.
QED.
/Flibble
Because it is an easily verified fact that the correct and >>>>>>>>>>>>>> complete
x86 emulation of the input to H(P,P) by H would never >>>>>>>>>>>>>> reach the "ret"
instruction of P and this is the criterion measure for H >>>>>>>>>>>>>> to reject
its input how do you figure that H gets the wrong answer? >>>>>>>>>>>>>>
What I am saying is a logical tautology the same as when >>>>>>>>>>>>>> we know that
X is a black cat then we know that X is a cat.
analysing what its input actually does and instead assuming >>>>>>>>>>>>> that an
input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>> correctly.
QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and >>>>>>>>>>>> correct x86 emulation of its input would never reach the >>>>>>>>>>>> "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus >>>>>>>>>>> fails to be a decider).
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments >>>>>>>>>> that H was called with.
(b) There are no instructions in Px that could possibly escape >>>>>>>>>> this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is >>>>>>>>>> invoked.
Only if H never aborts. If H does abort, then Px(Px), whose
behavior exactly matches the CORRECT emulation of the input to >>>>>>>>> H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct >>>>>>>> x86 emulation of the input to H(Px,Px) by H ever reach the "ret" >>>>>>>> instruction of Px.
What "Future Tense".
input WOULD halt. If halt deciders reported what the behavior of
its input
DOES then like you said it would never report on non halting inputs. >>>>>>
All non-simulating halt deciders can only report on what their input >>>>>> WOULD do and not what their input DOES because non-simulating halt >>>>>> deciders are static rather than dynamic analyzers.
Would only in the sense of condition of testing, not time.
would do in the future if they were executed.
Why?
There is no actual requirement to execute the machine, only know what
would happen if at some point we did do that execution either in the
past or the future.
They can never report on the non-halting behavior of what their
inputs did do in the past.
Why not?
If they are simulating halt deciders they can
never report on
never report on
never report on
never report on
never report on
the non-halting behavior
the non-halting behavior
the non-halting behavior
the non-halting behavior
the non-halting behavior
of what their inputs did do in the past
of what their inputs did do in the past
of what their inputs did do in the past
of what their inputs did do in the past
of what their inputs did do in the past
Because as you have said 1000 times they would be
stuck simulating this non-halting input forever.
If they are not simulating halt deciders they can
never report on
never report on
never report on
never report on
never report on
the non-halting behavior
the non-halting behavior
the non-halting behavior
the non-halting behavior
the non-halting behavior
Because they are not even examining behavior they are
only static analyzers that do not look at dynamic behavior.
Therefore halt deciders can never report on the non-halting behavior
of what their inputs did do in the past.
Therefore halt deciders can never report on the non-halting behavior
of what their inputs did do in the past.
Therefore halt deciders can never report on the non-halting behavior
of what their inputs did do in the past.
Therefore halt deciders can never report on the non-halting behavior
of what their inputs did do in the past.
Therefore halt deciders can never report on the non-halting behavior
of what their inputs did do in the past.
Regressing back to a two year old again I see.
Why can't H report on the behavior of what its input represents did in
the past?
On 6/19/2022 4:46 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong >>>>>>>>> saying Px doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when >>>>>>>>>>>>>> the behavior of Px matches this pattern that correct >>>>>>>>>>>>>> and complete x86 emulation of the input to H(Px,Px) by >>>>>>>>>>>>>> H would never reach the "ret" instruction of Px: >>>>>>>>>>>>>>
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500We are talking about Px, not P. We are talking about >>>>>>>>>>>>>>>>> your H not analysing what its input actually does >>>>>>>>>>>>>>>>> and instead assuming that an input that calls H is >>>>>>>>>>>>>>>>> always pathological.
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500 >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine >>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state. >>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234){
void Px(u32 x)
A halt decider must compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>> its inputs to an accept or reject state on >>>>>>>>>>>>>>>>>>>>>>>> the basis of the actual behavior of these >>>>>>>>>>>>>>>>>>>>>>>> actual inputs.
When a simulating halt decider rejects all >>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly >>>>>>>>>>>>>>>>>>>>>>>> detects [in a finite number of steps] that >>>>>>>>>>>>>>>>>>>>>>>> its correct and complete simulation of its >>>>>>>>>>>>>>>>>>>>>>>> input would never reach [a] final state of >>>>>>>>>>>>>>>>>>>>>>>> this input then all [these] inputs >>>>>>>>>>>>>>>>>>>>>>>> (including pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] >>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov >>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001100](01) 50 >>>>>>>>>>>>>>>>>>>>>> push eax // push P [00001101](03) >>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx >>>>>>>>>>>>>>>>>>>>>> // push P [00001105](05) e800feffff call >>>>>>>>>>>>>>>>>>>>>> 00000f0a // call H [0000110a](03) 83c408 add >>>>>>>>>>>>>>>>>>>>>> esp,+08 [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111
[00001113](01) 5d pop ebp >>>>>>>>>>>>>>>>>>>>>> [00001114](01) c3 ret Size in
bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>> at:211ee2 ...[000010da][00211ece][00211ed2] 55 >>>>>>>>>>>>>>>>>>>>>> push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push eax >>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e1][00211eca][000010da] >>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx >>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H Infinitely >>>>>>>>>>>>>>>>>>>>>> Recursive Simulation Detected Simulation >>>>>>>>>>>>>>>>>>>>>> Stopped
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>>>>> will see that when H bases its halt status >>>>>>>>>>>>>>>>>>>>>> decision on whether or not its complete and >>>>>>>>>>>>>>>>>>>>>> correct x86 emulation of its input would ever >>>>>>>>>>>>>>>>>>>>>> reach the "ret" instruction of this input that >>>>>>>>>>>>>>>>>>>>>> H is correct to reject this input. >>>>>>>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>> void Px(u32 x)
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
Because it is an easily verified fact that the >>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input to >>>>>>>>>>>>>>>>>> H(P,P) by H would never reach the "ret" instruction >>>>>>>>>>>>>>>>>> of P and this is the criterion measure for H to >>>>>>>>>>>>>>>>>> reject its input how do you figure that H gets the >>>>>>>>>>>>>>>>>> wrong answer?
What I am saying is a logical tautology the same as >>>>>>>>>>>>>>>>>> when we know that X is a black cat then we know >>>>>>>>>>>>>>>>>> that X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408
add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408
add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete >>>>>>>>>>>>>>>> and correct x86 emulation of its input would never >>>>>>>>>>>>>>>> reach the "ret" instruction of Px.
That is only true if H never returns ANY answer (and >>>>>>>>>>>>>>> thus fails to be a decider).
H knows its own machine address and on this basis: >>>>>>>>>>>>>> (a) H recognizes that Px is calling H with the same >>>>>>>>>>>>>> arguments that H was called with.
(b) There are no instructions in Px that could possibly >>>>>>>>>>>>>> escape this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to >>>>>>>>>>>>>> H is invoked.
Only if H never aborts. If H does abort, then Px(Px), >>>>>>>>>>>>> whose behavior exactly matches the CORRECT emulation of >>>>>>>>>>>>> the input to H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and >>>>>>>>>>>> correct x86 emulation of the input to H(Px,Px) by H ever >>>>>>>>>>>> reach the "ret" instruction of Px.
You always change this question to a different question: >>>>>>>>>>>>
Does (present tense) the complete and correct x86
emulation of the input to H(Px,Px) by H ever reach the >>>>>>>>>>>> "ret" instruction of Px.
The complete and correct x86 emulation of the input to >>>>>>>>>>> H(Px, Px) should be to allow Px to halt, which is what Px >>>>>>>>>>> is defined to do:
You are doing the same thing Richard is doing, getting at >>>>>>>>>> least one word of what I am saying incorrectly and then
rebutting the incorrect paraphrase. This is the strawman >>>>>>>>>> error.
The complete and correct x86 emulation of the input to
H(Px, Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px >>>>>>>>>> would never reach its "ret" instruction. This seems to be >>>>>>>>>> beyond your ordinary software engineering technical
competence.
/Flibble
Every technically competent software engineer can easily
confirm that the correct and complete x86 emulation of the
input to H(Px,Px) by H would never reach the "ret"
instruction of Px.
That you can not understand this proves that you are not a
sufficiently technically competent software engineer on this >>>>>>>> point. Very good COBOL programmers might never be able to
understand this.
To anyone that writes or maintains operating systems what I
am claiming would be as easy to verify as first grade
arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push
00000427 ---[000013f1][0010234f][00000427] e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
Get an operating system programmer to explain to you that the
correct and complete x86 emulation of the input to H(Px,Px) by
H would never reach the "ret" instruction of Px. *This is
totally over your head*
It is like I am saying that we know that black carts are cats
and you disagree saying the a black cat might be some kind of
dog.
My whole system is now wrapped in 131K zip file as a Visual
Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your logic.
First, by definition correct emulation of a program will match
the behavior of the program.
When you disagree with this precisely stated verified fact you
are either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px)
by H would never reach the "ret" instruction
When you disagree the the above precisely stated verified fact by
changing its words and showing that the changed words are not
true then between liar and incompetent you prove to be a liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px) by
H would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 ...[000013eb][00102353][00000000] 50 push eax ...[000013ec][0010234f][00000427] 6827040000 push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 ...[000013f9][00102357][00000000] 33c0 xor eax,eax ...[000013fb][0010235b][00100000] 5d pop ebp ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
You are not committing to a criterion measure of correctness thus
your claim is vague.
On Sun, 19 Jun 2022 17:16:03 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:46 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong >>>>>>>>>>> saying Px doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when >>>>>>>>>>>>>>>> the behavior of Px matches this pattern that correct >>>>>>>>>>>>>>>> and complete x86 emulation of the input to H(Px,Px) by >>>>>>>>>>>>>>>> H would never reach the "ret" instruction of Px: >>>>>>>>>>>>>>>>
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500We are talking about Px, not P. We are talking about >>>>>>>>>>>>>>>>>>> your H not analysing what its input actually does >>>>>>>>>>>>>>>>>>> and instead assuming that an input that calls H is >>>>>>>>>>>>>>>>>>> always pathological.
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine >>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state. >>>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234){
void Px(u32 x)
A halt decider must compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>> its inputs to an accept or reject state on >>>>>>>>>>>>>>>>>>>>>>>>>> the basis of the actual behavior of these >>>>>>>>>>>>>>>>>>>>>>>>>> actual inputs.
When a simulating halt decider rejects all >>>>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly >>>>>>>>>>>>>>>>>>>>>>>>>> detects [in a finite number of steps] that >>>>>>>>>>>>>>>>>>>>>>>>>> its correct and complete simulation of its >>>>>>>>>>>>>>>>>>>>>>>>>> input would never reach [a] final state of >>>>>>>>>>>>>>>>>>>>>>>>>> this input then all [these] inputs >>>>>>>>>>>>>>>>>>>>>>>>>> (including pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] >>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov >>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001100](01) 50 >>>>>>>>>>>>>>>>>>>>>>>> push eax // push P [00001101](03) >>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>> // push P [00001105](05) e800feffff call >>>>>>>>>>>>>>>>>>>>>>>> 00000f0a // call H [0000110a](03) 83c408 add >>>>>>>>>>>>>>>>>>>>>>>> esp,+08 [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111
[00001113](01) 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>> [00001114](01) c3 ret Size in
bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>> at:211ee2 ...[000010da][00211ece][00211ed2] 55 >>>>>>>>>>>>>>>>>>>>>>>> push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push eax >>>>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e1][00211eca][000010da] >>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H Infinitely >>>>>>>>>>>>>>>>>>>>>>>> Recursive Simulation Detected Simulation >>>>>>>>>>>>>>>>>>>>>>>> Stopped
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>>>>>>> will see that when H bases its halt status >>>>>>>>>>>>>>>>>>>>>>>> decision on whether or not its complete and >>>>>>>>>>>>>>>>>>>>>>>> correct x86 emulation of its input would ever >>>>>>>>>>>>>>>>>>>>>>>> reach the "ret" instruction of this input that >>>>>>>>>>>>>>>>>>>>>>>> H is correct to reject this input. >>>>>>>>>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>>>> void Px(u32 x)
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
Because it is an easily verified fact that the >>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input to >>>>>>>>>>>>>>>>>>>> H(P,P) by H would never reach the "ret" instruction >>>>>>>>>>>>>>>>>>>> of P and this is the criterion measure for H to >>>>>>>>>>>>>>>>>>>> reject its input how do you figure that H gets the >>>>>>>>>>>>>>>>>>>> wrong answer?
What I am saying is a logical tautology the same as >>>>>>>>>>>>>>>>>>>> when we know that X is a black cat then we know >>>>>>>>>>>>>>>>>>>> that X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete >>>>>>>>>>>>>>>>>> and correct x86 emulation of its input would never >>>>>>>>>>>>>>>>>> reach the "ret" instruction of Px.
That is only true if H never returns ANY answer (and >>>>>>>>>>>>>>>>> thus fails to be a decider).
H knows its own machine address and on this basis: >>>>>>>>>>>>>>>> (a) H recognizes that Px is calling H with the same >>>>>>>>>>>>>>>> arguments that H was called with.
(b) There are no instructions in Px that could possibly >>>>>>>>>>>>>>>> escape this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to >>>>>>>>>>>>>>>> H is invoked.
Only if H never aborts. If H does abort, then Px(Px), >>>>>>>>>>>>>>> whose behavior exactly matches the CORRECT emulation of >>>>>>>>>>>>>>> the input to H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and >>>>>>>>>>>>>> correct x86 emulation of the input to H(Px,Px) by H ever >>>>>>>>>>>>>> reach the "ret" instruction of Px.
You always change this question to a different question: >>>>>>>>>>>>>>
Does (present tense) the complete and correct x86
emulation of the input to H(Px,Px) by H ever reach the >>>>>>>>>>>>>> "ret" instruction of Px.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>> H(Px, Px) should be to allow Px to halt, which is what Px >>>>>>>>>>>>> is defined to do:
You are doing the same thing Richard is doing, getting at >>>>>>>>>>>> least one word of what I am saying incorrectly and then >>>>>>>>>>>> rebutting the incorrect paraphrase. This is the strawman >>>>>>>>>>>> error.
The complete and correct x86 emulation of the input to >>>>>>>>>>>> H(Px, Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px >>>>>>>>>>>> would never reach its "ret" instruction. This seems to be >>>>>>>>>>>> beyond your ordinary software engineering technical
competence.
/Flibble
Every technically competent software engineer can easily
confirm that the correct and complete x86 emulation of the >>>>>>>>>> input to H(Px,Px) by H would never reach the "ret"
instruction of Px.
That you can not understand this proves that you are not a >>>>>>>>>> sufficiently technically competent software engineer on this >>>>>>>>>> point. Very good COBOL programmers might never be able to
understand this.
To anyone that writes or maintains operating systems what I >>>>>>>>>> am claiming would be as easy to verify as first grade
arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push
00000427 ---[000013f1][0010234f][00000427] e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
Get an operating system programmer to explain to you that the
correct and complete x86 emulation of the input to H(Px,Px) by >>>>>>>> H would never reach the "ret" instruction of Px. *This is
totally over your head*
It is like I am saying that we know that black carts are cats
and you disagree saying the a black cat might be some kind of
dog.
My whole system is now wrapped in 131K zip file as a Visual
Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your logic.
First, by definition correct emulation of a program will match
the behavior of the program.
When you disagree with this precisely stated verified fact you
are either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px)
by H would never reach the "ret" instruction
When you disagree the the above precisely stated verified fact by
changing its words and showing that the changed words are not
true then between liar and incompetent you prove to be a liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px) by
H would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
You are not committing to a criterion measure of correctness thus
your claim is vague.
Vague? My "claim" is crystal clear: Px should ALWAYS HALT and your H
decides that it is non-halting.
/Flibble
On 6/19/2022 5:22 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 17:16:03 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:46 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong >>>>>>>>>>> saying Px doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:The question is: Would (future tense) the complete and >>>>>>>>>>>>>> correct x86 emulation of the input to H(Px,Px) by H >>>>>>>>>>>>>> ever reach the "ret" instruction of Px.
On 6/19/2022 1:20 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>> On 6/19/22 2:08 PM, olcott wrote:
Competent software engineers will understand that >>>>>>>>>>>>>>>> when the behavior of Px matches this pattern that >>>>>>>>>>>>>>>> correct and complete x86 emulation of the input to >>>>>>>>>>>>>>>> H(Px,Px) by H would never reach the "ret"On 6/19/2022 12:40 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500 >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine >>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state. >>>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)We are talking about Px, not P. We are talking >>>>>>>>>>>>>>>>>>> about your H not analysing what its input >>>>>>>>>>>>>>>>>>> actually does and instead assuming that an input >>>>>>>>>>>>>>>>>>> that calls H is always pathological.
void Px(u32 x)
A halt decider must compute the mapping >>>>>>>>>>>>>>>>>>>>>>>>>> from its inputs to an accept or reject >>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>> of these actual inputs.
When a simulating halt decider rejects all >>>>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly >>>>>>>>>>>>>>>>>>>>>>>>>> detects [in a finite number of steps] that >>>>>>>>>>>>>>>>>>>>>>>>>> its correct and complete simulation of its >>>>>>>>>>>>>>>>>>>>>>>>>> input would never reach [a] final state of >>>>>>>>>>>>>>>>>>>>>>>>>> this input then all [these] inputs >>>>>>>>>>>>>>>>>>>>>>>>>> (including pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov >>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001100](01) 50 >>>>>>>>>>>>>>>>>>>>>>>> push eax // push P [00001101](03) >>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx
// push P [00001105](05) e800feffff call >>>>>>>>>>>>>>>>>>>>>>>> 00000f0a // call H [0000110a](03) 83c408 >>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111
[00001113](01) 5d pop ebp
[00001114](01) c3 ret Size in
bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>> at:211ee2 ...[000010da][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push eax >>>>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e1][00211eca][000010da] >>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H Infinitely >>>>>>>>>>>>>>>>>>>>>>>> Recursive Simulation Detected Simulation >>>>>>>>>>>>>>>>>>>>>>>> Stopped
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>> engineers* will see that when H bases its >>>>>>>>>>>>>>>>>>>>>>>> halt status decision on whether or not its >>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its >>>>>>>>>>>>>>>>>>>>>>>> input would ever reach the "ret" instruction >>>>>>>>>>>>>>>>>>>>>>>> of this input that H is correct to reject >>>>>>>>>>>>>>>>>>>>>>>> this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] >>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
Because it is an easily verified fact that the >>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input >>>>>>>>>>>>>>>>>>>> to H(P,P) by H would never reach the "ret" >>>>>>>>>>>>>>>>>>>> instruction of P and this is the criterion >>>>>>>>>>>>>>>>>>>> measure for H to reject its input how do you >>>>>>>>>>>>>>>>>>>> figure that H gets the wrong answer? >>>>>>>>>>>>>>>>>>>>
What I am saying is a logical tautology the same >>>>>>>>>>>>>>>>>>>> as when we know that X is a black cat then we >>>>>>>>>>>>>>>>>>>> know that X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete >>>>>>>>>>>>>>>>>> and correct x86 emulation of its input would never >>>>>>>>>>>>>>>>>> reach the "ret" instruction of Px.
That is only true if H never returns ANY answer (and >>>>>>>>>>>>>>>>> thus fails to be a decider).
instruction of Px:
H knows its own machine address and on this basis: >>>>>>>>>>>>>>>> (a) H recognizes that Px is calling H with the same >>>>>>>>>>>>>>>> arguments that H was called with.
(b) There are no instructions in Px that could >>>>>>>>>>>>>>>> possibly escape this infinitely recursive emulation. >>>>>>>>>>>>>>>> (c) H aborts its emulation of Px before Px its call >>>>>>>>>>>>>>>> to H is invoked.
Only if H never aborts. If H does abort, then Px(Px), >>>>>>>>>>>>>>> whose behavior exactly matches the CORRECT emulation >>>>>>>>>>>>>>> of the input to H(Px,Px) BY DEFINITION shows this. >>>>>>>>>>>>>>
You always change this question to a different
question:
Does (present tense) the complete and correct x86 >>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H ever reach the >>>>>>>>>>>>>> "ret" instruction of Px.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>> H(Px, Px) should be to allow Px to halt, which is what >>>>>>>>>>>>> Px is defined to do:
You are doing the same thing Richard is doing, getting at >>>>>>>>>>>> least one word of what I am saying incorrectly and then >>>>>>>>>>>> rebutting the incorrect paraphrase. This is the strawman >>>>>>>>>>>> error.
The complete and correct x86 emulation of the input to >>>>>>>>>>>> H(Px, Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that >>>>>>>>>>>> Px would never reach its "ret" instruction. This seems >>>>>>>>>>>> to be beyond your ordinary software engineering technical >>>>>>>>>>>> competence.
/Flibble
Every technically competent software engineer can easily >>>>>>>>>> confirm that the correct and complete x86 emulation of the >>>>>>>>>> input to H(Px,Px) by H would never reach the "ret"
instruction of Px.
That you can not understand this proves that you are not a >>>>>>>>>> sufficiently technically competent software engineer on
this point. Very good COBOL programmers might never be
able to understand this.
To anyone that writes or maintains operating systems what I >>>>>>>>>> am claiming would be as easy to verify as first grade
arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
Get an operating system programmer to explain to you that the >>>>>>>> correct and complete x86 emulation of the input to H(Px,Px)
by H would never reach the "ret" instruction of Px. *This is >>>>>>>> totally over your head*
It is like I am saying that we know that black carts are cats >>>>>>>> and you disagree saying the a black cat might be some kind of >>>>>>>> dog.
My whole system is now wrapped in 131K zip file as a Visual
Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your logic. >>>>>>>
First, by definition correct emulation of a program will match >>>>>>> the behavior of the program.
When you disagree with this precisely stated verified fact you
are either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px)
by H would never reach the "ret" instruction
When you disagree the the above precisely stated verified fact
by changing its words and showing that the changed words are
not true then between liar and incompetent you prove to be a
liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px)
by H would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
You are not committing to a criterion measure of correctness thus
your claim is vague.
Vague? My "claim" is crystal clear: Px should ALWAYS HALT and your H decides that it is non-halting.
/Flibble
Flibble knows that he is so woefully incompetent that he refuses to
answer whether or not the following is true or false:
the correct and complete x86 emulation of the input to H(Px,Px) by
H would never reach the "ret" instruction
If one has no idea whether or not a statement is true or false and
they want to hide the fact that they have no idea then when
repeatedly pressed to provide an answer the best that they can
possibly do is continue to dodge the question.
it is no longer worth my time to continue to talk to you of Richard.
On Sun, 19 Jun 2022 17:16:03 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:46 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong >>>>>>>>>>> saying Px doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when >>>>>>>>>>>>>>>> the behavior of Px matches this pattern that correct >>>>>>>>>>>>>>>> and complete x86 emulation of the input to H(Px,Px) by >>>>>>>>>>>>>>>> H would never reach the "ret" instruction of Px: >>>>>>>>>>>>>>>>
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500We are talking about Px, not P. We are talking about >>>>>>>>>>>>>>>>>>> your H not analysing what its input actually does >>>>>>>>>>>>>>>>>>> and instead assuming that an input that calls H is >>>>>>>>>>>>>>>>>>> always pathological.
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine >>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state. >>>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234){
void Px(u32 x)
A halt decider must compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>> its inputs to an accept or reject state on >>>>>>>>>>>>>>>>>>>>>>>>>> the basis of the actual behavior of these >>>>>>>>>>>>>>>>>>>>>>>>>> actual inputs.
When a simulating halt decider rejects all >>>>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly >>>>>>>>>>>>>>>>>>>>>>>>>> detects [in a finite number of steps] that >>>>>>>>>>>>>>>>>>>>>>>>>> its correct and complete simulation of its >>>>>>>>>>>>>>>>>>>>>>>>>> input would never reach [a] final state of >>>>>>>>>>>>>>>>>>>>>>>>>> this input then all [these] inputs >>>>>>>>>>>>>>>>>>>>>>>>>> (including pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] >>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov >>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001100](01) 50 >>>>>>>>>>>>>>>>>>>>>>>> push eax // push P [00001101](03) >>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>> // push P [00001105](05) e800feffff call >>>>>>>>>>>>>>>>>>>>>>>> 00000f0a // call H [0000110a](03) 83c408 add >>>>>>>>>>>>>>>>>>>>>>>> esp,+08 [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111
[00001113](01) 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>> [00001114](01) c3 ret Size in
bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>> at:211ee2 ...[000010da][00211ece][00211ed2] 55 >>>>>>>>>>>>>>>>>>>>>>>> push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push eax >>>>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e1][00211eca][000010da] >>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H Infinitely >>>>>>>>>>>>>>>>>>>>>>>> Recursive Simulation Detected Simulation >>>>>>>>>>>>>>>>>>>>>>>> Stopped
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>>>>>>> will see that when H bases its halt status >>>>>>>>>>>>>>>>>>>>>>>> decision on whether or not its complete and >>>>>>>>>>>>>>>>>>>>>>>> correct x86 emulation of its input would ever >>>>>>>>>>>>>>>>>>>>>>>> reach the "ret" instruction of this input that >>>>>>>>>>>>>>>>>>>>>>>> H is correct to reject this input. >>>>>>>>>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>>>> void Px(u32 x)
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
Because it is an easily verified fact that the >>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input to >>>>>>>>>>>>>>>>>>>> H(P,P) by H would never reach the "ret" instruction >>>>>>>>>>>>>>>>>>>> of P and this is the criterion measure for H to >>>>>>>>>>>>>>>>>>>> reject its input how do you figure that H gets the >>>>>>>>>>>>>>>>>>>> wrong answer?
What I am saying is a logical tautology the same as >>>>>>>>>>>>>>>>>>>> when we know that X is a black cat then we know >>>>>>>>>>>>>>>>>>>> that X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete >>>>>>>>>>>>>>>>>> and correct x86 emulation of its input would never >>>>>>>>>>>>>>>>>> reach the "ret" instruction of Px.
That is only true if H never returns ANY answer (and >>>>>>>>>>>>>>>>> thus fails to be a decider).
H knows its own machine address and on this basis: >>>>>>>>>>>>>>>> (a) H recognizes that Px is calling H with the same >>>>>>>>>>>>>>>> arguments that H was called with.
(b) There are no instructions in Px that could possibly >>>>>>>>>>>>>>>> escape this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to >>>>>>>>>>>>>>>> H is invoked.
Only if H never aborts. If H does abort, then Px(Px), >>>>>>>>>>>>>>> whose behavior exactly matches the CORRECT emulation of >>>>>>>>>>>>>>> the input to H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and >>>>>>>>>>>>>> correct x86 emulation of the input to H(Px,Px) by H ever >>>>>>>>>>>>>> reach the "ret" instruction of Px.
You always change this question to a different question: >>>>>>>>>>>>>>
Does (present tense) the complete and correct x86
emulation of the input to H(Px,Px) by H ever reach the >>>>>>>>>>>>>> "ret" instruction of Px.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>> H(Px, Px) should be to allow Px to halt, which is what Px >>>>>>>>>>>>> is defined to do:
You are doing the same thing Richard is doing, getting at >>>>>>>>>>>> least one word of what I am saying incorrectly and then >>>>>>>>>>>> rebutting the incorrect paraphrase. This is the strawman >>>>>>>>>>>> error.
The complete and correct x86 emulation of the input to >>>>>>>>>>>> H(Px, Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that Px >>>>>>>>>>>> would never reach its "ret" instruction. This seems to be >>>>>>>>>>>> beyond your ordinary software engineering technical
competence.
/Flibble
Every technically competent software engineer can easily
confirm that the correct and complete x86 emulation of the >>>>>>>>>> input to H(Px,Px) by H would never reach the "ret"
instruction of Px.
That you can not understand this proves that you are not a >>>>>>>>>> sufficiently technically competent software engineer on this >>>>>>>>>> point. Very good COBOL programmers might never be able to
understand this.
To anyone that writes or maintains operating systems what I >>>>>>>>>> am claiming would be as easy to verify as first grade
arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push
00000427 ---[000013f1][0010234f][00000427] e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
Get an operating system programmer to explain to you that the
correct and complete x86 emulation of the input to H(Px,Px) by >>>>>>>> H would never reach the "ret" instruction of Px. *This is
totally over your head*
It is like I am saying that we know that black carts are cats
and you disagree saying the a black cat might be some kind of
dog.
My whole system is now wrapped in 131K zip file as a Visual
Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your logic.
First, by definition correct emulation of a program will match
the behavior of the program.
When you disagree with this precisely stated verified fact you
are either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px)
by H would never reach the "ret" instruction
When you disagree the the above precisely stated verified fact by
changing its words and showing that the changed words are not
true then between liar and incompetent you prove to be a liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px) by
H would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
You are not committing to a criterion measure of correctness thus
your claim is vague.
Vague? My "claim" is crystal clear: Px should ALWAYS HALT and your H
decides that it is non-halting.
/Flibble
On 6/19/22 6:22 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 17:16:03 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:46 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong >>>>>>>>>>> saying Px doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:The question is: Would (future tense) the complete and >>>>>>>>>>>>>> correct x86 emulation of the input to H(Px,Px) by H >>>>>>>>>>>>>> ever reach the "ret" instruction of Px.
On 6/19/2022 1:20 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>> On 6/19/22 2:08 PM, olcott wrote:
Competent software engineers will understand that >>>>>>>>>>>>>>>> when the behavior of Px matches this pattern that >>>>>>>>>>>>>>>> correct and complete x86 emulation of the input to >>>>>>>>>>>>>>>> H(Px,Px) by H would never reach the "ret"On 6/19/2022 12:40 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500 >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine >>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state. >>>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)We are talking about Px, not P. We are talking >>>>>>>>>>>>>>>>>>> about your H not analysing what its input >>>>>>>>>>>>>>>>>>> actually does and instead assuming that an input >>>>>>>>>>>>>>>>>>> that calls H is always pathological.
void Px(u32 x)
A halt decider must compute the mapping >>>>>>>>>>>>>>>>>>>>>>>>>> from its inputs to an accept or reject >>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>> of these actual inputs.
When a simulating halt decider rejects all >>>>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly >>>>>>>>>>>>>>>>>>>>>>>>>> detects [in a finite number of steps] that >>>>>>>>>>>>>>>>>>>>>>>>>> its correct and complete simulation of its >>>>>>>>>>>>>>>>>>>>>>>>>> input would never reach [a] final state of >>>>>>>>>>>>>>>>>>>>>>>>>> this input then all [these] inputs >>>>>>>>>>>>>>>>>>>>>>>>>> (including pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov >>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001100](01) 50 >>>>>>>>>>>>>>>>>>>>>>>> push eax // push P [00001101](03) >>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx
// push P [00001105](05) e800feffff call >>>>>>>>>>>>>>>>>>>>>>>> 00000f0a // call H [0000110a](03) 83c408 >>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111
[00001113](01) 5d pop ebp
[00001114](01) c3 ret Size in
bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>> at:211ee2 ...[000010da][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push eax >>>>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e1][00211eca][000010da] >>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H Infinitely >>>>>>>>>>>>>>>>>>>>>>>> Recursive Simulation Detected Simulation >>>>>>>>>>>>>>>>>>>>>>>> Stopped
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>> engineers* will see that when H bases its >>>>>>>>>>>>>>>>>>>>>>>> halt status decision on whether or not its >>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its >>>>>>>>>>>>>>>>>>>>>>>> input would ever reach the "ret" instruction >>>>>>>>>>>>>>>>>>>>>>>> of this input that H is correct to reject >>>>>>>>>>>>>>>>>>>>>>>> this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] >>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
Because it is an easily verified fact that the >>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input >>>>>>>>>>>>>>>>>>>> to H(P,P) by H would never reach the "ret" >>>>>>>>>>>>>>>>>>>> instruction of P and this is the criterion >>>>>>>>>>>>>>>>>>>> measure for H to reject its input how do you >>>>>>>>>>>>>>>>>>>> figure that H gets the wrong answer? >>>>>>>>>>>>>>>>>>>>
What I am saying is a logical tautology the same >>>>>>>>>>>>>>>>>>>> as when we know that X is a black cat then we >>>>>>>>>>>>>>>>>>>> know that X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete >>>>>>>>>>>>>>>>>> and correct x86 emulation of its input would never >>>>>>>>>>>>>>>>>> reach the "ret" instruction of Px.
That is only true if H never returns ANY answer (and >>>>>>>>>>>>>>>>> thus fails to be a decider).
instruction of Px:
H knows its own machine address and on this basis: >>>>>>>>>>>>>>>> (a) H recognizes that Px is calling H with the same >>>>>>>>>>>>>>>> arguments that H was called with.
(b) There are no instructions in Px that could >>>>>>>>>>>>>>>> possibly escape this infinitely recursive emulation. >>>>>>>>>>>>>>>> (c) H aborts its emulation of Px before Px its call >>>>>>>>>>>>>>>> to H is invoked.
Only if H never aborts. If H does abort, then Px(Px), >>>>>>>>>>>>>>> whose behavior exactly matches the CORRECT emulation >>>>>>>>>>>>>>> of the input to H(Px,Px) BY DEFINITION shows this. >>>>>>>>>>>>>>
You always change this question to a different
question:
Does (present tense) the complete and correct x86 >>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H ever reach the >>>>>>>>>>>>>> "ret" instruction of Px.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>> H(Px, Px) should be to allow Px to halt, which is what >>>>>>>>>>>>> Px is defined to do:
You are doing the same thing Richard is doing, getting at >>>>>>>>>>>> least one word of what I am saying incorrectly and then >>>>>>>>>>>> rebutting the incorrect paraphrase. This is the strawman >>>>>>>>>>>> error.
The complete and correct x86 emulation of the input to >>>>>>>>>>>> H(Px, Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that >>>>>>>>>>>> Px would never reach its "ret" instruction. This seems >>>>>>>>>>>> to be beyond your ordinary software engineering technical >>>>>>>>>>>> competence.
/Flibble
Every technically competent software engineer can easily >>>>>>>>>> confirm that the correct and complete x86 emulation of the >>>>>>>>>> input to H(Px,Px) by H would never reach the "ret"
instruction of Px.
That you can not understand this proves that you are not a >>>>>>>>>> sufficiently technically competent software engineer on
this point. Very good COBOL programmers might never be
able to understand this.
To anyone that writes or maintains operating systems what I >>>>>>>>>> am claiming would be as easy to verify as first grade
arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
Get an operating system programmer to explain to you that the >>>>>>>> correct and complete x86 emulation of the input to H(Px,Px)
by H would never reach the "ret" instruction of Px. *This is >>>>>>>> totally over your head*
It is like I am saying that we know that black carts are cats >>>>>>>> and you disagree saying the a black cat might be some kind of >>>>>>>> dog.
My whole system is now wrapped in 131K zip file as a Visual
Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your logic. >>>>>>>
First, by definition correct emulation of a program will match >>>>>>> the behavior of the program.
When you disagree with this precisely stated verified fact you
are either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px)
by H would never reach the "ret" instruction
When you disagree the the above precisely stated verified fact
by changing its words and showing that the changed words are
not true then between liar and incompetent you prove to be a
liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px)
by H would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
You are not committing to a criterion measure of correctness thus
your claim is vague.
Vague? My "claim" is crystal clear: Px should ALWAYS HALT and your H decides that it is non-halting.
/Flibble
Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return because
it gets stuck in an infinite loop, then Px(Px) doesn't Halt.
Now, this H fails to be a decider, so can't be a counter example for
a Halt Decider.
On 6/19/2022 4:56 PM, Richard Damon wrote:
On 6/19/22 5:34 PM, olcott wrote:
On 6/19/2022 4:23 PM, Richard Damon wrote:
On 6/19/22 4:55 PM, olcott wrote:
On 6/19/2022 3:50 PM, Richard Damon wrote:
On 6/19/22 4:34 PM, olcott wrote:Halt deciders must always predict what their non-halting inputs
On 6/19/2022 3:19 PM, Richard Damon wrote:
A halt decider must always correctly determine whether or not its >>>>>>> input WOULD halt. If halt deciders reported what the behavior of >>>>>>> its input
On 6/19/22 3:17 PM, olcott wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote:
On 6/19/22 2:08 PM, olcott wrote:Competent software engineers will understand that when the >>>>>>>>>>> behavior of Px matches this pattern that correct and complete >>>>>>>>>>> x86 emulation of the input to H(Px,Px) by H would never reach >>>>>>>>>>> the "ret" instruction of Px:
On 6/19/2022 12:40 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote:We are talking about Px, not P. We are talking about your >>>>>>>>>>>>>> H not
On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 11:01 AM, Mr Flibble wrote:{
On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:
computation that halts … the Turing machine will >>>>>>>>>>>>>>>>>>>>> halt whenever
it enters a final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>>>
A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>>>>> inputs to an
accept or reject state on the basis of the actual >>>>>>>>>>>>>>>>>>>>> behavior of
these actual inputs.
When a simulating halt decider rejects all inputs as >>>>>>>>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a >>>>>>>>>>>>>>>>>>>>> finite number
of steps] that its correct and complete simulation >>>>>>>>>>>>>>>>>>>>> of its
input would never reach [a] final state of this >>>>>>>>>>>>>>>>>>>>> input then all
[these] inputs (including pathological inputs) are >>>>>>>>>>>>>>>>>>>>> decided
correctly.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push eax >>>>>>>>>>>>>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>>> xor eax,eax
...[000013fb][0010235b][00100000] 5d
pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>>> decided
correctly. QED.
/Flibble
_P()
[000010fa](01) 55 push ebp >>>>>>>>>>>>>>>>>>> [000010fb](02) 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>> [00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H
[0000110a](03) 83c408 add esp,+08 >>>>>>>>>>>>>>>>>>> [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113 >>>>>>>>>>>>>>>>>>> [00001111](02) ebfe jmp 00001111 >>>>>>>>>>>>>>>>>>> [00001113](01) 5d pop ebp >>>>>>>>>>>>>>>>>>> [00001114](01) c3 ret >>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored at:211ee2 >>>>>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov ebp,esp
...[000010dd][00211ece][00211ed2] 8b4508 mov >>>>>>>>>>>>>>>>>>> eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push >>>>>>>>>>>>>>>>>>> eax //
push P ...[000010e1][00211eca][000010da] 8b4d08 mov >>>>>>>>>>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push >>>>>>>>>>>>>>>>>>> ecx // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>> e820feffff
call 00000f0a // call H Infinitely Recursive >>>>>>>>>>>>>>>>>>> Simulation Detected
Simulation Stopped
*All technically competent software engineers* will >>>>>>>>>>>>>>>>>>> see that
when H bases its halt status decision on whether or >>>>>>>>>>>>>>>>>>> not its
complete and correct x86 emulation of its input would >>>>>>>>>>>>>>>>>>> ever reach
the "ret" instruction of this input that H is correct >>>>>>>>>>>>>>>>>>> to reject
this input.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add
esp,+08
...[000013eb][00102353][00000000] 50 push
eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08
...[000013f9][00102357][00000000] 33c0 xor
eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>>>>>> correctly. QED.
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>> void Px(u32 x)
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>>>>> esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>>>>> esp,+08
...[000013f9][00102357][00000000] 33c0 xor
eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>> decided correctly.
QED.
/Flibble
Because it is an easily verified fact that the correct >>>>>>>>>>>>>>> and complete
x86 emulation of the input to H(P,P) by H would never >>>>>>>>>>>>>>> reach the "ret"
instruction of P and this is the criterion measure for H >>>>>>>>>>>>>>> to reject
its input how do you figure that H gets the wrong answer? >>>>>>>>>>>>>>>
What I am saying is a logical tautology the same as when >>>>>>>>>>>>>>> we know that
X is a black cat then we know that X is a cat.
analysing what its input actually does and instead >>>>>>>>>>>>>> assuming that an
input that calls H is always pathological.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push >>>>>>>>>>>>>> 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>> 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>>> correctly.
QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete and >>>>>>>>>>>>> correct x86 emulation of its input would never reach the >>>>>>>>>>>>> "ret" instruction of Px.
That is only true if H never returns ANY answer (and thus >>>>>>>>>>>> fails to be a decider).
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments >>>>>>>>>>> that H was called with.
(b) There are no instructions in Px that could possibly
escape this infinitely recursive emulation.
(c) H aborts its emulation of Px before Px its call to H is >>>>>>>>>>> invoked.
Only if H never aborts. If H does abort, then Px(Px), whose >>>>>>>>>> behavior exactly matches the CORRECT emulation of the input to >>>>>>>>>> H(Px,Px) BY DEFINITION shows this.
The question is: Would (future tense) the complete and correct >>>>>>>>> x86 emulation of the input to H(Px,Px) by H ever reach the
"ret" instruction of Px.
What "Future Tense".
DOES then like you said it would never report on non halting inputs. >>>>>>>
All non-simulating halt deciders can only report on what their input >>>>>>> WOULD do and not what their input DOES because non-simulating halt >>>>>>> deciders are static rather than dynamic analyzers.
Would only in the sense of condition of testing, not time.
would do in the future if they were executed.
Why?
There is no actual requirement to execute the machine, only know
what would happen if at some point we did do that execution either
in the past or the future.
They can never report on the non-halting behavior of what their
inputs did do in the past.
Why not?
If they are simulating halt deciders they can
never report on
never report on
never report on
never report on
never report on
the non-halting behavior
the non-halting behavior
the non-halting behavior
the non-halting behavior
the non-halting behavior
of what their inputs did do in the past
of what their inputs did do in the past
of what their inputs did do in the past
of what their inputs did do in the past
of what their inputs did do in the past
Because as you have said 1000 times they would be
stuck simulating this non-halting input forever.
If they are not simulating halt deciders they can
never report on
never report on
never report on
never report on
never report on
the non-halting behavior
the non-halting behavior
the non-halting behavior
the non-halting behavior
the non-halting behavior
Because they are not even examining behavior they are
only static analyzers that do not look at dynamic behavior.
Therefore halt deciders can never report on the non-halting behavior
of what their inputs did do in the past.
Therefore halt deciders can never report on the non-halting behavior
of what their inputs did do in the past.
Therefore halt deciders can never report on the non-halting behavior
of what their inputs did do in the past.
Therefore halt deciders can never report on the non-halting behavior
of what their inputs did do in the past.
Therefore halt deciders can never report on the non-halting behavior
of what their inputs did do in the past.
Regressing back to a two year old again I see.
That I have to tell you the same thing hundreds and hundreds of times
before you notice that I said it once is best handled by plonking you.
Why can't H report on the behavior of what its input represents did in
the past?
On Sun, 19 Jun 2022 18:53:36 -0400
Richard Damon <Richard@Damon-Family.org> wrote:
On 6/19/22 6:22 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 17:16:03 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:46 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong >>>>>>>>>>>>> saying Px doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:The question is: Would (future tense) the complete and >>>>>>>>>>>>>>>> correct x86 emulation of the input to H(Px,Px) by H >>>>>>>>>>>>>>>> ever reach the "ret" instruction of Px.
On 6/19/2022 1:20 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/19/22 2:08 PM, olcott wrote:
Competent software engineers will understand that >>>>>>>>>>>>>>>>>> when the behavior of Px matches this pattern that >>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input to >>>>>>>>>>>>>>>>>> H(Px,Px) by H would never reach the "ret"On 6/19/2022 12:40 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine >>>>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)We are talking about Px, not P. We are talking >>>>>>>>>>>>>>>>>>>>> about your H not analysing what its input >>>>>>>>>>>>>>>>>>>>> actually does and instead assuming that an input >>>>>>>>>>>>>>>>>>>>> that calls H is always pathological. >>>>>>>>>>>>>>>>>>>>>
void Px(u32 x)
A halt decider must compute the mapping >>>>>>>>>>>>>>>>>>>>>>>>>>>> from its inputs to an accept or reject >>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>> of these actual inputs. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects all >>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>> detects [in a finite number of steps] that >>>>>>>>>>>>>>>>>>>>>>>>>>>> its correct and complete simulation of its >>>>>>>>>>>>>>>>>>>>>>>>>>>> input would never reach [a] final state of >>>>>>>>>>>>>>>>>>>>>>>>>>>> this input then all [these] inputs >>>>>>>>>>>>>>>>>>>>>>>>>>>> (including pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427 >>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov >>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001100](01) 50 >>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P [00001101](03) >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx
// push P [00001105](05) e800feffff call >>>>>>>>>>>>>>>>>>>>>>>>>> 00000f0a // call H [0000110a](03) 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111
[00001113](01) 5d pop ebp
[00001114](01) c3 ret Size in
bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>> at:211ee2 ...[000010da][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push eax >>>>>>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e1][00211eca][000010da] >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H Infinitely >>>>>>>>>>>>>>>>>>>>>>>>>> Recursive Simulation Detected Simulation >>>>>>>>>>>>>>>>>>>>>>>>>> Stopped
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>>>> engineers* will see that when H bases its >>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision on whether or not its >>>>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its >>>>>>>>>>>>>>>>>>>>>>>>>> input would ever reach the "ret" instruction >>>>>>>>>>>>>>>>>>>>>>>>>> of this input that H is correct to reject >>>>>>>>>>>>>>>>>>>>>>>>>> this input.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>> return;
}
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] >>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
Because it is an easily verified fact that the >>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input >>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H would never reach the "ret" >>>>>>>>>>>>>>>>>>>>>> instruction of P and this is the criterion >>>>>>>>>>>>>>>>>>>>>> measure for H to reject its input how do you >>>>>>>>>>>>>>>>>>>>>> figure that H gets the wrong answer? >>>>>>>>>>>>>>>>>>>>>>
What I am saying is a logical tautology the same >>>>>>>>>>>>>>>>>>>>>> as when we know that X is a black cat then we >>>>>>>>>>>>>>>>>>>>>> know that X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete >>>>>>>>>>>>>>>>>>>> and correct x86 emulation of its input would never >>>>>>>>>>>>>>>>>>>> reach the "ret" instruction of Px.
That is only true if H never returns ANY answer (and >>>>>>>>>>>>>>>>>>> thus fails to be a decider).
instruction of Px:
H knows its own machine address and on this basis: >>>>>>>>>>>>>>>>>> (a) H recognizes that Px is calling H with the same >>>>>>>>>>>>>>>>>> arguments that H was called with.
(b) There are no instructions in Px that could >>>>>>>>>>>>>>>>>> possibly escape this infinitely recursive emulation. >>>>>>>>>>>>>>>>>> (c) H aborts its emulation of Px before Px its call >>>>>>>>>>>>>>>>>> to H is invoked.
Only if H never aborts. If H does abort, then Px(Px), >>>>>>>>>>>>>>>>> whose behavior exactly matches the CORRECT emulation >>>>>>>>>>>>>>>>> of the input to H(Px,Px) BY DEFINITION shows this. >>>>>>>>>>>>>>>>
You always change this question to a different >>>>>>>>>>>>>>>> question:
Does (present tense) the complete and correct x86 >>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H ever reach the >>>>>>>>>>>>>>>> "ret" instruction of Px.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>>>> H(Px, Px) should be to allow Px to halt, which is what >>>>>>>>>>>>>>> Px is defined to do:
You are doing the same thing Richard is doing, getting at >>>>>>>>>>>>>> least one word of what I am saying incorrectly and then >>>>>>>>>>>>>> rebutting the incorrect paraphrase. This is the strawman >>>>>>>>>>>>>> error.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>>> H(Px, Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that >>>>>>>>>>>>>> Px would never reach its "ret" instruction. This seems >>>>>>>>>>>>>> to be beyond your ordinary software engineering technical >>>>>>>>>>>>>> competence.
/Flibble
Every technically competent software engineer can easily >>>>>>>>>>>> confirm that the correct and complete x86 emulation of the >>>>>>>>>>>> input to H(Px,Px) by H would never reach the "ret"
instruction of Px.
That you can not understand this proves that you are not a >>>>>>>>>>>> sufficiently technically competent software engineer on >>>>>>>>>>>> this point. Very good COBOL programmers might never be >>>>>>>>>>>> able to understand this.
To anyone that writes or maintains operating systems what I >>>>>>>>>>>> am claiming would be as easy to verify as first grade
arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly. QED.
/Flibble
Get an operating system programmer to explain to you that the >>>>>>>>>> correct and complete x86 emulation of the input to H(Px,Px) >>>>>>>>>> by H would never reach the "ret" instruction of Px. *This is >>>>>>>>>> totally over your head*
It is like I am saying that we know that black carts are cats >>>>>>>>>> and you disagree saying the a black cat might be some kind of >>>>>>>>>> dog.
My whole system is now wrapped in 131K zip file as a Visual >>>>>>>>>> Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your logic. >>>>>>>>>
First, by definition correct emulation of a program will match >>>>>>>>> the behavior of the program.
When you disagree with this precisely stated verified fact you >>>>>>>> are either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px) >>>>>>>> by H would never reach the "ret" instruction
When you disagree the the above precisely stated verified fact >>>>>>>> by changing its words and showing that the changed words are
not true then between liar and incompetent you prove to be a
liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px)
by H would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
You are not committing to a criterion measure of correctness thus
your claim is vague.
Vague? My "claim" is crystal clear: Px should ALWAYS HALT and your H
decides that it is non-halting.
/Flibble
Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return because
it gets stuck in an infinite loop, then Px(Px) doesn't Halt.
Now, this H fails to be a decider, so can't be a counter example for
a Halt Decider.
If H is a valid halt decider (and by that I mean returns an answer in
finite time) then Px *will* always halt: it doesn't because Olcott's H
is not a valid halt decider.
/Flibble
When you disagree with this precisely stated verified fact you are
either a liar or incompetent:
On 6/19/2022 5:58 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 18:53:36 -0400
Richard Damon <Richard@Damon-Family.org> wrote:
On 6/19/22 6:22 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 17:16:03 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:46 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer >>>>>>>>>>>>> wrong saying Px doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>> On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/19/22 2:08 PM, olcott wrote:
Competent software engineers will understand that >>>>>>>>>>>>>>>>>> when the behavior of Px matches this pattern that >>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input to >>>>>>>>>>>>>>>>>> H(Px,Px) by H would never reach the "ret" >>>>>>>>>>>>>>>>>> instruction of Px:On 6/19/2022 12:40 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500 >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing >>>>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a >>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>>>>>>>>>>That is only true if H never returns ANY answer >>>>>>>>>>>>>>>>>>> (and thus fails to be a decider).
We are talking about Px, not P. We are talking >>>>>>>>>>>>>>>>>>>>> about your H not analysing what its input >>>>>>>>>>>>>>>>>>>>> actually does and instead assuming that an input >>>>>>>>>>>>>>>>>>>>> that calls H is always pathological. >>>>>>>>>>>>>>>>>>>>>void Px(u32 x)void Px(u32 x)A halt decider must compute the mapping >>>>>>>>>>>>>>>>>>>>>>>>>>>> from its inputs to an accept or reject >>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>> of these actual inputs. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects >>>>>>>>>>>>>>>>>>>>>>>>>>>> all inputs as non-halting whenever it >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly detects [in a finite number of >>>>>>>>>>>>>>>>>>>>>>>>>>>> steps] that its correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never >>>>>>>>>>>>>>>>>>>>>>>>>>>> reach [a] final state of this input then >>>>>>>>>>>>>>>>>>>>>>>>>>>> all [these] inputs (including >>>>>>>>>>>>>>>>>>>>>>>>>>>> pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); } >>>>>>>>>>>>>>>>>>>>>>>>>>>
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427 >>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has >>>>>>>>>>>>>>>>>>>>>>>>>>> not been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov >>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001100](01) 50 >>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P [00001101](03) >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx
// push P [00001105](05) e800feffff call >>>>>>>>>>>>>>>>>>>>>>>>>> 00000f0a // call H [0000110a](03) 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 [0000110d](02) 85c0 test >>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax [0000110f](02) 7402 jz
00001113 [00001111](02) ebfe >>>>>>>>>>>>>>>>>>>>>>>>>> jmp 00001111 [00001113](01) 5d >>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001114](01) c3 >>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [00001114] >>>>>>>>>>>>>>>>>>>>>>>>>>
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>> at:211ee2 ...[000010da][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>> eax // push P
...[000010e1][00211eca][000010da] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H >>>>>>>>>>>>>>>>>>>>>>>>>> Infinitely Recursive Simulation Detected >>>>>>>>>>>>>>>>>>>>>>>>>> Simulation Stopped
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>>>> engineers* will see that when H bases its >>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision on whether or not its >>>>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its >>>>>>>>>>>>>>>>>>>>>>>>>> input would ever reach the "ret" >>>>>>>>>>>>>>>>>>>>>>>>>> instruction of this input that H is >>>>>>>>>>>>>>>>>>>>>>>>>> correct to reject this input. >>>>>>>>>>>>>>>>>>>>>>>>>
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>> engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] >>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
Because it is an easily verified fact that the >>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input >>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H would never reach the "ret" >>>>>>>>>>>>>>>>>>>>>> instruction of P and this is the criterion >>>>>>>>>>>>>>>>>>>>>> measure for H to reject its input how do you >>>>>>>>>>>>>>>>>>>>>> figure that H gets the wrong answer? >>>>>>>>>>>>>>>>>>>>>>
What I am saying is a logical tautology the >>>>>>>>>>>>>>>>>>>>>> same as when we know that X is a black cat >>>>>>>>>>>>>>>>>>>>>> then we know that X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the >>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its input >>>>>>>>>>>>>>>>>>>> would never reach the "ret" instruction of Px. >>>>>>>>>>>>>>>>>>>
H knows its own machine address and on this basis: >>>>>>>>>>>>>>>>>> (a) H recognizes that Px is calling H with the same >>>>>>>>>>>>>>>>>> arguments that H was called with.
(b) There are no instructions in Px that could >>>>>>>>>>>>>>>>>> possibly escape this infinitely recursive >>>>>>>>>>>>>>>>>> emulation. (c) H aborts its emulation of Px before >>>>>>>>>>>>>>>>>> Px its call to H is invoked.
Only if H never aborts. If H does abort, then >>>>>>>>>>>>>>>>> Px(Px), whose behavior exactly matches the CORRECT >>>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) BY DEFINITION >>>>>>>>>>>>>>>>> shows this.
The question is: Would (future tense) the complete >>>>>>>>>>>>>>>> and correct x86 emulation of the input to H(Px,Px) >>>>>>>>>>>>>>>> by H ever reach the "ret" instruction of Px. >>>>>>>>>>>>>>>>
You always change this question to a different >>>>>>>>>>>>>>>> question:
Does (present tense) the complete and correct x86 >>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H ever reach >>>>>>>>>>>>>>>> the "ret" instruction of Px.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>>>> H(Px, Px) should be to allow Px to halt, which is what >>>>>>>>>>>>>>> Px is defined to do:
You are doing the same thing Richard is doing, getting >>>>>>>>>>>>>> at least one word of what I am saying incorrectly and >>>>>>>>>>>>>> then rebutting the incorrect paraphrase. This is the >>>>>>>>>>>>>> strawman error.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>>> H(Px, Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact >>>>>>>>>>>>>> that Px would never reach its "ret" instruction. This >>>>>>>>>>>>>> seems to be beyond your ordinary software engineering >>>>>>>>>>>>>> technical competence.
/Flibble
Every technically competent software engineer can easily >>>>>>>>>>>> confirm that the correct and complete x86 emulation of >>>>>>>>>>>> the input to H(Px,Px) by H would never reach the "ret" >>>>>>>>>>>> instruction of Px.
That you can not understand this proves that you are not >>>>>>>>>>>> a sufficiently technically competent software engineer on >>>>>>>>>>>> this point. Very good COBOL programmers might never be >>>>>>>>>>>> able to understand this.
To anyone that writes or maintains operating systems >>>>>>>>>>>> what I am claiming would be as easy to verify as first >>>>>>>>>>>> grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly. QED.
/Flibble
Get an operating system programmer to explain to you that >>>>>>>>>> the correct and complete x86 emulation of the input to
H(Px,Px) by H would never reach the "ret" instruction of >>>>>>>>>> Px. *This is totally over your head*
It is like I am saying that we know that black carts are >>>>>>>>>> cats and you disagree saying the a black cat might be some >>>>>>>>>> kind of dog.
My whole system is now wrapped in 131K zip file as a Visual >>>>>>>>>> Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your
logic.
First, by definition correct emulation of a program will
match the behavior of the program.
When you disagree with this precisely stated verified fact
you are either a liar or incompetent:
the correct and complete x86 emulation of the input to
H(Px,Px) by H would never reach the "ret" instruction
When you disagree the the above precisely stated verified
fact by changing its words and showing that the changed
words are not true then between liar and incompetent you
prove to be a liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push
00000427 ---[000013f1][0010234f][00000427] e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px)
by H would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
You are not committing to a criterion measure of correctness thus
your claim is vague.
Vague? My "claim" is crystal clear: Px should ALWAYS HALT and
your H decides that it is non-halting.
/Flibble
Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return
because it gets stuck in an infinite loop, then Px(Px) doesn't
Halt.
Now, this H fails to be a decider, so can't be a counter example
for a Halt Decider.
If H is a valid halt decider (and by that I mean returns an answer
in finite time) then Px *will* always halt: it doesn't because
Olcott's H is not a valid halt decider.
/Flibble
Now that H has been very recently adapted to be a pure function of
its inputs whenever it is invoked it always returns on finite time.
H aborts its simulation of Px before Px invokes H.
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that H
was called with.
(b) There are no instructions in Px that could possibly escape this infinitely recursive emulation.
(c) H aborts its emulation of Px before its call to H is invoked.
On Sun, 19 Jun 2022 18:53:36 -0400
Richard Damon <Richard@Damon-Family.org> wrote:
On 6/19/22 6:22 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 17:16:03 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:46 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong >>>>>>>>>>>>> saying Px doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:The question is: Would (future tense) the complete and >>>>>>>>>>>>>>>> correct x86 emulation of the input to H(Px,Px) by H >>>>>>>>>>>>>>>> ever reach the "ret" instruction of Px.
On 6/19/2022 1:20 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/19/22 2:08 PM, olcott wrote:
Competent software engineers will understand that >>>>>>>>>>>>>>>>>> when the behavior of Px matches this pattern that >>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input to >>>>>>>>>>>>>>>>>> H(Px,Px) by H would never reach the "ret"On 6/19/2022 12:40 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 12:01 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine >>>>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)We are talking about Px, not P. We are talking >>>>>>>>>>>>>>>>>>>>> about your H not analysing what its input >>>>>>>>>>>>>>>>>>>>> actually does and instead assuming that an input >>>>>>>>>>>>>>>>>>>>> that calls H is always pathological. >>>>>>>>>>>>>>>>>>>>>
void Px(u32 x)
A halt decider must compute the mapping >>>>>>>>>>>>>>>>>>>>>>>>>>>> from its inputs to an accept or reject >>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>> of these actual inputs. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects all >>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>> detects [in a finite number of steps] that >>>>>>>>>>>>>>>>>>>>>>>>>>>> its correct and complete simulation of its >>>>>>>>>>>>>>>>>>>>>>>>>>>> input would never reach [a] final state of >>>>>>>>>>>>>>>>>>>>>>>>>>>> this input then all [these] inputs >>>>>>>>>>>>>>>>>>>>>>>>>>>> (including pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427 >>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov >>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001100](01) 50 >>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P [00001101](03) >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx
// push P [00001105](05) e800feffff call >>>>>>>>>>>>>>>>>>>>>>>>>> 00000f0a // call H [0000110a](03) 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111
[00001113](01) 5d pop ebp
[00001114](01) c3 ret Size in
bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>> at:211ee2 ...[000010da][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push eax >>>>>>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e1][00211eca][000010da] >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H Infinitely >>>>>>>>>>>>>>>>>>>>>>>>>> Recursive Simulation Detected Simulation >>>>>>>>>>>>>>>>>>>>>>>>>> Stopped
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>>>> engineers* will see that when H bases its >>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision on whether or not its >>>>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its >>>>>>>>>>>>>>>>>>>>>>>>>> input would ever reach the "ret" instruction >>>>>>>>>>>>>>>>>>>>>>>>>> of this input that H is correct to reject >>>>>>>>>>>>>>>>>>>>>>>>>> this input.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>> return;
}
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] >>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
Because it is an easily verified fact that the >>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input >>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H would never reach the "ret" >>>>>>>>>>>>>>>>>>>>>> instruction of P and this is the criterion >>>>>>>>>>>>>>>>>>>>>> measure for H to reject its input how do you >>>>>>>>>>>>>>>>>>>>>> figure that H gets the wrong answer? >>>>>>>>>>>>>>>>>>>>>>
What I am saying is a logical tautology the same >>>>>>>>>>>>>>>>>>>>>> as when we know that X is a black cat then we >>>>>>>>>>>>>>>>>>>>>> know that X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete >>>>>>>>>>>>>>>>>>>> and correct x86 emulation of its input would never >>>>>>>>>>>>>>>>>>>> reach the "ret" instruction of Px.
That is only true if H never returns ANY answer (and >>>>>>>>>>>>>>>>>>> thus fails to be a decider).
instruction of Px:
H knows its own machine address and on this basis: >>>>>>>>>>>>>>>>>> (a) H recognizes that Px is calling H with the same >>>>>>>>>>>>>>>>>> arguments that H was called with.
(b) There are no instructions in Px that could >>>>>>>>>>>>>>>>>> possibly escape this infinitely recursive emulation. >>>>>>>>>>>>>>>>>> (c) H aborts its emulation of Px before Px its call >>>>>>>>>>>>>>>>>> to H is invoked.
Only if H never aborts. If H does abort, then Px(Px), >>>>>>>>>>>>>>>>> whose behavior exactly matches the CORRECT emulation >>>>>>>>>>>>>>>>> of the input to H(Px,Px) BY DEFINITION shows this. >>>>>>>>>>>>>>>>
You always change this question to a different >>>>>>>>>>>>>>>> question:
Does (present tense) the complete and correct x86 >>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H ever reach the >>>>>>>>>>>>>>>> "ret" instruction of Px.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>>>> H(Px, Px) should be to allow Px to halt, which is what >>>>>>>>>>>>>>> Px is defined to do:
You are doing the same thing Richard is doing, getting at >>>>>>>>>>>>>> least one word of what I am saying incorrectly and then >>>>>>>>>>>>>> rebutting the incorrect paraphrase. This is the strawman >>>>>>>>>>>>>> error.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>>> H(Px, Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that >>>>>>>>>>>>>> Px would never reach its "ret" instruction. This seems >>>>>>>>>>>>>> to be beyond your ordinary software engineering technical >>>>>>>>>>>>>> competence.
/Flibble
Every technically competent software engineer can easily >>>>>>>>>>>> confirm that the correct and complete x86 emulation of the >>>>>>>>>>>> input to H(Px,Px) by H would never reach the "ret"
instruction of Px.
That you can not understand this proves that you are not a >>>>>>>>>>>> sufficiently technically competent software engineer on >>>>>>>>>>>> this point. Very good COBOL programmers might never be >>>>>>>>>>>> able to understand this.
To anyone that writes or maintains operating systems what I >>>>>>>>>>>> am claiming would be as easy to verify as first grade
arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly. QED.
/Flibble
Get an operating system programmer to explain to you that the >>>>>>>>>> correct and complete x86 emulation of the input to H(Px,Px) >>>>>>>>>> by H would never reach the "ret" instruction of Px. *This is >>>>>>>>>> totally over your head*
It is like I am saying that we know that black carts are cats >>>>>>>>>> and you disagree saying the a black cat might be some kind of >>>>>>>>>> dog.
My whole system is now wrapped in 131K zip file as a Visual >>>>>>>>>> Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your logic. >>>>>>>>>
First, by definition correct emulation of a program will match >>>>>>>>> the behavior of the program.
When you disagree with this precisely stated verified fact you >>>>>>>> are either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px) >>>>>>>> by H would never reach the "ret" instruction
When you disagree the the above precisely stated verified fact >>>>>>>> by changing its words and showing that the changed words are
not true then between liar and incompetent you prove to be a
liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px)
by H would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
You are not committing to a criterion measure of correctness thus
your claim is vague.
Vague? My "claim" is crystal clear: Px should ALWAYS HALT and your H
decides that it is non-halting.
/Flibble
Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return because
it gets stuck in an infinite loop, then Px(Px) doesn't Halt.
Now, this H fails to be a decider, so can't be a counter example for
a Halt Decider.
If H is a valid halt decider (and by that I mean returns an answer in
finite time) then Px *will* always halt: it doesn't because Olcott's H
is not a valid halt decider.
/Flibble
On 6/19/2022 5:58 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 18:53:36 -0400
Richard Damon <Richard@Damon-Family.org> wrote:
On 6/19/22 6:22 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 17:16:03 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:46 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer >>>>>>>>>>>>> wrong saying Px doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>> On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/19/22 2:08 PM, olcott wrote:
Competent software engineers will understand that >>>>>>>>>>>>>>>>>> when the behavior of Px matches this pattern that >>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input to >>>>>>>>>>>>>>>>>> H(Px,Px) by H would never reach the "ret" >>>>>>>>>>>>>>>>>> instruction of Px:On 6/19/2022 12:40 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500 >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing >>>>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a >>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>>>>>>>>>>That is only true if H never returns ANY answer >>>>>>>>>>>>>>>>>>> (and thus fails to be a decider).
We are talking about Px, not P. We are talking >>>>>>>>>>>>>>>>>>>>> about your H not analysing what its input >>>>>>>>>>>>>>>>>>>>> actually does and instead assuming that an input >>>>>>>>>>>>>>>>>>>>> that calls H is always pathological. >>>>>>>>>>>>>>>>>>>>>void Px(u32 x)void Px(u32 x)A halt decider must compute the mapping >>>>>>>>>>>>>>>>>>>>>>>>>>>> from its inputs to an accept or reject >>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>> of these actual inputs. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects >>>>>>>>>>>>>>>>>>>>>>>>>>>> all inputs as non-halting whenever it >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly detects [in a finite number of >>>>>>>>>>>>>>>>>>>>>>>>>>>> steps] that its correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never >>>>>>>>>>>>>>>>>>>>>>>>>>>> reach [a] final state of this input then >>>>>>>>>>>>>>>>>>>>>>>>>>>> all [these] inputs (including >>>>>>>>>>>>>>>>>>>>>>>>>>>> pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); } >>>>>>>>>>>>>>>>>>>>>>>>>>>
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427 >>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has >>>>>>>>>>>>>>>>>>>>>>>>>>> not been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov >>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001100](01) 50 >>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P [00001101](03) >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx
// push P [00001105](05) e800feffff call >>>>>>>>>>>>>>>>>>>>>>>>>> 00000f0a // call H [0000110a](03) 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 [0000110d](02) 85c0 test >>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax [0000110f](02) 7402 jz
00001113 [00001111](02) ebfe >>>>>>>>>>>>>>>>>>>>>>>>>> jmp 00001111 [00001113](01) 5d >>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001114](01) c3 >>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [00001114] >>>>>>>>>>>>>>>>>>>>>>>>>>
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>> at:211ee2 ...[000010da][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>> eax // push P
...[000010e1][00211eca][000010da] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H >>>>>>>>>>>>>>>>>>>>>>>>>> Infinitely Recursive Simulation Detected >>>>>>>>>>>>>>>>>>>>>>>>>> Simulation Stopped
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>>>> engineers* will see that when H bases its >>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision on whether or not its >>>>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its >>>>>>>>>>>>>>>>>>>>>>>>>> input would ever reach the "ret" >>>>>>>>>>>>>>>>>>>>>>>>>> instruction of this input that H is >>>>>>>>>>>>>>>>>>>>>>>>>> correct to reject this input. >>>>>>>>>>>>>>>>>>>>>>>>>
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>> engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] >>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
Because it is an easily verified fact that the >>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input >>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H would never reach the "ret" >>>>>>>>>>>>>>>>>>>>>> instruction of P and this is the criterion >>>>>>>>>>>>>>>>>>>>>> measure for H to reject its input how do you >>>>>>>>>>>>>>>>>>>>>> figure that H gets the wrong answer? >>>>>>>>>>>>>>>>>>>>>>
What I am saying is a logical tautology the >>>>>>>>>>>>>>>>>>>>>> same as when we know that X is a black cat >>>>>>>>>>>>>>>>>>>>>> then we know that X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the >>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its input >>>>>>>>>>>>>>>>>>>> would never reach the "ret" instruction of Px. >>>>>>>>>>>>>>>>>>>
H knows its own machine address and on this basis: >>>>>>>>>>>>>>>>>> (a) H recognizes that Px is calling H with the same >>>>>>>>>>>>>>>>>> arguments that H was called with.
(b) There are no instructions in Px that could >>>>>>>>>>>>>>>>>> possibly escape this infinitely recursive >>>>>>>>>>>>>>>>>> emulation. (c) H aborts its emulation of Px before >>>>>>>>>>>>>>>>>> Px its call to H is invoked.
Only if H never aborts. If H does abort, then >>>>>>>>>>>>>>>>> Px(Px), whose behavior exactly matches the CORRECT >>>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) BY DEFINITION >>>>>>>>>>>>>>>>> shows this.
The question is: Would (future tense) the complete >>>>>>>>>>>>>>>> and correct x86 emulation of the input to H(Px,Px) >>>>>>>>>>>>>>>> by H ever reach the "ret" instruction of Px. >>>>>>>>>>>>>>>>
You always change this question to a different >>>>>>>>>>>>>>>> question:
Does (present tense) the complete and correct x86 >>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H ever reach >>>>>>>>>>>>>>>> the "ret" instruction of Px.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>>>> H(Px, Px) should be to allow Px to halt, which is what >>>>>>>>>>>>>>> Px is defined to do:
You are doing the same thing Richard is doing, getting >>>>>>>>>>>>>> at least one word of what I am saying incorrectly and >>>>>>>>>>>>>> then rebutting the incorrect paraphrase. This is the >>>>>>>>>>>>>> strawman error.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>>> H(Px, Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact >>>>>>>>>>>>>> that Px would never reach its "ret" instruction. This >>>>>>>>>>>>>> seems to be beyond your ordinary software engineering >>>>>>>>>>>>>> technical competence.
/Flibble
Every technically competent software engineer can easily >>>>>>>>>>>> confirm that the correct and complete x86 emulation of >>>>>>>>>>>> the input to H(Px,Px) by H would never reach the "ret" >>>>>>>>>>>> instruction of Px.
That you can not understand this proves that you are not >>>>>>>>>>>> a sufficiently technically competent software engineer on >>>>>>>>>>>> this point. Very good COBOL programmers might never be >>>>>>>>>>>> able to understand this.
To anyone that writes or maintains operating systems >>>>>>>>>>>> what I am claiming would be as easy to verify as first >>>>>>>>>>>> grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>> correctly. QED.
/Flibble
Get an operating system programmer to explain to you that >>>>>>>>>> the correct and complete x86 emulation of the input to
H(Px,Px) by H would never reach the "ret" instruction of >>>>>>>>>> Px. *This is totally over your head*
It is like I am saying that we know that black carts are >>>>>>>>>> cats and you disagree saying the a black cat might be some >>>>>>>>>> kind of dog.
My whole system is now wrapped in 131K zip file as a Visual >>>>>>>>>> Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your
logic.
First, by definition correct emulation of a program will
match the behavior of the program.
When you disagree with this precisely stated verified fact
you are either a liar or incompetent:
the correct and complete x86 emulation of the input to
H(Px,Px) by H would never reach the "ret" instruction
When you disagree the the above precisely stated verified
fact by changing its words and showing that the changed
words are not true then between liar and incompetent you
prove to be a liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push
00000427 ---[000013f1][0010234f][00000427] e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px)
by H would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
You are not committing to a criterion measure of correctness thus
your claim is vague.
Vague? My "claim" is crystal clear: Px should ALWAYS HALT and
your H decides that it is non-halting.
/Flibble
Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return
because it gets stuck in an infinite loop, then Px(Px) doesn't
Halt.
Now, this H fails to be a decider, so can't be a counter example
for a Halt Decider.
If H is a valid halt decider (and by that I mean returns an answer
in finite time) then Px *will* always halt: it doesn't because
Olcott's H is not a valid halt decider.
/Flibble
Now that H has been very recently adapted to be a pure function of
its inputs whenever it is invoked it always returns on finite time.
H aborts its simulation of Px before Px invokes H.
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that H
was called with.
(b) There are no instructions in Px that could possibly escape this infinitely recursive emulation.
(c) H aborts its emulation of Px before its call to H is invoked.
On Sun, 19 Jun 2022 18:25:33 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 5:58 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 18:53:36 -0400
Richard Damon <Richard@Damon-Family.org> wrote:
On 6/19/22 6:22 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 17:16:03 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:46 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer >>>>>>>>>>>>>>> wrong saying Px doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/19/22 2:08 PM, olcott wrote:
Competent software engineers will understand that >>>>>>>>>>>>>>>>>>>> when the behavior of Px matches this pattern that >>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input to >>>>>>>>>>>>>>>>>>>> H(Px,Px) by H would never reach the "ret" >>>>>>>>>>>>>>>>>>>> instruction of Px:On 6/19/2022 12:40 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>That is only true if H never returns ANY answer >>>>>>>>>>>>>>>>>>>>> (and thus fails to be a decider).
We are talking about Px, not P. We are talking >>>>>>>>>>>>>>>>>>>>>>> about your H not analysing what its input >>>>>>>>>>>>>>>>>>>>>>> actually does and instead assuming that an input >>>>>>>>>>>>>>>>>>>>>>> that calls H is always pathological. >>>>>>>>>>>>>>>>>>>>>>>void Px(u32 x)void Px(u32 x)A halt decider must compute the mapping >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from its inputs to an accept or reject >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of these actual inputs. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all inputs as non-halting whenever it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly detects [in a finite number of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps] that its correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach [a] final state of this input then >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all [these] inputs (including >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has >>>>>>>>>>>>>>>>>>>>>>>>>>>>> not been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov >>>>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001100](01) 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P [00001101](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx
// push P [00001105](05) e800feffff call >>>>>>>>>>>>>>>>>>>>>>>>>>>> 00000f0a // call H [0000110a](03) 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 [0000110d](02) 85c0 test >>>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax [0000110f](02) 7402 jz
00001113 [00001111](02) ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 00001111 [00001113](01) 5d >>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001114](01) c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [00001114] >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>>> at:211ee2 ...[000010da][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000010e0][00211eca][000010da] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>> eax // push P
...[000010e1][00211eca][000010da] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinitely Recursive Simulation Detected >>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulation Stopped
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>>>>>> engineers* will see that when H bases its >>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision on whether or not its >>>>>>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its >>>>>>>>>>>>>>>>>>>>>>>>>>>> input would ever reach the "ret" >>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction of this input that H is >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct to reject this input. >>>>>>>>>>>>>>>>>>>>>>>>>>>
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427 >>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>>>> engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] >>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
Because it is an easily verified fact that the >>>>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input >>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H would never reach the "ret" >>>>>>>>>>>>>>>>>>>>>>>> instruction of P and this is the criterion >>>>>>>>>>>>>>>>>>>>>>>> measure for H to reject its input how do you >>>>>>>>>>>>>>>>>>>>>>>> figure that H gets the wrong answer? >>>>>>>>>>>>>>>>>>>>>>>>
What I am saying is a logical tautology the >>>>>>>>>>>>>>>>>>>>>>>> same as when we know that X is a black cat >>>>>>>>>>>>>>>>>>>>>>>> then we know that X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the >>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its input >>>>>>>>>>>>>>>>>>>>>> would never reach the "ret" instruction of Px. >>>>>>>>>>>>>>>>>>>>>
H knows its own machine address and on this basis: >>>>>>>>>>>>>>>>>>>> (a) H recognizes that Px is calling H with the same >>>>>>>>>>>>>>>>>>>> arguments that H was called with.
(b) There are no instructions in Px that could >>>>>>>>>>>>>>>>>>>> possibly escape this infinitely recursive >>>>>>>>>>>>>>>>>>>> emulation. (c) H aborts its emulation of Px before >>>>>>>>>>>>>>>>>>>> Px its call to H is invoked.
Only if H never aborts. If H does abort, then >>>>>>>>>>>>>>>>>>> Px(Px), whose behavior exactly matches the CORRECT >>>>>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) BY DEFINITION >>>>>>>>>>>>>>>>>>> shows this.
The question is: Would (future tense) the complete >>>>>>>>>>>>>>>>>> and correct x86 emulation of the input to H(Px,Px) >>>>>>>>>>>>>>>>>> by H ever reach the "ret" instruction of Px. >>>>>>>>>>>>>>>>>>
You always change this question to a different >>>>>>>>>>>>>>>>>> question:
Does (present tense) the complete and correct x86 >>>>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H ever reach >>>>>>>>>>>>>>>>>> the "ret" instruction of Px.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>>>>>> H(Px, Px) should be to allow Px to halt, which is what >>>>>>>>>>>>>>>>> Px is defined to do:
You are doing the same thing Richard is doing, getting >>>>>>>>>>>>>>>> at least one word of what I am saying incorrectly and >>>>>>>>>>>>>>>> then rebutting the incorrect paraphrase. This is the >>>>>>>>>>>>>>>> strawman error.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>>>>> H(Px, Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact >>>>>>>>>>>>>>>> that Px would never reach its "ret" instruction. This >>>>>>>>>>>>>>>> seems to be beyond your ordinary software engineering >>>>>>>>>>>>>>>> technical competence.
/Flibble
Every technically competent software engineer can easily >>>>>>>>>>>>>> confirm that the correct and complete x86 emulation of >>>>>>>>>>>>>> the input to H(Px,Px) by H would never reach the "ret" >>>>>>>>>>>>>> instruction of Px.
That you can not understand this proves that you are not >>>>>>>>>>>>>> a sufficiently technically competent software engineer on >>>>>>>>>>>>>> this point. Very good COBOL programmers might never be >>>>>>>>>>>>>> able to understand this.
To anyone that writes or maintains operating systems >>>>>>>>>>>>>> what I am claiming would be as easy to verify as first >>>>>>>>>>>>>> grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>> correctly. QED.
/Flibble
Get an operating system programmer to explain to you that >>>>>>>>>>>> the correct and complete x86 emulation of the input to >>>>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction of >>>>>>>>>>>> Px. *This is totally over your head*
It is like I am saying that we know that black carts are >>>>>>>>>>>> cats and you disagree saying the a black cat might be some >>>>>>>>>>>> kind of dog.
My whole system is now wrapped in 131K zip file as a Visual >>>>>>>>>>>> Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your
logic.
First, by definition correct emulation of a program will >>>>>>>>>>> match the behavior of the program.
When you disagree with this precisely stated verified fact >>>>>>>>>> you are either a liar or incompetent:
the correct and complete x86 emulation of the input to
H(Px,Px) by H would never reach the "ret" instruction
When you disagree the the above precisely stated verified
fact by changing its words and showing that the changed
words are not true then between liar and incompetent you
prove to be a liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>>>>> ...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push
00000427 ---[000013f1][0010234f][00000427] e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>>>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px) >>>>>>>> by H would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
You are not committing to a criterion measure of correctness thus
your claim is vague.
Vague? My "claim" is crystal clear: Px should ALWAYS HALT and
your H decides that it is non-halting.
/Flibble
Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return
because it gets stuck in an infinite loop, then Px(Px) doesn't
Halt.
Now, this H fails to be a decider, so can't be a counter example
for a Halt Decider.
If H is a valid halt decider (and by that I mean returns an answer
in finite time) then Px *will* always halt: it doesn't because
Olcott's H is not a valid halt decider.
/Flibble
Now that H has been very recently adapted to be a pure function of
its inputs whenever it is invoked it always returns on finite time.
H aborts its simulation of Px before Px invokes H.
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that H
was called with.
(b) There are no instructions in Px that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of Px before its call to H is invoked.
To be a valid halt decider H must always return a value to its invoker,
in this case Px; it doesn't so it isn't a valid halt decider.
/Flibble
On Sun, 19 Jun 2022 18:25:33 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 5:58 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 18:53:36 -0400
Richard Damon <Richard@Damon-Family.org> wrote:
On 6/19/22 6:22 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 17:16:03 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:46 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer >>>>>>>>>>>>>>> wrong saying Px doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/19/22 2:08 PM, olcott wrote:
Competent software engineers will understand that >>>>>>>>>>>>>>>>>>>> when the behavior of Px matches this pattern that >>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input to >>>>>>>>>>>>>>>>>>>> H(Px,Px) by H would never reach the "ret" >>>>>>>>>>>>>>>>>>>> instruction of Px:On 6/19/2022 12:40 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>That is only true if H never returns ANY answer >>>>>>>>>>>>>>>>>>>>> (and thus fails to be a decider).
We are talking about Px, not P. We are talking >>>>>>>>>>>>>>>>>>>>>>> about your H not analysing what its input >>>>>>>>>>>>>>>>>>>>>>> actually does and instead assuming that an input >>>>>>>>>>>>>>>>>>>>>>> that calls H is always pathological. >>>>>>>>>>>>>>>>>>>>>>>void Px(u32 x)void Px(u32 x)A halt decider must compute the mapping >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from its inputs to an accept or reject >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of these actual inputs. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all inputs as non-halting whenever it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly detects [in a finite number of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps] that its correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach [a] final state of this input then >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all [these] inputs (including >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has >>>>>>>>>>>>>>>>>>>>>>>>>>>>> not been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov >>>>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001100](01) 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P [00001101](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx
// push P [00001105](05) e800feffff call >>>>>>>>>>>>>>>>>>>>>>>>>>>> 00000f0a // call H [0000110a](03) 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 [0000110d](02) 85c0 test >>>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax [0000110f](02) 7402 jz
00001113 [00001111](02) ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 00001111 [00001113](01) 5d >>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001114](01) c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [00001114] >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>>> at:211ee2 ...[000010da][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000010e0][00211eca][000010da] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>> eax // push P
...[000010e1][00211eca][000010da] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push >>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx // push P
...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinitely Recursive Simulation Detected >>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulation Stopped
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>>>>>> engineers* will see that when H bases its >>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision on whether or not its >>>>>>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its >>>>>>>>>>>>>>>>>>>>>>>>>>>> input would ever reach the "ret" >>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction of this input that H is >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct to reject this input. >>>>>>>>>>>>>>>>>>>>>>>>>>>
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427 >>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>>>> engineers*
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] >>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
Because it is an easily verified fact that the >>>>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input >>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H would never reach the "ret" >>>>>>>>>>>>>>>>>>>>>>>> instruction of P and this is the criterion >>>>>>>>>>>>>>>>>>>>>>>> measure for H to reject its input how do you >>>>>>>>>>>>>>>>>>>>>>>> figure that H gets the wrong answer? >>>>>>>>>>>>>>>>>>>>>>>>
What I am saying is a logical tautology the >>>>>>>>>>>>>>>>>>>>>>>> same as when we know that X is a black cat >>>>>>>>>>>>>>>>>>>>>>>> then we know that X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the >>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its input >>>>>>>>>>>>>>>>>>>>>> would never reach the "ret" instruction of Px. >>>>>>>>>>>>>>>>>>>>>
H knows its own machine address and on this basis: >>>>>>>>>>>>>>>>>>>> (a) H recognizes that Px is calling H with the same >>>>>>>>>>>>>>>>>>>> arguments that H was called with.
(b) There are no instructions in Px that could >>>>>>>>>>>>>>>>>>>> possibly escape this infinitely recursive >>>>>>>>>>>>>>>>>>>> emulation. (c) H aborts its emulation of Px before >>>>>>>>>>>>>>>>>>>> Px its call to H is invoked.
Only if H never aborts. If H does abort, then >>>>>>>>>>>>>>>>>>> Px(Px), whose behavior exactly matches the CORRECT >>>>>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) BY DEFINITION >>>>>>>>>>>>>>>>>>> shows this.
The question is: Would (future tense) the complete >>>>>>>>>>>>>>>>>> and correct x86 emulation of the input to H(Px,Px) >>>>>>>>>>>>>>>>>> by H ever reach the "ret" instruction of Px. >>>>>>>>>>>>>>>>>>
You always change this question to a different >>>>>>>>>>>>>>>>>> question:
Does (present tense) the complete and correct x86 >>>>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H ever reach >>>>>>>>>>>>>>>>>> the "ret" instruction of Px.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>>>>>> H(Px, Px) should be to allow Px to halt, which is what >>>>>>>>>>>>>>>>> Px is defined to do:
You are doing the same thing Richard is doing, getting >>>>>>>>>>>>>>>> at least one word of what I am saying incorrectly and >>>>>>>>>>>>>>>> then rebutting the incorrect paraphrase. This is the >>>>>>>>>>>>>>>> strawman error.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>>>>> H(Px, Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact >>>>>>>>>>>>>>>> that Px would never reach its "ret" instruction. This >>>>>>>>>>>>>>>> seems to be beyond your ordinary software engineering >>>>>>>>>>>>>>>> technical competence.
/Flibble
Every technically competent software engineer can easily >>>>>>>>>>>>>> confirm that the correct and complete x86 emulation of >>>>>>>>>>>>>> the input to H(Px,Px) by H would never reach the "ret" >>>>>>>>>>>>>> instruction of Px.
That you can not understand this proves that you are not >>>>>>>>>>>>>> a sufficiently technically competent software engineer on >>>>>>>>>>>>>> this point. Very good COBOL programmers might never be >>>>>>>>>>>>>> able to understand this.
To anyone that writes or maintains operating systems >>>>>>>>>>>>>> what I am claiming would be as easy to verify as first >>>>>>>>>>>>>> grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>>> correctly. QED.
/Flibble
Get an operating system programmer to explain to you that >>>>>>>>>>>> the correct and complete x86 emulation of the input to >>>>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction of >>>>>>>>>>>> Px. *This is totally over your head*
It is like I am saying that we know that black carts are >>>>>>>>>>>> cats and you disagree saying the a black cat might be some >>>>>>>>>>>> kind of dog.
My whole system is now wrapped in 131K zip file as a Visual >>>>>>>>>>>> Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your
logic.
First, by definition correct emulation of a program will >>>>>>>>>>> match the behavior of the program.
When you disagree with this precisely stated verified fact >>>>>>>>>> you are either a liar or incompetent:
the correct and complete x86 emulation of the input to
H(Px,Px) by H would never reach the "ret" instruction
When you disagree the the above precisely stated verified
fact by changing its words and showing that the changed
words are not true then between liar and incompetent you
prove to be a liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>>>>> ...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push
00000427 ---[000013f1][0010234f][00000427] e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>>>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px) >>>>>>>> by H would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
You are not committing to a criterion measure of correctness thus
your claim is vague.
Vague? My "claim" is crystal clear: Px should ALWAYS HALT and
your H decides that it is non-halting.
/Flibble
Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return
because it gets stuck in an infinite loop, then Px(Px) doesn't
Halt.
Now, this H fails to be a decider, so can't be a counter example
for a Halt Decider.
If H is a valid halt decider (and by that I mean returns an answer
in finite time) then Px *will* always halt: it doesn't because
Olcott's H is not a valid halt decider.
/Flibble
Now that H has been very recently adapted to be a pure function of
its inputs whenever it is invoked it always returns on finite time.
H aborts its simulation of Px before Px invokes H.
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that H
was called with.
(b) There are no instructions in Px that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of Px before its call to H is invoked.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 ...[000013eb][00102353][00000000] 50 push eax ...[000013ec][0010234f][00000427] 6827040000 push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 ...[000013f9][00102357][00000000] 33c0 xor eax,eax ...[000013fb][0010235b][00100000] 5d pop ebp ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
On 6/19/2022 6:27 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 18:25:33 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 5:58 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 18:53:36 -0400
Richard Damon <Richard@Damon-Family.org> wrote:
On 6/19/22 6:22 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 17:16:03 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:46 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer >>>>>>>>>>>>>>> wrong saying Px doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/19/22 2:08 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 12:40 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>
void Px(u32 x)void Px(u32 x)void Px(u32 x)On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
A halt decider must compute the mapping >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from its inputs to an accept or reject >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of these actual inputs. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all inputs as non-halting whenever it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly detects [in a finite number >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of steps] that its correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach [a] final state of this input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then all [these] inputs (including >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax
...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0 ...[000013f6][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c408 add esp,+08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> xor eax,eax
...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp
...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Number of Instructions >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Executed(16120)
It gets the answer wrong, i.e. input has >>>>>>>>>>>>>>>>>>>>>>>>>>>>> not been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov >>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000010fd](03) 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] [00001100](01) 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P [00001101](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx
// push P [00001105](05) e800feffff call >>>>>>>>>>>>>>>>>>>>>>>>>>>> 00000f0a // call H [0000110a](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c408 add esp,+08 [0000110d](02) 85c0 >>>>>>>>>>>>>>>>>>>>>>>>>>>> test eax,eax [0000110f](02) 7402 >>>>>>>>>>>>>>>>>>>>>>>>>>>> jz 00001113 [00001111](02) ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 00001111 [00001113](01) 5d >>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001114](01) c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [00001114] >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>>> at:211ee2
...[000010da][00211ece][00211ed2] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
...[000010db][00211ece][00211ed2] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
...[000010dd][00211ece][00211ed2] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P
...[000010e1][00211eca][000010da] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx // push P
...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinitely Recursive Simulation Detected >>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulation Stopped
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>>>>>> engineers* will see that when H bases its >>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision on whether or not >>>>>>>>>>>>>>>>>>>>>>>>>>>> its complete and correct x86 emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input would ever reach the "ret" >>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction of this input that H is >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct to reject this input. >>>>>>>>>>>>>>>>>>>>>>>>>>>
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); } >>>>>>>>>>>>>>>>>>>>>>>>>>>
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427 >>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has >>>>>>>>>>>>>>>>>>>>>>>>>>> not been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>>>> engineers*
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
Because it is an easily verified fact that >>>>>>>>>>>>>>>>>>>>>>>> the correct and complete x86 emulation of >>>>>>>>>>>>>>>>>>>>>>>> the input to H(P,P) by H would never reach >>>>>>>>>>>>>>>>>>>>>>>> the "ret" instruction of P and this is the >>>>>>>>>>>>>>>>>>>>>>>> criterion measure for H to reject its input >>>>>>>>>>>>>>>>>>>>>>>> how do you figure that H gets the wrong >>>>>>>>>>>>>>>>>>>>>>>> answer?
What I am saying is a logical tautology the >>>>>>>>>>>>>>>>>>>>>>>> same as when we know that X is a black cat >>>>>>>>>>>>>>>>>>>>>>>> then we know that X is a cat. >>>>>>>>>>>>>>>>>>>>>>> We are talking about Px, not P. We are talking >>>>>>>>>>>>>>>>>>>>>>> about your H not analysing what its input >>>>>>>>>>>>>>>>>>>>>>> actually does and instead assuming that an >>>>>>>>>>>>>>>>>>>>>>> input that calls H is always pathological. >>>>>>>>>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] >>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the >>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its input >>>>>>>>>>>>>>>>>>>>>> would never reach the "ret" instruction of Px. >>>>>>>>>>>>>>>>>>>>>>
That is only true if H never returns ANY answer >>>>>>>>>>>>>>>>>>>>> (and thus fails to be a decider). >>>>>>>>>>>>>>>>>>>> Competent software engineers will understand that >>>>>>>>>>>>>>>>>>>> when the behavior of Px matches this pattern that >>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input >>>>>>>>>>>>>>>>>>>> to H(Px,Px) by H would never reach the "ret" >>>>>>>>>>>>>>>>>>>> instruction of Px:
H knows its own machine address and on this >>>>>>>>>>>>>>>>>>>> basis: (a) H recognizes that Px is calling H >>>>>>>>>>>>>>>>>>>> with the same arguments that H was called with. >>>>>>>>>>>>>>>>>>>> (b) There are no instructions in Px that could >>>>>>>>>>>>>>>>>>>> possibly escape this infinitely recursive >>>>>>>>>>>>>>>>>>>> emulation. (c) H aborts its emulation of Px >>>>>>>>>>>>>>>>>>>> before Px its call to H is invoked.
Only if H never aborts. If H does abort, then >>>>>>>>>>>>>>>>>>> Px(Px), whose behavior exactly matches the CORRECT >>>>>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) BY DEFINITION >>>>>>>>>>>>>>>>>>> shows this.
The question is: Would (future tense) the complete >>>>>>>>>>>>>>>>>> and correct x86 emulation of the input to H(Px,Px) >>>>>>>>>>>>>>>>>> by H ever reach the "ret" instruction of Px. >>>>>>>>>>>>>>>>>>
You always change this question to a different >>>>>>>>>>>>>>>>>> question:
Does (present tense) the complete and correct x86 >>>>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H ever reach >>>>>>>>>>>>>>>>>> the "ret" instruction of Px.
The complete and correct x86 emulation of the input >>>>>>>>>>>>>>>>> to H(Px, Px) should be to allow Px to halt, which >>>>>>>>>>>>>>>>> is what Px is defined to do:
You are doing the same thing Richard is doing, >>>>>>>>>>>>>>>> getting at least one word of what I am saying >>>>>>>>>>>>>>>> incorrectly and then rebutting the incorrect >>>>>>>>>>>>>>>> paraphrase. This is the strawman error.
The complete and correct x86 emulation of the input >>>>>>>>>>>>>>>> to H(Px, Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact >>>>>>>>>>>>>>>> that Px would never reach its "ret" instruction. This >>>>>>>>>>>>>>>> seems to be beyond your ordinary software engineering >>>>>>>>>>>>>>>> technical competence.
/Flibble
Every technically competent software engineer can >>>>>>>>>>>>>> easily confirm that the correct and complete x86 >>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H would never >>>>>>>>>>>>>> reach the "ret" instruction of Px.
That you can not understand this proves that you are >>>>>>>>>>>>>> not a sufficiently technically competent software >>>>>>>>>>>>>> engineer on this point. Very good COBOL programmers >>>>>>>>>>>>>> might never be able to understand this.
To anyone that writes or maintains operating systems >>>>>>>>>>>>>> what I am claiming would be as easy to verify as first >>>>>>>>>>>>>> grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427]
e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been
decided correctly. QED.
/Flibble
Get an operating system programmer to explain to you that >>>>>>>>>>>> the correct and complete x86 emulation of the input to >>>>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction of >>>>>>>>>>>> Px. *This is totally over your head*
It is like I am saying that we know that black carts are >>>>>>>>>>>> cats and you disagree saying the a black cat might be >>>>>>>>>>>> some kind of dog.
My whole system is now wrapped in 131K zip file as a >>>>>>>>>>>> Visual Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your >>>>>>>>>>> logic.
First, by definition correct emulation of a program will >>>>>>>>>>> match the behavior of the program.
When you disagree with this precisely stated verified fact >>>>>>>>>> you are either a liar or incompetent:
the correct and complete x86 emulation of the input to
H(Px,Px) by H would never reach the "ret" instruction
When you disagree the the above precisely stated verified >>>>>>>>>> fact by changing its words and showing that the changed
words are not true then between liar and incompetent you >>>>>>>>>> prove to be a liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to
H(Px,Px) by H would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push
00000427 ---[000013f1][0010234f][00000427] e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
You are not committing to a criterion measure of correctness
thus your claim is vague.
Vague? My "claim" is crystal clear: Px should ALWAYS HALT and
your H decides that it is non-halting.
/Flibble
Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return
because it gets stuck in an infinite loop, then Px(Px) doesn't
Halt.
Now, this H fails to be a decider, so can't be a counter example
for a Halt Decider.
If H is a valid halt decider (and by that I mean returns an answer
in finite time) then Px *will* always halt: it doesn't because
Olcott's H is not a valid halt decider.
/Flibble
Now that H has been very recently adapted to be a pure function of
its inputs whenever it is invoked it always returns on finite time.
H aborts its simulation of Px before Px invokes H.
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that
H was called with.
(b) There are no instructions in Px that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of Px before its call to H is invoked.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 ...[000013eb][00102353][00000000] 50 push eax ...[000013ec][0010234f][00000427] 6827040000 push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 ...[000013f9][00102357][00000000] 33c0 xor eax,eax ...[000013fb][0010235b][00100000] 5d pop ebp ...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided correctly.
QED.
/Flibble
So you are a mere bot now.
On 6/19/2022 6:32 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 18:25:33 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 5:58 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 18:53:36 -0400
Richard Damon <Richard@Damon-Family.org> wrote:
On 6/19/22 6:22 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 17:16:03 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:46 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer >>>>>>>>>>>>>>> wrong saying Px doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/19/22 2:30 PM, olcott wrote:
On 6/19/2022 1:20 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/19/22 2:08 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 12:40 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500 >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500 >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>
void Px(u32 x)void Px(u32 x)void Px(u32 x)On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
A halt decider must compute the mapping >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from its inputs to an accept or reject >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of these actual inputs. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all inputs as non-halting whenever it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly detects [in a finite number >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of steps] that its correct and complete >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach [a] final state of this input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then all [these] inputs (including >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax
...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0 ...[000013f6][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c408 add esp,+08 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> xor eax,eax
...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp
...[000013fc][0010235f][00000004] c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Number of Instructions >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Executed(16120)
It gets the answer wrong, i.e. input has >>>>>>>>>>>>>>>>>>>>>>>>>>>>> not been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov >>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000010fd](03) 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] [00001100](01) 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P [00001101](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx
// push P [00001105](05) e800feffff call >>>>>>>>>>>>>>>>>>>>>>>>>>>> 00000f0a // call H [0000110a](03) >>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c408 add esp,+08 [0000110d](02) 85c0 >>>>>>>>>>>>>>>>>>>>>>>>>>>> test eax,eax [0000110f](02) 7402 >>>>>>>>>>>>>>>>>>>>>>>>>>>> jz 00001113 [00001111](02) ebfe >>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 00001111 [00001113](01) 5d >>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp [00001114](01) c3 >>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [00001114] >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>>> at:211ee2
...[000010da][00211ece][00211ed2] 55 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
...[000010db][00211ece][00211ed2] 8bec >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
...[000010dd][00211ece][00211ed2] 8b4508 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P
...[000010e1][00211eca][000010da] 8b4d08 >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 >>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx // push P
...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H >>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinitely Recursive Simulation Detected >>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulation Stopped
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>>>>>> engineers* will see that when H bases its >>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision on whether or not >>>>>>>>>>>>>>>>>>>>>>>>>>>> its complete and correct x86 emulation >>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input would ever reach the "ret" >>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction of this input that H is >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct to reject this input. >>>>>>>>>>>>>>>>>>>>>>>>>>>
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); } >>>>>>>>>>>>>>>>>>>>>>>>>>>
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427 >>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has >>>>>>>>>>>>>>>>>>>>>>>>>>> not been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>>>> engineers*
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
Because it is an easily verified fact that >>>>>>>>>>>>>>>>>>>>>>>> the correct and complete x86 emulation of >>>>>>>>>>>>>>>>>>>>>>>> the input to H(P,P) by H would never reach >>>>>>>>>>>>>>>>>>>>>>>> the "ret" instruction of P and this is the >>>>>>>>>>>>>>>>>>>>>>>> criterion measure for H to reject its input >>>>>>>>>>>>>>>>>>>>>>>> how do you figure that H gets the wrong >>>>>>>>>>>>>>>>>>>>>>>> answer?
What I am saying is a logical tautology the >>>>>>>>>>>>>>>>>>>>>>>> same as when we know that X is a black cat >>>>>>>>>>>>>>>>>>>>>>>> then we know that X is a cat. >>>>>>>>>>>>>>>>>>>>>>> We are talking about Px, not P. We are talking >>>>>>>>>>>>>>>>>>>>>>> about your H not analysing what its input >>>>>>>>>>>>>>>>>>>>>>> actually does and instead assuming that an >>>>>>>>>>>>>>>>>>>>>>> input that calls H is always pathological. >>>>>>>>>>>>>>>>>>>>>>>
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] >>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the >>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its input >>>>>>>>>>>>>>>>>>>>>> would never reach the "ret" instruction of Px. >>>>>>>>>>>>>>>>>>>>>>
That is only true if H never returns ANY answer >>>>>>>>>>>>>>>>>>>>> (and thus fails to be a decider). >>>>>>>>>>>>>>>>>>>> Competent software engineers will understand that >>>>>>>>>>>>>>>>>>>> when the behavior of Px matches this pattern that >>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input >>>>>>>>>>>>>>>>>>>> to H(Px,Px) by H would never reach the "ret" >>>>>>>>>>>>>>>>>>>> instruction of Px:
H knows its own machine address and on this >>>>>>>>>>>>>>>>>>>> basis: (a) H recognizes that Px is calling H >>>>>>>>>>>>>>>>>>>> with the same arguments that H was called with. >>>>>>>>>>>>>>>>>>>> (b) There are no instructions in Px that could >>>>>>>>>>>>>>>>>>>> possibly escape this infinitely recursive >>>>>>>>>>>>>>>>>>>> emulation. (c) H aborts its emulation of Px >>>>>>>>>>>>>>>>>>>> before Px its call to H is invoked.
Only if H never aborts. If H does abort, then >>>>>>>>>>>>>>>>>>> Px(Px), whose behavior exactly matches the CORRECT >>>>>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) BY DEFINITION >>>>>>>>>>>>>>>>>>> shows this.
The question is: Would (future tense) the complete >>>>>>>>>>>>>>>>>> and correct x86 emulation of the input to H(Px,Px) >>>>>>>>>>>>>>>>>> by H ever reach the "ret" instruction of Px. >>>>>>>>>>>>>>>>>>
You always change this question to a different >>>>>>>>>>>>>>>>>> question:
Does (present tense) the complete and correct x86 >>>>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H ever reach >>>>>>>>>>>>>>>>>> the "ret" instruction of Px.
The complete and correct x86 emulation of the input >>>>>>>>>>>>>>>>> to H(Px, Px) should be to allow Px to halt, which >>>>>>>>>>>>>>>>> is what Px is defined to do:
You are doing the same thing Richard is doing, >>>>>>>>>>>>>>>> getting at least one word of what I am saying >>>>>>>>>>>>>>>> incorrectly and then rebutting the incorrect >>>>>>>>>>>>>>>> paraphrase. This is the strawman error.
The complete and correct x86 emulation of the input >>>>>>>>>>>>>>>> to H(Px, Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact >>>>>>>>>>>>>>>> that Px would never reach its "ret" instruction. This >>>>>>>>>>>>>>>> seems to be beyond your ordinary software engineering >>>>>>>>>>>>>>>> technical competence.
/Flibble
Every technically competent software engineer can >>>>>>>>>>>>>> easily confirm that the correct and complete x86 >>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H would never >>>>>>>>>>>>>> reach the "ret" instruction of Px.
That you can not understand this proves that you are >>>>>>>>>>>>>> not a sufficiently technically competent software >>>>>>>>>>>>>> engineer on this point. Very good COBOL programmers >>>>>>>>>>>>>> might never be able to understand this.
To anyone that writes or maintains operating systems >>>>>>>>>>>>>> what I am claiming would be as easy to verify as first >>>>>>>>>>>>>> grade arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000 >>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427]
e880f0ffff call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been
decided correctly. QED.
/Flibble
Get an operating system programmer to explain to you that >>>>>>>>>>>> the correct and complete x86 emulation of the input to >>>>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction of >>>>>>>>>>>> Px. *This is totally over your head*
It is like I am saying that we know that black carts are >>>>>>>>>>>> cats and you disagree saying the a black cat might be >>>>>>>>>>>> some kind of dog.
My whole system is now wrapped in 131K zip file as a >>>>>>>>>>>> Visual Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your >>>>>>>>>>> logic.
First, by definition correct emulation of a program will >>>>>>>>>>> match the behavior of the program.
When you disagree with this precisely stated verified fact >>>>>>>>>> you are either a liar or incompetent:
the correct and complete x86 emulation of the input to
H(Px,Px) by H would never reach the "ret" instruction
When you disagree the the above precisely stated verified >>>>>>>>>> fact by changing its words and showing that the changed
words are not true then between liar and incompetent you >>>>>>>>>> prove to be a liar.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add
esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add
esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to
H(Px,Px) by H would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08
...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push
00000427 ---[000013f1][0010234f][00000427] e880f0ffff
call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08
...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
You are not committing to a criterion measure of correctness
thus your claim is vague.
Vague? My "claim" is crystal clear: Px should ALWAYS HALT and
your H decides that it is non-halting.
/Flibble
Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return
because it gets stuck in an infinite loop, then Px(Px) doesn't
Halt.
Now, this H fails to be a decider, so can't be a counter example
for a Halt Decider.
If H is a valid halt decider (and by that I mean returns an answer
in finite time) then Px *will* always halt: it doesn't because
Olcott's H is not a valid halt decider.
/Flibble
Now that H has been very recently adapted to be a pure function of
its inputs whenever it is invoked it always returns on finite time.
H aborts its simulation of Px before Px invokes H.
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that
H was called with.
(b) There are no instructions in Px that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of Px before its call to H is invoked.
To be a valid halt decider H must always return a value to its
invoker, in this case Px; it doesn't so it isn't a valid halt
decider.
/Flibble
When a function is called in infinite recursion it merely never stops.
When a halt decider is called in infinite recursion it essentially
says https://www.youtube.com/watch?v=Z6EsNyIRG-g
When a function is called in infinite recursion it merely never stops.
When a halt decider is called in infinite recursion it essentially says https://www.youtube.com/watch?v=Z6EsNyIRG-g
On 6/19/2022 5:58 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 18:53:36 -0400
Richard Damon <Richard@Damon-Family.org> wrote:
On 6/19/22 6:22 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 17:16:03 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:46 PM, Mr Flibble wrote:Vague? My "claim" is crystal clear: Px should ALWAYS HALT and your H
On Sun, 19 Jun 2022 16:23:17 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:20 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 16:17:20 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 4:00 PM, Richard Damon wrote:void Px(u32 x)
On 6/19/22 4:43 PM, olcott wrote:
On 6/19/2022 3:31 PM, Mr Flibble wrote:
On Sun, 19 Jun 2022 15:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 3:08 PM, Mr Flibble wrote:void Px(u32 x)
On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 2:59 PM, Mr Flibble wrote:Px is defined to always halt; your H gets the answer wrong >>>>>>>>>>>>>> saying Px doesn't halt. QED.
On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:
On 6/19/2022 1:43 PM, Richard Damon wrote:
On 6/19/22 2:30 PM, olcott wrote:The question is: Would (future tense) the complete and >>>>>>>>>>>>>>>>> correct x86 emulation of the input to H(Px,Px) by H >>>>>>>>>>>>>>>>> ever reach the "ret" instruction of Px.
On 6/19/2022 1:20 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 6/19/22 2:08 PM, olcott wrote:
Competent software engineers will understand that >>>>>>>>>>>>>>>>>>> when the behavior of Px matches this pattern that >>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input to >>>>>>>>>>>>>>>>>>> H(Px,Px) by H would never reach the "ret" >>>>>>>>>>>>>>>>>>> instruction of Px:On 6/19/2022 12:40 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500 >>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500 >>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500 >>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
We are talking about Px, not P. We are talking >>>>>>>>>>>>>>>>>>>>>> about your H not analysing what its input >>>>>>>>>>>>>>>>>>>>>> actually does and instead assuming that an input >>>>>>>>>>>>>>>>>>>>>> that calls H is always pathological. >>>>>>>>>>>>>>>>>>>>>>{
A halt decider must compute the mapping >>>>>>>>>>>>>>>>>>>>>>>>>>>>> from its inputs to an accept or reject >>>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>> of these actual inputs. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
When a simulating halt decider rejects all >>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> detects [in a finite number of steps] that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> its correct and complete simulation of its >>>>>>>>>>>>>>>>>>>>>>>>>>>>> input would never reach [a] final state of >>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input then all [these] inputs >>>>>>>>>>>>>>>>>>>>>>>>>>>>> (including pathological inputs) are decided >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); } >>>>>>>>>>>>>>>>>>>>>>>>>>>>
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013eb][00102353][00000000] 50 push >>>>>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427 >>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
...[000013f9][00102357][00000000] 33c0 xor >>>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000] >>>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov >>>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08] [00001100](01) 50 >>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P [00001101](03) >>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>>>>>>>>>>>>>> [00001104](01) 51 push ecx
// push P [00001105](05) e800feffff call >>>>>>>>>>>>>>>>>>>>>>>>>>> 00000f0a // call H [0000110a](03) 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 [0000110d](02) 85c0 test eax,eax >>>>>>>>>>>>>>>>>>>>>>>>>>> [0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111
[00001113](01) 5d pop ebp
[00001114](01) c3 ret Size in
bytes:(0027) [00001114]
Begin Simulation Execution Trace Stored >>>>>>>>>>>>>>>>>>>>>>>>>>> at:211ee2 ...[000010da][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
...[000010db][00211ece][00211ed2] 8bec mov >>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp ...[000010dd][00211ece][00211ed2] >>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
...[000010e0][00211eca][000010da] 50 push eax >>>>>>>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e1][00211eca][000010da] >>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
...[000010e4][00211ec6][000010da] 51 push ecx >>>>>>>>>>>>>>>>>>>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] >>>>>>>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H Infinitely >>>>>>>>>>>>>>>>>>>>>>>>>>> Recursive Simulation Detected Simulation >>>>>>>>>>>>>>>>>>>>>>>>>>> Stopped
*All technically competent software >>>>>>>>>>>>>>>>>>>>>>>>>>> engineers* will see that when H bases its >>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision on whether or not its >>>>>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its >>>>>>>>>>>>>>>>>>>>>>>>>>> input would ever reach the "ret" instruction >>>>>>>>>>>>>>>>>>>>>>>>>>> of this input that H is correct to reject >>>>>>>>>>>>>>>>>>>>>>>>>>> this input.
void Px(u32 x)
{
H(x, x); >>>>>>>>>>>>>>>>>>>>>>>>>> return; >>>>>>>>>>>>>>>>>>>>>>>>>> }
int main()
{
Output("Input_Halts = ", >>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] >>>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0 >>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED. >>>>>>>>>>>>>>>>>>>>>>>>>>
/Flibble
*All technically competent software engineers* >>>>>>>>>>>>>>>>>>>>>>>> void Px(u32 x)
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px,
(u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] >>>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret Number >>>>>>>>>>>>>>>>>>>>>>>> of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not >>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
/Flibble
Because it is an easily verified fact that the >>>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input >>>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H would never reach the "ret" >>>>>>>>>>>>>>>>>>>>>>> instruction of P and this is the criterion >>>>>>>>>>>>>>>>>>>>>>> measure for H to reject its input how do you >>>>>>>>>>>>>>>>>>>>>>> figure that H gets the wrong answer? >>>>>>>>>>>>>>>>>>>>>>>
What I am saying is a logical tautology the same >>>>>>>>>>>>>>>>>>>>>>> as when we know that X is a black cat then we >>>>>>>>>>>>>>>>>>>>>>> know that X is a cat.
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, >>>>>>>>>>>>>>>>>>>>>> (u32)Px)); }
...[000013e8][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000] 50 >>>>>>>>>>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] >>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call >>>>>>>>>>>>>>>>>>>>>> 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 >>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000] 33c0 >>>>>>>>>>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d >>>>>>>>>>>>>>>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3 ret >>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120) >>>>>>>>>>>>>>>>>>>>>>
It gets the answer wrong, i.e. input has not been >>>>>>>>>>>>>>>>>>>>>> decided correctly. QED.
/Flibble
DO YOU AGREE WITH THIS?
H(Px,Px) does correctly determine that the complete >>>>>>>>>>>>>>>>>>>>> and correct x86 emulation of its input would never >>>>>>>>>>>>>>>>>>>>> reach the "ret" instruction of Px.
That is only true if H never returns ANY answer (and >>>>>>>>>>>>>>>>>>>> thus fails to be a decider).
H knows its own machine address and on this basis: >>>>>>>>>>>>>>>>>>> (a) H recognizes that Px is calling H with the same >>>>>>>>>>>>>>>>>>> arguments that H was called with.
(b) There are no instructions in Px that could >>>>>>>>>>>>>>>>>>> possibly escape this infinitely recursive emulation. >>>>>>>>>>>>>>>>>>> (c) H aborts its emulation of Px before Px its call >>>>>>>>>>>>>>>>>>> to H is invoked.
Only if H never aborts. If H does abort, then Px(Px), >>>>>>>>>>>>>>>>>> whose behavior exactly matches the CORRECT emulation >>>>>>>>>>>>>>>>>> of the input to H(Px,Px) BY DEFINITION shows this. >>>>>>>>>>>>>>>>>
You always change this question to a different >>>>>>>>>>>>>>>>> question:
Does (present tense) the complete and correct x86 >>>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H ever reach the >>>>>>>>>>>>>>>>> "ret" instruction of Px.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>>>>> H(Px, Px) should be to allow Px to halt, which is what >>>>>>>>>>>>>>>> Px is defined to do:
You are doing the same thing Richard is doing, getting at >>>>>>>>>>>>>>> least one word of what I am saying incorrectly and then >>>>>>>>>>>>>>> rebutting the incorrect paraphrase. This is the strawman >>>>>>>>>>>>>>> error.
The complete and correct x86 emulation of the input to >>>>>>>>>>>>>>> H(Px, Px) BY H
BY H
BY H
BY H
BY H
cannot possibly contradict the easily verified fact that >>>>>>>>>>>>>>> Px would never reach its "ret" instruction. This seems >>>>>>>>>>>>>>> to be beyond your ordinary software engineering technical >>>>>>>>>>>>>>> competence.
/Flibble
Every technically competent software engineer can easily >>>>>>>>>>>>> confirm that the correct and complete x86 emulation of the >>>>>>>>>>>>> input to H(Px,Px) by H would never reach the "ret"
instruction of Px.
That you can not understand this proves that you are not a >>>>>>>>>>>>> sufficiently technically competent software engineer on >>>>>>>>>>>>> this point. Very good COBOL programmers might never be >>>>>>>>>>>>> able to understand this.
To anyone that writes or maintains operating systems what I >>>>>>>>>>>>> am claiming would be as easy to verify as first grade >>>>>>>>>>>>> arithmetic.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px)); >>>>>>>>>>>> }
...[000013e8][00102357][00000000] 83c408 add >>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
push eax ...[000013ec][0010234f][00000427] 6827040000
push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff >>>>>>>>>>>> call 00000476 Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add >>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
xor eax,eax ...[000013fb][0010235b][00100000] 5d
pop ebp ...[000013fc][0010235f][00000004] c3
ret Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided >>>>>>>>>>>> correctly. QED.
/Flibble
Get an operating system programmer to explain to you that the >>>>>>>>>>> correct and complete x86 emulation of the input to H(Px,Px) >>>>>>>>>>> by H would never reach the "ret" instruction of Px. *This is >>>>>>>>>>> totally over your head*
It is like I am saying that we know that black carts are cats >>>>>>>>>>> and you disagree saying the a black cat might be some kind of >>>>>>>>>>> dog.
My whole system is now wrapped in 131K zip file as a Visual >>>>>>>>>>> Studio project on a downloadable link.
No, maybe you need an actual programmer to look at your logic. >>>>>>>>>>
First, by definition correct emulation of a program will match >>>>>>>>>> the behavior of the program.
When you disagree with this precisely stated verified fact you >>>>>>>>> are either a liar or incompetent:
the correct and complete x86 emulation of the input to H(Px,Px) >>>>>>>>> by H would never reach the "ret" instruction
When you disagree the the above precisely stated verified fact >>>>>>>>> by changing its words and showing that the changed words are >>>>>>>>> not true then between liar and incompetent you prove to be a >>>>>>>>> liar.
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>>>> ...[000013eb][00102353][00000000] 50 push eax
...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
...[000013fb][0010235b][00100000] 5d pop ebp >>>>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
the correct and complete x86 emulation of the input to H(Px,Px)
by H would never reach the "ret" instruction
What I am saying is the following, no more, no less:
void Px(u32 x)
{
H(x, x);
return;
}
int main()
{
Output("Input_Halts = ", H((u32)Px, (u32)Px));
}
...[000013e8][00102357][00000000] 83c408 add esp,+08 >>>>>> ...[000013eb][00102353][00000000] 50 push eax >>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427 >>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476 >>>>>> Input_Halts = 0
...[000013f6][00102357][00000000] 83c408 add esp,+08 >>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax >>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp >>>>>> ...[000013fc][0010235f][00000004] c3 ret >>>>>> Number of Instructions Executed(16120)
It gets the answer wrong, i.e. input has not been decided
correctly. QED.
/Flibble
You are not committing to a criterion measure of correctness thus
your claim is vague.
decides that it is non-halting.
/Flibble
Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return because
it gets stuck in an infinite loop, then Px(Px) doesn't Halt.
Now, this H fails to be a decider, so can't be a counter example for
a Halt Decider.
If H is a valid halt decider (and by that I mean returns an answer in
finite time) then Px *will* always halt: it doesn't because Olcott's H
is not a valid halt decider.
/Flibble
Now that H has been very recently adapted to be a pure function of its
inputs whenever it is invoked it always returns on finite time.
H aborts its simulation of Px before Px invokes H.
H knows its own machine address and on this basis:
(a) H recognizes that Px is calling H with the same arguments that H was called with.
(b) There are no instructions in Px that could possibly escape this infinitely recursive emulation.
(c) H aborts its emulation of Px before its call to H is invoked.
On 6/19/2022 5:02 PM, André G. Isaak wrote:
On 2022-06-19 14:43, olcott wrote:
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
I see no link anywhere.
André
Are you sure maybe you didn't look hard enough?
Maybe there is an invisible link between "131K" and "zip"
On 6/19/2022 5:02 PM, André G. Isaak wrote:
On 2022-06-19 14:43, olcott wrote:
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
I see no link anywhere.
André
Are you sure maybe you didn't look hard enough?
Maybe there is an invisible link between "131K" and "zip"
On 2022-06-19 16:18, olcott wrote:
On 6/19/2022 5:02 PM, André G. Isaak wrote:
On 2022-06-19 14:43, olcott wrote:
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
I see no link anywhere.
André
Are you sure maybe you didn't look hard enough?
Maybe there is an invisible link between "131K" and "zip"
If you posted it somewhere, wouldn't it be easier to simply repost the
link rather than make snide comments?
Or if you don't intend to post the link, then say so.
André
On 2022-06-19 21:14, olcott wrote:
On 6/19/2022 9:27 PM, André G. Isaak wrote:
On 2022-06-19 16:18, olcott wrote:
On 6/19/2022 5:02 PM, André G. Isaak wrote:
On 2022-06-19 14:43, olcott wrote:
My whole system is now wrapped in 131K zip file as a Visual Studio >>>>>> project on a downloadable link.
I see no link anywhere.
André
Are you sure maybe you didn't look hard enough?
Maybe there is an invisible link between "131K" and "zip"
If you posted it somewhere, wouldn't it be easier to simply repost
the link rather than make snide comments?
Or if you don't intend to post the link, then say so.
André
I do not intend to post the link very soon.
So then why bother mentioning it at all?
André
On 6/19/2022 9:27 PM, André G. Isaak wrote:
On 2022-06-19 16:18, olcott wrote:
On 6/19/2022 5:02 PM, André G. Isaak wrote:
On 2022-06-19 14:43, olcott wrote:
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
I see no link anywhere.
André
Are you sure maybe you didn't look hard enough?
Maybe there is an invisible link between "131K" and "zip"
If you posted it somewhere, wouldn't it be easier to simply repost the
link rather than make snide comments?
Or if you don't intend to post the link, then say so.
André
I do not intend to post the link very soon.
On 6/19/2022 9:27 PM, André G. Isaak wrote:
On 2022-06-19 16:18, olcott wrote:
On 6/19/2022 5:02 PM, André G. Isaak wrote:
On 2022-06-19 14:43, olcott wrote:
My whole system is now wrapped in 131K zip file as a Visual Studio
project on a downloadable link.
I see no link anywhere.
André
Are you sure maybe you didn't look hard enough?
Maybe there is an invisible link between "131K" and "zip"
If you posted it somewhere, wouldn't it be easier to simply repost the
link rather than make snide comments?
Or if you don't intend to post the link, then say so.
André
I do not intend to post the link very soon.
Because reviewers here have been so consistently disparaging of my work
they will be last in line to be able to have access to this code.
When I boiled my claims down to two easily verified facts of software engineering and everyone consistently still disagreed then I knew that
none of my reviewers were both sufficiently technically competent and
honest.
It is a very easily verified fact that the correct and complete x86
emulation of the input to H(P,P) by H would never reach the "ret"
instruction of P. Only one reviewer out of 100 reviewers in a dozen
different forums over the period of a year would acknowledge that.
The x86 emulator code is immaculate because I was very cautious in my
slight changes to keep it very clean. H is the one halt decider that has
all of its code quite clean and finally a pure function of its inputs.
The x86utm operating system code is very reliable yet quite messy.
At this point I have provided enough evidence that reasonable people
would conclude that all of my claims of having actual code have been sufficiently proven. I decided that posting this code as a Google Drive downloadable link to a complete Visual Studio project is the way to go.
The solution is defined so that immediately after the build the halt
decider can be directly run from inside Visual Studio. The halt decider
file itself can be edited to run different halt deciders on a small
library of sample inputs. Right out of the box H(P,P) is executed.
On 6/19/22 11:14 PM, olcott wrote:This is the part where you prove that you do not have sufficient
On 6/19/2022 9:27 PM, André G. Isaak wrote:
On 2022-06-19 16:18, olcott wrote:
On 6/19/2022 5:02 PM, André G. Isaak wrote:
On 2022-06-19 14:43, olcott wrote:
My whole system is now wrapped in 131K zip file as a Visual Studio >>>>>> project on a downloadable link.
I see no link anywhere.
André
Are you sure maybe you didn't look hard enough?
Maybe there is an invisible link between "131K" and "zip"
If you posted it somewhere, wouldn't it be easier to simply repost
the link rather than make snide comments?
Or if you don't intend to post the link, then say so.
André
I do not intend to post the link very soon.
Because reviewers here have been so consistently disparaging of my
work they will be last in line to be able to have access to this code.
When I boiled my claims down to two easily verified facts of software
engineering and everyone consistently still disagreed then I knew that
none of my reviewers were both sufficiently technically competent and
honest.
No, you haven't, because you can't actually verify them, just claim
them, because they aren't actually correct.
It is a very easily verified fact that the correct and complete x86
emulation of the input to H(P,P) by H would never reach the "ret"
instruction of P. Only one reviewer out of 100 reviewers in a dozen
different forums over the period of a year would acknowledge that.
ONLY if H actually does a correct and complete x86 emulation,
On 6/20/2022 6:18 AM, Richard Damon wrote:
On 6/19/22 11:14 PM, olcott wrote:
On 6/19/2022 9:27 PM, Andr� G. Isaak wrote:
On 2022-06-19 16:18, olcott wrote:
On 6/19/2022 5:02 PM, Andr� G. Isaak wrote:
On 2022-06-19 14:43, olcott wrote:
My whole system is now wrapped in 131K zip file as a Visual
Studio project on a downloadable link.
I see no link anywhere.
Andr�
Are you sure maybe you didn't look hard enough?
Maybe there is an invisible link between "131K" and "zip"
If you posted it somewhere, wouldn't it be easier to simply
repost the link rather than make snide comments?
Or if you don't intend to post the link, then say so.
Andr�
I do not intend to post the link very soon.
Because reviewers here have been so consistently disparaging of my
work they will be last in line to be able to have access to this
code.
When I boiled my claims down to two easily verified facts of
software engineering and everyone consistently still disagreed
then I knew that none of my reviewers were both sufficiently
technically competent and honest.
No, you haven't, because you can't actually verify them, just claim
them, because they aren't actually correct.
It is a very easily verified fact that the correct and complete
x86 emulation of the input to H(P,P) by H would never reach the
"ret" instruction of P. Only one reviewer out of 100 reviewers in
a dozen different forums over the period of a year would
acknowledge that.
ONLY if H actually does a correct and complete x86 emulation,This is the part where you prove that you do not have sufficient
technical competence in software engineering.
H correctly detects in a finite number of steps that its complete and correct x86 emulation of its input would never reach the "ret"
instruction of P.
H knows its own machine address and on this basis:
(a) H recognizes that P is calling H with the same arguments that H
was called with.
(b) There are no instructions in P that could possibly escape this infinitely recursive emulation.
(c) H aborts its emulation of P before its call to H is invoked.
The proof that I am correct is that no counter-example can possibly
exist.
On 6/20/2022 6:18 AM, Richard Damon wrote:
This is the part where you prove that you do not have sufficient
On 6/19/22 11:14 PM, olcott wrote:
On 6/19/2022 9:27 PM, André G. Isaak wrote:
On 2022-06-19 16:18, olcott wrote:
On 6/19/2022 5:02 PM, André G. Isaak wrote:
On 2022-06-19 14:43, olcott wrote:
My whole system is now wrapped in 131K zip file as a Visual
Studio project on a downloadable link.
I see no link anywhere.
André
Are you sure maybe you didn't look hard enough?
Maybe there is an invisible link between "131K" and "zip"
If you posted it somewhere, wouldn't it be easier to simply repost
the link rather than make snide comments?
Or if you don't intend to post the link, then say so.
André
I do not intend to post the link very soon.
Because reviewers here have been so consistently disparaging of my
work they will be last in line to be able to have access to this code.
When I boiled my claims down to two easily verified facts of software
engineering and everyone consistently still disagreed then I knew
that none of my reviewers were both sufficiently technically
competent and honest.
No, you haven't, because you can't actually verify them, just claim
them, because they aren't actually correct.
It is a very easily verified fact that the correct and complete x86
emulation of the input to H(P,P) by H would never reach the "ret"
instruction of P. Only one reviewer out of 100 reviewers in a dozen
different forums over the period of a year would acknowledge that.
ONLY if H actually does a correct and complete x86 emulation,
technical competence in software engineering.
H correctly detects in a finite number of steps that its complete and
correct x86 emulation of its input would never reach the "ret"
instruction of P.
H knows its own machine address and on this basis:
(a) H recognizes that P is calling H with the same arguments that H was called with.
(b) There are no instructions in P that could possibly escape this
infinitely recursive emulation.
(c) H aborts its emulation of P before its call to H is invoked.
The proof that I am correct is that no counter-example can possibly exist.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 461 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 21:11:26 |
| Calls: | 9,358 |
| Calls today: | 3 |
| Files: | 13,542 |
| Messages: | 6,083,980 |
| Posted today: | 2 |