XPost: comp.theory, sci.logic, sci.math

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.

*The above three sentences form a tautology that is proven to be true
entirely on the basis of the meaning of their words*

Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. (317-320)


--
Copyright 2022 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

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.

--
Copyright 2022 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/19/2022 10:54 AM, Mikko wrote:

On 2022-06-19 15:13:00 +0000, olcott said:

computation that halts … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

This definition is incomplete. Therefore your refutation does not
apply to Linz' proof.

Mikko

It will halt whenever it reaches final state means
if and only if it reaches its final state it halts.

--
Copyright 2022 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 6/19/22 11:13 AM, olcott 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.

And the call H(P,P) must be asking about the actual behavior of P(P) or
your P isn't built by the actual requirements of the Linz prrof.

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.

Except the decision needs to be CORRECT, based on what a CORRECT
simulation would do, which BY DEFINITION, matches the behaivor of the
program that it represents.

*The above three sentences form a tautology that is proven to be true entirely on the basis of the meaning of their words*

Except that you never actually meet the requirements of its premises.

Since there does not exist a finite pattern in the execution trace of
P(P) that the H(P,P) that it uses can have that actually shows
non-halting behavior, as any pattern that is put into that H that
appears in the execution of P(P) causes that H(P,P) to return 0 to its
calling P(P) which makes that, and thus ALL, P(P)s halt.

Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. (317-320)

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

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*

--
Copyright 2022 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/19/22 11:59 AM, olcott wrote:

On 6/19/2022 10:54 AM, Mikko wrote:

On 2022-06-19 15:13:00 +0000, olcott said:

computation that halts … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

This definition is incomplete. Therefore your refutation does not
apply to Linz' proof.

Mikko

It will halt whenever it reaches final state means
if and only if it reaches its final state it halts.

But it needs to also include the fact that non-halting means that it
never reaches the final state without running for an unbounded number of
steps.

The definition as quoted presumes that nothing "pauses or stops" the
execution of the Turing Machine.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 6/19/22 12:23 PM, olcott wrote:

*All technically competent software engineers*

Which means you are excluding yourself.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 6/19/22 11:39 AM, olcott 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.

So, does it do a complete and correct emulation (and thus never aborts
so never returns the value 0) or does it not do a complete and correct emulation so it can return 0 and thus has no true premise to base its
logic on.

Your arguement makes the flaw of assuming an impossible condition, that
H CAN do both a correct and complete emulation and at the same time
return the value 0.

Either you need to do infinite work in finite time or you are doing
something incorrectly and have unsound logic.

FAIL.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 6/19/22 1:16 PM, olcott 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)

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.

No, your "proof" of this is based on the assumption that H itself does a complete and correct emulation of its input. SInce it doesn't if it
returns 0 from H(P,P), that proof doesn't apply.

Your logic is unsound.

You have an impossible to meet definition of an algorithm to put into H,
so it doesn't actually exist.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

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)

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.

--
Copyright 2022 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

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)

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.

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)
{
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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

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)

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.

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

--
Copyright 2022 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 6/19/2022 12:35 PM, Mikko wrote:

On 2022-06-19 15:59:55 +0000, olcott said:

On 6/19/2022 10:54 AM, Mikko wrote:

On 2022-06-19 15:13:00 +0000, olcott said:

computation that halts … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

This definition is incomplete. Therefore your refutation does not
apply to Linz' proof.

Mikko

It will halt whenever it reaches final state means
if and only if it reaches its final state it halts.

Dosn't matter if you can't write a publishable proof.

Mikko

The code <is> the proof.

--
Copyright 2022 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 6/19/22 2:09 PM, olcott wrote:

On 6/19/2022 12:35 PM, Mikko wrote:

On 2022-06-19 15:59:55 +0000, olcott said:

On 6/19/2022 10:54 AM, Mikko wrote:

On 2022-06-19 15:13:00 +0000, olcott said:

computation that halts … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

This definition is incomplete. Therefore your refutation does not
apply to Linz' proof.

Mikko

It will halt whenever it reaches final state means
if and only if it reaches its final state it halts.

Dosn't matter if you can't write a publishable proof.

Mikko

The code <is> the proof.

WHAT code? You haven't shown any code that does the magic you claim.

You last code sample hide the magic halt detection in a function that
wasn't shown, just described as detecting the mythical halting pattern
that exists in P(P) that actually correctly detects that it doesn't
halt, even if H(P,P) return the 0 to it which causes it to halt.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

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:

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.

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

If H aborts its emulation and returns an answer, then the right answer
would be 1.

This case is NOT pathological, and if you assume that H can detect
recursion to itself, can actually be solved, so not pathological.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)