XPost: comp.theory, sci.logic

On 2/10/23 6:46 PM, olcott wrote:

Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

Right, and NO HH that "correctly" simulates its input (per the
definition that allows it to replace the direct execution of its input)
of E ever gives an answer.

An HH that does, isn't an HH as described above.

So, any logic comparing them is BROKEN.

PERIOD.

You claims otherwise just prove you are a pathological liar.

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

XPost: comp.theory, sci.logic

Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

void E(int (*x)())
{
HH(x, x);
return;
}

int main()
{
HH(E,E);
}

_E()
[00001d40] 55 push ebp
[00001d41] 8bec mov ebp,esp
[00001d43] 8b4508 mov eax,[ebp+08]
[00001d46] 50 push eax
[00001d47] 8b4d08 mov ecx,[ebp+08]
[00001d4a] 51 push ecx
[00001d4b] e820f6ffff call 00001370
[00001d50] 83c408 add esp,+08
[00001d53] 5d pop ebp
[00001d54] c3 ret
Size in bytes:(0021) [00001d54]

_main()
[00001d60] 55 push ebp
[00001d61] 8bec mov ebp,esp
[00001d63] 68401d0000 push 00001d40
[00001d68] 68401d0000 push 00001d40
[00001d6d] e8fef5ffff call 00001370
[00001d72] 83c408 add esp,+08
[00001d75] 33c0 xor eax,eax
[00001d77] 5d pop ebp
[00001d78] c3 ret
Size in bytes:(0025) [00001d78]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= [00001d60][00103017][00000000] 55 push ebp [00001d61][00103017][00000000] 8bec mov ebp,esp [00001d63][00103013][00001d40] 68401d0000 push 00001d40 [00001d68][0010300f][00001d40] 68401d0000 push 00001d40 [00001d6d][0010300b][00001d72] e8fef5ffff call 00001370
New slave_stack at:1030bb

Begin Local Halt Decider Simulation Execution Trace Stored at:1130c3 [00001d40][001130af][001130b3] 55 push ebp // begin E [00001d41][001130af][001130b3] 8bec mov ebp,esp [00001d43][001130af][001130b3] 8b4508 mov eax,[ebp+08] [00001d46][001130ab][00001d40] 50 push eax // push address of E [00001d47][001130ab][00001d40] 8b4d08 mov ecx,[ebp+08] [00001d4a][001130a7][00001d40] 51 push ecx // push address of E [00001d4b][001130a3][00001d50] e820f6ffff call 00001370 // call HH
New slave_stack at:14dae3
[00001d40][0015dad7][0015dadb] 55 push ebp // begin E [00001d41][0015dad7][0015dadb] 8bec mov ebp,esp [00001d43][0015dad7][0015dadb] 8b4508 mov eax,[ebp+08] [00001d46][0015dad3][00001d40] 50 push eax // push address of E [00001d47][0015dad3][00001d40] 8b4d08 mov ecx,[ebp+08] [00001d4a][0015dacf][00001d40] 51 push ecx // push address of E [00001d4b][0015dacb][00001d50] e820f6ffff call 00001370 // call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001d72][00103017][00000000] 83c408 add esp,+08 [00001d75][00103017][00000000] 33c0 xor eax,eax [00001d77][0010301b][00000018] 5d pop ebp [00001d78][0010301f][00000000] c3 ret
Number of Instructions Executed(15319) == 229 Pages

--
Copyright 2023 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 2/10/2023 5:46 PM, olcott wrote:

Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

void E(int (*x)())
{
  HH(x, x);
  return;
}

int main()
{
  HH(E,E);
}

_E()
[00001d40] 55             push ebp
[00001d41] 8bec           mov ebp,esp
[00001d43] 8b4508         mov eax,[ebp+08]
[00001d46] 50             push eax
[00001d47] 8b4d08         mov ecx,[ebp+08]
[00001d4a] 51             push ecx
[00001d4b] e820f6ffff     call 00001370
[00001d50] 83c408         add esp,+08
[00001d53] 5d             pop ebp
[00001d54] c3             ret
Size in bytes:(0021) [00001d54]

_main()
[00001d60] 55             push ebp
[00001d61] 8bec           mov ebp,esp
[00001d63] 68401d0000     push 00001d40
[00001d68] 68401d0000     push 00001d40
[00001d6d] e8fef5ffff     call 00001370
[00001d72] 83c408         add esp,+08
[00001d75] 33c0           xor eax,eax
[00001d77] 5d             pop ebp
[00001d78] c3             ret
Size in bytes:(0025) [00001d78]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  =========  ============= [00001d60][00103017][00000000] 55         push ebp [00001d61][00103017][00000000] 8bec       mov ebp,esp [00001d63][00103013][00001d40] 68401d0000 push 00001d40 [00001d68][0010300f][00001d40] 68401d0000 push 00001d40 [00001d6d][0010300b][00001d72] e8fef5ffff call 00001370
New slave_stack at:1030bb

Begin Local Halt Decider Simulation   Execution Trace Stored at:1130c3 [00001d40][001130af][001130b3] 55         push ebp      // begin E
[00001d41][001130af][001130b3] 8bec       mov ebp,esp [00001d43][001130af][001130b3] 8b4508     mov eax,[ebp+08] [00001d46][001130ab][00001d40] 50         push eax      // push address
of E
[00001d47][001130ab][00001d40] 8b4d08     mov ecx,[ebp+08] [00001d4a][001130a7][00001d40] 51         push ecx      // push address
of E
[00001d4b][001130a3][00001d50] e820f6ffff call 00001370 // call HH
New slave_stack at:14dae3
[00001d40][0015dad7][0015dadb] 55         push ebp      // begin E
[00001d41][0015dad7][0015dadb] 8bec       mov ebp,esp [00001d43][0015dad7][0015dadb] 8b4508     mov eax,[ebp+08] [00001d46][0015dad3][00001d40] 50         push eax      // push address
of E
[00001d47][0015dad3][00001d40] 8b4d08     mov ecx,[ebp+08] [00001d4a][0015dacf][00001d40] 51         push ecx      // push address
of E
[00001d4b][0015dacb][00001d50] e820f6ffff call 00001370 // call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001d72][00103017][00000000] 83c408     add esp,+08 [00001d75][00103017][00000000] 33c0       xor eax,eax [00001d77][0010301b][00000018] 5d         pop ebp [00001d78][0010301f][00000000] c3         ret
Number of Instructions Executed(15319) == 229 Pages

Because Every E correctly simulated by any HH cannot possibly halt any
HH that detects this is correct to abort its simulation and reject its
input as non-halting.

No halt decider is ever required to simulate any number of steps of its
input. Halt deciders are only required to correctly predict whether or
not their input can possibly reach its own final state and terminate
normally.

Simulating halt decider HH computes the mapping from its input E to an
accept or reject state on the basis of the behavior of E correctly
simulated by HH. As soon as HH has simulated enough steps of E to
correctly predict that E cannot possibly reach its own final state then
HH is correct to abort its simulation of E and reject E as non-halting.


--
Copyright 2023 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 2/10/23 7:29 PM, olcott wrote:

On 2/10/2023 5:46 PM, olcott wrote:

Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

void E(int (*x)())
{
   HH(x, x);
   return;
}

int main()
{
   HH(E,E);
}

_E()
[00001d40] 55             push ebp
[00001d41] 8bec           mov ebp,esp
[00001d43] 8b4508         mov eax,[ebp+08]
[00001d46] 50             push eax
[00001d47] 8b4d08         mov ecx,[ebp+08]
[00001d4a] 51             push ecx
[00001d4b] e820f6ffff     call 00001370
[00001d50] 83c408         add esp,+08
[00001d53] 5d             pop ebp
[00001d54] c3             ret
Size in bytes:(0021) [00001d54]

_main()
[00001d60] 55             push ebp
[00001d61] 8bec           mov ebp,esp
[00001d63] 68401d0000     push 00001d40
[00001d68] 68401d0000     push 00001d40
[00001d6d] e8fef5ffff     call 00001370
[00001d72] 83c408         add esp,+08
[00001d75] 33c0           xor eax,eax
[00001d77] 5d             pop ebp
[00001d78] c3             ret
Size in bytes:(0025) [00001d78]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00001d60][00103017][00000000] 55         push ebp
[00001d61][00103017][00000000] 8bec       mov ebp,esp
[00001d63][00103013][00001d40] 68401d0000 push 00001d40
[00001d68][0010300f][00001d40] 68401d0000 push 00001d40
[00001d6d][0010300b][00001d72] e8fef5ffff call 00001370
New slave_stack at:1030bb

Begin Local Halt Decider Simulation   Execution Trace Stored at:1130c3
[00001d40][001130af][001130b3] 55         push ebp      // begin E
[00001d41][001130af][001130b3] 8bec       mov ebp,esp
[00001d43][001130af][001130b3] 8b4508     mov eax,[ebp+08]
[00001d46][001130ab][00001d40] 50         push eax      // push >> address of E
[00001d47][001130ab][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][001130a7][00001d40] 51         push ecx      // push >> address of E
[00001d4b][001130a3][00001d50] e820f6ffff call 00001370 // call HH
New slave_stack at:14dae3
[00001d40][0015dad7][0015dadb] 55         push ebp      // begin E
[00001d41][0015dad7][0015dadb] 8bec       mov ebp,esp
[00001d43][0015dad7][0015dadb] 8b4508     mov eax,[ebp+08]
[00001d46][0015dad3][00001d40] 50         push eax      // push >> address of E
[00001d47][0015dad3][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][0015dacf][00001d40] 51         push ecx      // push >> address of E
[00001d4b][0015dacb][00001d50] e820f6ffff call 00001370 // call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001d72][00103017][00000000] 83c408     add esp,+08
[00001d75][00103017][00000000] 33c0       xor eax,eax
[00001d77][0010301b][00000018] 5d         pop ebp
[00001d78][0010301f][00000000] c3         ret
Number of Instructions Executed(15319) == 229 Pages

Because Every E correctly simulated by any HH cannot possibly halt any
HH that detects this is correct to abort its simulation and reject its
input as non-halting.

There is only ONE E for any given HH, and the only one that actually
matters is the one built for the HH that you want to claim to be correct.

It doesn't matter AT ALL, that some other E buit on some other HH that
does a complete simulation can be shown to not halt.

Your continued reference to things that are not the input to THIS HH,
just shows you are either totally ignorant of what you are talking about
or are just a pathological liar.

Your continued renaming of things that you want to define the same, and
at the same time reusing names for things that are different shows
strong evidence that you are intentionally trying to be deceptive.

WIthout some indication, there should be JUST ONE thing called E, and
ont thing called HH, as the term "Every E" shows a total
misunderstanding of the problem space.

Given that you claim that HH(E,E) is "correctly" returning 0, we can see
by simple inspection that E(E) will halt, and thus HH is INCORRECT in
its answer and its simulation.

PERIOD.

No halt decider is ever required to simulate any number of steps of its input. Halt deciders are only required to correctly predict whether or
not their input can possibly reach its own final state and terminate normally.

Right, they don't need to do the actual simulation, but need to predict
the behavior of what a UTM simulation of the input would do (NOT the
behavior of their own PARTIAL simulation)

Simulating halt decider HH computes the mapping from its input E to an
accept or reject state on the basis of the behavior of E correctly
simulated by HH. As soon as HH has simulated enough steps of E to
correctly predict that E cannot possibly reach its own final state then
HH is correct to abort its simulation of E and reject E as non-halting.

No, based on HH's "Correct" prediction of what the UTM simulation of the
input to HH would do.

Since HH DOESN'T DO a "Correct Simulate" per the definition of a UTM,
its simulation is IRRELEVENT.

YOU ARE JUST PROVING YOU DON'T UNDERSTAND WHAT YOU ARE TALKING ABOUT.

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

XPost: comp.theory, sci.logic

On 2/10/2023 6:29 PM, olcott wrote:

On 2/10/2023 5:46 PM, olcott wrote:

Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

void E(int (*x)())
{
   HH(x, x);
   return;
}

int main()
{
   HH(E,E);
}

_E()
[00001d40] 55             push ebp
[00001d41] 8bec           mov ebp,esp
[00001d43] 8b4508         mov eax,[ebp+08]
[00001d46] 50             push eax
[00001d47] 8b4d08         mov ecx,[ebp+08]
[00001d4a] 51             push ecx
[00001d4b] e820f6ffff     call 00001370
[00001d50] 83c408         add esp,+08
[00001d53] 5d             pop ebp
[00001d54] c3             ret
Size in bytes:(0021) [00001d54]

_main()
[00001d60] 55             push ebp
[00001d61] 8bec           mov ebp,esp
[00001d63] 68401d0000     push 00001d40
[00001d68] 68401d0000     push 00001d40
[00001d6d] e8fef5ffff     call 00001370
[00001d72] 83c408         add esp,+08
[00001d75] 33c0           xor eax,eax
[00001d77] 5d             pop ebp
[00001d78] c3             ret
Size in bytes:(0025) [00001d78]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00001d60][00103017][00000000] 55         push ebp
[00001d61][00103017][00000000] 8bec       mov ebp,esp
[00001d63][00103013][00001d40] 68401d0000 push 00001d40
[00001d68][0010300f][00001d40] 68401d0000 push 00001d40
[00001d6d][0010300b][00001d72] e8fef5ffff call 00001370
New slave_stack at:1030bb

Begin Local Halt Decider Simulation   Execution Trace Stored at:1130c3
[00001d40][001130af][001130b3] 55         push ebp      // begin E
[00001d41][001130af][001130b3] 8bec       mov ebp,esp
[00001d43][001130af][001130b3] 8b4508     mov eax,[ebp+08]
[00001d46][001130ab][00001d40] 50         push eax      // push >> address of E
[00001d47][001130ab][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][001130a7][00001d40] 51         push ecx      // push >> address of E
[00001d4b][001130a3][00001d50] e820f6ffff call 00001370 // call HH
New slave_stack at:14dae3
[00001d40][0015dad7][0015dadb] 55         push ebp      // begin E
[00001d41][0015dad7][0015dadb] 8bec       mov ebp,esp
[00001d43][0015dad7][0015dadb] 8b4508     mov eax,[ebp+08]
[00001d46][0015dad3][00001d40] 50         push eax      // push >> address of E
[00001d47][0015dad3][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][0015dacf][00001d40] 51         push ecx      // push >> address of E
[00001d4b][0015dacb][00001d50] e820f6ffff call 00001370 // call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001d72][00103017][00000000] 83c408     add esp,+08
[00001d75][00103017][00000000] 33c0       xor eax,eax
[00001d77][0010301b][00000018] 5d         pop ebp
[00001d78][0010301f][00000000] c3         ret
Number of Instructions Executed(15319) == 229 Pages

Because Every E correctly simulated by any HH cannot possibly halt any
HH that detects this is correct to abort its simulation and reject its
input as non-halting.

No halt decider is ever required to simulate any number of steps of its input. Halt deciders are only required to correctly predict whether or
not their input can possibly reach its own final state and terminate normally.

Simulating halt decider HH computes the mapping from its input E to an
accept or reject state on the basis of the behavior of E correctly
simulated by HH. As soon as HH has simulated enough steps of E to
correctly predict that E cannot possibly reach its own final state then
HH is correct to abort its simulation of E and reject E as non-halting.

When we have examined every element of the infinite set of HH/E pairs
and and found that no E correctly simulated by HH ever halts then it is necessarily correct for HH(E,E) to reject its input as non-halting.

When we find a pea under every shell of the shell game then it is
impossible to do a switch-a-roo and hide the pea under a different
shell. https://en.wikipedia.org/wiki/Shell_game

--
Copyright 2023 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 2/10/23 11:03 PM, olcott wrote:

On 2/10/2023 6:29 PM, olcott wrote:

On 2/10/2023 5:46 PM, olcott wrote:

Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

void E(int (*x)())
{
   HH(x, x);
   return;
}

int main()
{
   HH(E,E);
}

_E()
[00001d40] 55             push ebp
[00001d41] 8bec           mov ebp,esp
[00001d43] 8b4508         mov eax,[ebp+08]
[00001d46] 50             push eax
[00001d47] 8b4d08         mov ecx,[ebp+08]
[00001d4a] 51             push ecx
[00001d4b] e820f6ffff     call 00001370
[00001d50] 83c408         add esp,+08
[00001d53] 5d             pop ebp
[00001d54] c3             ret
Size in bytes:(0021) [00001d54]

_main()
[00001d60] 55             push ebp
[00001d61] 8bec           mov ebp,esp
[00001d63] 68401d0000     push 00001d40
[00001d68] 68401d0000     push 00001d40
[00001d6d] e8fef5ffff     call 00001370
[00001d72] 83c408         add esp,+08
[00001d75] 33c0           xor eax,eax
[00001d77] 5d             pop ebp
[00001d78] c3             ret
Size in bytes:(0025) [00001d78]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00001d60][00103017][00000000] 55         push ebp
[00001d61][00103017][00000000] 8bec       mov ebp,esp
[00001d63][00103013][00001d40] 68401d0000 push 00001d40
[00001d68][0010300f][00001d40] 68401d0000 push 00001d40
[00001d6d][0010300b][00001d72] e8fef5ffff call 00001370
New slave_stack at:1030bb

Begin Local Halt Decider Simulation   Execution Trace Stored at:1130c3 >>> [00001d40][001130af][001130b3] 55         push ebp      // begin E
[00001d41][001130af][001130b3] 8bec       mov ebp,esp
[00001d43][001130af][001130b3] 8b4508     mov eax,[ebp+08]
[00001d46][001130ab][00001d40] 50         push eax      // push
address of E
[00001d47][001130ab][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][001130a7][00001d40] 51         push ecx      // push
address of E
[00001d4b][001130a3][00001d50] e820f6ffff call 00001370 // call HH
New slave_stack at:14dae3
[00001d40][0015dad7][0015dadb] 55         push ebp      // begin E
[00001d41][0015dad7][0015dadb] 8bec       mov ebp,esp
[00001d43][0015dad7][0015dadb] 8b4508     mov eax,[ebp+08]
[00001d46][0015dad3][00001d40] 50         push eax      // push
address of E
[00001d47][0015dad3][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][0015dacf][00001d40] 51         push ecx      // push
address of E
[00001d4b][0015dacb][00001d50] e820f6ffff call 00001370 // call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001d72][00103017][00000000] 83c408     add esp,+08
[00001d75][00103017][00000000] 33c0       xor eax,eax
[00001d77][0010301b][00000018] 5d         pop ebp
[00001d78][0010301f][00000000] c3         ret
Number of Instructions Executed(15319) == 229 Pages

Because Every E correctly simulated by any HH cannot possibly halt any
HH that detects this is correct to abort its simulation and reject its
input as non-halting.

No halt decider is ever required to simulate any number of steps of its
input. Halt deciders are only required to correctly predict whether or
not their input can possibly reach its own final state and terminate
normally.

Simulating halt decider HH computes the mapping from its input E to an
accept or reject state on the basis of the behavior of E correctly
simulated by HH. As soon as HH has simulated enough steps of E to
correctly predict that E cannot possibly reach its own final state then
HH is correct to abort its simulation of E and reject E as non-halting.

When we have examined every element of the infinite set of HH/E pairs
and and found that no E correctly simulated by HH ever halts then it is necessarily correct for HH(E,E) to reject its input as non-halting.

So, you are admitting that you are making a category error? The Halting
Problem is about SPECIFIC DECIDERS and SPECIFIC INPUTS, not "Sets of
Deciders" and "Sets of Inputs".

How do you give a "Set" an Input?

How do you give an infinite Set as an Input?

What is the x86 assembly code for any of these "Sets"?

You need to distinguish the individual elements of the set, if we call
HHi a specific instance of the deciders in the set HH, and Ei the
specific instance of the set E that is built on HHi, then the key answer
is does HHi get the right answer for HHi(Ei,Ei).

Your analysis looks at HHi(Ej,Ej) for j != i and in fact for HHj being
the decider that never aborts. The only only decider which the answer
for Ej matters, is HHj, and since that one never aborts is simulation,
it never answers.

When we find a pea under every shell of the shell game then it is
impossible to do a switch-a-roo and hide the pea under a different
shell. https://en.wikipedia.org/wiki/Shell_game

But you DON'T look under every shell. You only look at a small class of
the cases, and NEVER the case that is actually requird, where the HH
that E calls is the identical code to the HH that is deciding it.

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

XPost: comp.theory, sci.logic

On 2/10/23 6:46 PM, olcott wrote:

Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

Another way to point out your error.

Given your SETS HH and E, and their members HHi, Ei where HHi is a
specific instance of a Halt Decider and Ei is the E built from it.

Yes, there exist a SUBSET of E, En where it can be shown that each of Ei
in that set is simulated by its HHi correctly and completely showing it
is non-halting.

None of these HHi correctly indicate that its input is non-halting, and
there is a set HHc where each of the HHj can correctly indicate that the
Ei is non-halting, but in NO case is i == j, so in no case has the HHj
given a correct answer for the Ej that it needs to in order to be a
"counter" to the Halting Problem Proof.


Note, the definition of Halting is NOT that the "Decider" can simulate
the input to a Halt State, but could be described as one where a UTM
will simulate to a Final State, and Non-Halting is that the UTM will
never reach such a final state. A decider aborting its simulation before reaching the final state is NOT defined as showing "Non-Halting".

To claim it is, is to admit you don't understand the definitions of the
field, or that you are just a pathological liar.

You are showing yourself to be INTENTIONALLY deceptive by loose (and
incorrect) terminology.

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

XPost: comp.theory, sci.logic

On 2/10/2023 10:03 PM, olcott wrote:

On 2/10/2023 6:29 PM, olcott wrote:

On 2/10/2023 5:46 PM, olcott wrote:

Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

void E(int (*x)())
{
   HH(x, x);
   return;
}

int main()
{
   HH(E,E);
}

_E()
[00001d40] 55             push ebp
[00001d41] 8bec           mov ebp,esp
[00001d43] 8b4508         mov eax,[ebp+08]
[00001d46] 50             push eax
[00001d47] 8b4d08         mov ecx,[ebp+08]
[00001d4a] 51             push ecx
[00001d4b] e820f6ffff     call 00001370
[00001d50] 83c408         add esp,+08
[00001d53] 5d             pop ebp
[00001d54] c3             ret
Size in bytes:(0021) [00001d54]

_main()
[00001d60] 55             push ebp
[00001d61] 8bec           mov ebp,esp
[00001d63] 68401d0000     push 00001d40
[00001d68] 68401d0000     push 00001d40
[00001d6d] e8fef5ffff     call 00001370
[00001d72] 83c408         add esp,+08
[00001d75] 33c0           xor eax,eax
[00001d77] 5d             pop ebp
[00001d78] c3             ret
Size in bytes:(0025) [00001d78]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00001d60][00103017][00000000] 55         push ebp
[00001d61][00103017][00000000] 8bec       mov ebp,esp
[00001d63][00103013][00001d40] 68401d0000 push 00001d40
[00001d68][0010300f][00001d40] 68401d0000 push 00001d40
[00001d6d][0010300b][00001d72] e8fef5ffff call 00001370
New slave_stack at:1030bb

Begin Local Halt Decider Simulation   Execution Trace Stored at:1130c3 >>> [00001d40][001130af][001130b3] 55         push ebp      // begin E
[00001d41][001130af][001130b3] 8bec       mov ebp,esp
[00001d43][001130af][001130b3] 8b4508     mov eax,[ebp+08]
[00001d46][001130ab][00001d40] 50         push eax      // push
address of E
[00001d47][001130ab][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][001130a7][00001d40] 51         push ecx      // push
address of E
[00001d4b][001130a3][00001d50] e820f6ffff call 00001370 // call HH
New slave_stack at:14dae3
[00001d40][0015dad7][0015dadb] 55         push ebp      // begin E
[00001d41][0015dad7][0015dadb] 8bec       mov ebp,esp
[00001d43][0015dad7][0015dadb] 8b4508     mov eax,[ebp+08]
[00001d46][0015dad3][00001d40] 50         push eax      // push
address of E
[00001d47][0015dad3][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][0015dacf][00001d40] 51         push ecx      // push
address of E
[00001d4b][0015dacb][00001d50] e820f6ffff call 00001370 // call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001d72][00103017][00000000] 83c408     add esp,+08
[00001d75][00103017][00000000] 33c0       xor eax,eax
[00001d77][0010301b][00000018] 5d         pop ebp
[00001d78][0010301f][00000000] c3         ret
Number of Instructions Executed(15319) == 229 Pages

Because Every E correctly simulated by any HH cannot possibly halt any
HH that detects this is correct to abort its simulation and reject its
input as non-halting.

No halt decider is ever required to simulate any number of steps of its
input. Halt deciders are only required to correctly predict whether or
not their input can possibly reach its own final state and terminate
normally.

Simulating halt decider HH computes the mapping from its input E to an
accept or reject state on the basis of the behavior of E correctly
simulated by HH. As soon as HH has simulated enough steps of E to
correctly predict that E cannot possibly reach its own final state then
HH is correct to abort its simulation of E and reject E as non-halting.

When we have examined every element of the infinite set of HH/E pairs
and and found that no E correctly simulated by HH ever halts then it is necessarily correct for HH(E,E) to reject its input as non-halting.

When we find a pea under every shell of the shell game then it is
impossible to do a switch-a-roo and hide the pea under a different
shell. https://en.wikipedia.org/wiki/Shell_game

∀HH ∈ (E is correctly simulated by H) (¬∃(HH/E pair) Halts(E))
∴ HH(E,E)==0 is correct for every HH that aborts its simulation of E.

HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally.

Simulating halt deciders must compute the mapping from their inputs to
their own accept or reject state on the basis of their correct
simulation of their input up to the point when they correctly determine
that E correctly simulated by HH cannot possibly reach its own final
state an terminate normally.

In the same way that Sum(3,4) must compute the sum of 3+4 and is not
allowed to compute the sum of 2+6 HH is only allowed to report on the
behavior of E simulated by HH. As soon as HH correctly detects that E
has a repeating state HH is correct to abort its simulation and reject
its input as non-halting.





--
Copyright 2023 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 2/11/23 10:29 AM, olcott wrote:

On 2/10/2023 10:03 PM, olcott wrote:

On 2/10/2023 6:29 PM, olcott wrote:

On 2/10/2023 5:46 PM, olcott wrote:

Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

void E(int (*x)())
{
   HH(x, x);
   return;
}

int main()
{
   HH(E,E);
}

_E()
[00001d40] 55             push ebp
[00001d41] 8bec           mov ebp,esp
[00001d43] 8b4508         mov eax,[ebp+08]
[00001d46] 50             push eax
[00001d47] 8b4d08         mov ecx,[ebp+08]
[00001d4a] 51             push ecx
[00001d4b] e820f6ffff     call 00001370
[00001d50] 83c408         add esp,+08
[00001d53] 5d             pop ebp
[00001d54] c3             ret
Size in bytes:(0021) [00001d54]

_main()
[00001d60] 55             push ebp
[00001d61] 8bec           mov ebp,esp
[00001d63] 68401d0000     push 00001d40
[00001d68] 68401d0000     push 00001d40
[00001d6d] e8fef5ffff     call 00001370
[00001d72] 83c408         add esp,+08
[00001d75] 33c0           xor eax,eax
[00001d77] 5d             pop ebp
[00001d78] c3             ret
Size in bytes:(0025) [00001d78]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00001d60][00103017][00000000] 55         push ebp
[00001d61][00103017][00000000] 8bec       mov ebp,esp
[00001d63][00103013][00001d40] 68401d0000 push 00001d40
[00001d68][0010300f][00001d40] 68401d0000 push 00001d40
[00001d6d][0010300b][00001d72] e8fef5ffff call 00001370
New slave_stack at:1030bb

Begin Local Halt Decider Simulation   Execution Trace Stored at:1130c3 >>>> [00001d40][001130af][001130b3] 55         push ebp      // begin E
[00001d41][001130af][001130b3] 8bec       mov ebp,esp
[00001d43][001130af][001130b3] 8b4508     mov eax,[ebp+08]
[00001d46][001130ab][00001d40] 50         push eax      // push
address of E
[00001d47][001130ab][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][001130a7][00001d40] 51         push ecx      // push
address of E
[00001d4b][001130a3][00001d50] e820f6ffff call 00001370 // call HH
New slave_stack at:14dae3
[00001d40][0015dad7][0015dadb] 55         push ebp      // begin E
[00001d41][0015dad7][0015dadb] 8bec       mov ebp,esp
[00001d43][0015dad7][0015dadb] 8b4508     mov eax,[ebp+08]
[00001d46][0015dad3][00001d40] 50         push eax      // push
address of E
[00001d47][0015dad3][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][0015dacf][00001d40] 51         push ecx      // push
address of E
[00001d4b][0015dacb][00001d50] e820f6ffff call 00001370 // call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001d72][00103017][00000000] 83c408     add esp,+08
[00001d75][00103017][00000000] 33c0       xor eax,eax
[00001d77][0010301b][00000018] 5d         pop ebp
[00001d78][0010301f][00000000] c3         ret
Number of Instructions Executed(15319) == 229 Pages

Because Every E correctly simulated by any HH cannot possibly halt any
HH that detects this is correct to abort its simulation and reject its
input as non-halting.

No halt decider is ever required to simulate any number of steps of its
input. Halt deciders are only required to correctly predict whether or
not their input can possibly reach its own final state and terminate
normally.

Simulating halt decider HH computes the mapping from its input E to an
accept or reject state on the basis of the behavior of E correctly
simulated by HH. As soon as HH has simulated enough steps of E to
correctly predict that E cannot possibly reach its own final state then
HH is correct to abort its simulation of E and reject E as non-halting.

When we have examined every element of the infinite set of HH/E pairs
and and found that no E correctly simulated by HH ever halts then it is
necessarily correct for HH(E,E) to reject its input as non-halting.

When we find a pea under every shell of the shell game then it is
impossible to do a switch-a-roo and hide the pea under a different
shell. https://en.wikipedia.org/wiki/Shell_game

∀HH ∈ (E is correctly simulated by H) (¬∃(HH/E pair) Halts(E))
∴ HH(E,E)==0 is correct for every HH that aborts its simulation of E.

HH !+ H so irrelevnt.

HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally.

No, it needs to simulate until it determines that a CORRECT and COMPLETE simulation will not reach a final state.

Note, HH must have a defined behavior, if HH DOES abort at a given
point, you can not hypothesize it simulating past that point if doing so changes its behavior as used by E. Such an action is in your own words,
a blattant lie, as it its looking at the ACTUAL input, where the
DEFINITE machine E is based on the DEFINITE machine H which is giving
the decision, and not some hypothetical alternate that behaves differently.

You are just admitting that you are a stinking liar, working on a straw
man problem, as you aren't looking at the input actually given.

Simulating halt deciders must compute the mapping from their inputs to
their own accept or reject state on the basis of their correct
simulation of their input up to the point when they correctly determine
that E correctly simulated by HH cannot possibly reach its own final
state an terminate normally.

No, they must compute the mapping of their input to the CORRECT answer
for the problem they are defined to solve.

For a Halting Decider, H, that is if the machine described by its input
when applied to the input it is also given will Halt.

Thus, all you re proving is you don't know what you are talking about or
that you are just a pathological liar, as the Halting Problem does not,
and CAN not depend on the behavior of the Decider, as it is a property
of JUST the input.

You are just proving your utter stupditiy by keep on claiming illogical
basis for your decision.

In the same way that Sum(3,4) must compute the sum of 3+4 and is not
allowed to compute the sum of 2+6 HH is only allowed to report on the behavior of E simulated by HH. As soon as HH correctly detects that E
has a repeating state HH is correct to abort its simulation and reject
its input as non-halting.

Right, so HH(D,D) must compute if D(D) will Halt, or UTM(D,D) will halt. PERIOD.

You admit that that D(D) will halt if HH(D,D) returns 0, so you have
agreed that the the only possibly correct answer by the definition is
Halting, but you some how claim that non-halting is also correct.

Thus you are admitting that your logic system think halting ==
non-halting and is thus inconsistent.

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

XPost: comp.theory, sci.logic

On 2/11/2023 9:29 AM, olcott wrote:

On 2/10/2023 10:03 PM, olcott wrote:

On 2/10/2023 6:29 PM, olcott wrote:

On 2/10/2023 5:46 PM, olcott wrote:

Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

void E(int (*x)())
{
   HH(x, x);
   return;
}

int main()
{
   HH(E,E);
}

_E()
[00001d40] 55             push ebp
[00001d41] 8bec           mov ebp,esp
[00001d43] 8b4508         mov eax,[ebp+08]
[00001d46] 50             push eax
[00001d47] 8b4d08         mov ecx,[ebp+08]
[00001d4a] 51             push ecx
[00001d4b] e820f6ffff     call 00001370
[00001d50] 83c408         add esp,+08
[00001d53] 5d             pop ebp
[00001d54] c3             ret
Size in bytes:(0021) [00001d54]

_main()
[00001d60] 55             push ebp
[00001d61] 8bec           mov ebp,esp
[00001d63] 68401d0000     push 00001d40
[00001d68] 68401d0000     push 00001d40
[00001d6d] e8fef5ffff     call 00001370
[00001d72] 83c408         add esp,+08
[00001d75] 33c0           xor eax,eax
[00001d77] 5d             pop ebp
[00001d78] c3             ret
Size in bytes:(0025) [00001d78]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00001d60][00103017][00000000] 55         push ebp
[00001d61][00103017][00000000] 8bec       mov ebp,esp
[00001d63][00103013][00001d40] 68401d0000 push 00001d40
[00001d68][0010300f][00001d40] 68401d0000 push 00001d40
[00001d6d][0010300b][00001d72] e8fef5ffff call 00001370
New slave_stack at:1030bb

Begin Local Halt Decider Simulation   Execution Trace Stored at:1130c3 >>>> [00001d40][001130af][001130b3] 55         push ebp      // begin E
[00001d41][001130af][001130b3] 8bec       mov ebp,esp
[00001d43][001130af][001130b3] 8b4508     mov eax,[ebp+08]
[00001d46][001130ab][00001d40] 50         push eax      // push
address of E
[00001d47][001130ab][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][001130a7][00001d40] 51         push ecx      // push
address of E
[00001d4b][001130a3][00001d50] e820f6ffff call 00001370 // call HH
New slave_stack at:14dae3
[00001d40][0015dad7][0015dadb] 55         push ebp      // begin E
[00001d41][0015dad7][0015dadb] 8bec       mov ebp,esp
[00001d43][0015dad7][0015dadb] 8b4508     mov eax,[ebp+08]
[00001d46][0015dad3][00001d40] 50         push eax      // push
address of E
[00001d47][0015dad3][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][0015dacf][00001d40] 51         push ecx      // push
address of E
[00001d4b][0015dacb][00001d50] e820f6ffff call 00001370 // call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001d72][00103017][00000000] 83c408     add esp,+08
[00001d75][00103017][00000000] 33c0       xor eax,eax
[00001d77][0010301b][00000018] 5d         pop ebp
[00001d78][0010301f][00000000] c3         ret
Number of Instructions Executed(15319) == 229 Pages

Because Every E correctly simulated by any HH cannot possibly halt any
HH that detects this is correct to abort its simulation and reject its
input as non-halting.

No halt decider is ever required to simulate any number of steps of its
input. Halt deciders are only required to correctly predict whether or
not their input can possibly reach its own final state and terminate
normally.

Simulating halt decider HH computes the mapping from its input E to an
accept or reject state on the basis of the behavior of E correctly
simulated by HH. As soon as HH has simulated enough steps of E to
correctly predict that E cannot possibly reach its own final state then
HH is correct to abort its simulation of E and reject E as non-halting.

When we have examined every element of the infinite set of HH/E pairs
and and found that no E correctly simulated by HH ever halts then it is
necessarily correct for HH(E,E) to reject its input as non-halting.

When we find a pea under every shell of the shell game then it is
impossible to do a switch-a-roo and hide the pea under a different
shell. https://en.wikipedia.org/wiki/Shell_game

∀HH ∈ (E is correctly simulated by H) (¬∃(HH/E pair) Halts(E))
∴ HH(E,E)==0 is correct for every HH that aborts its simulation of E.

HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally.

Simulating halt deciders must compute the mapping from their inputs to
their own accept or reject state on the basis of their correct
simulation of their input up to the point when they correctly determine
that E correctly simulated by HH cannot possibly reach its own final
state an terminate normally.

In the same way that Sum(3,4) must compute the sum of 3+4 and is not
allowed to compute the sum of 2+6 HH is only allowed to report on the behavior of E simulated by HH. As soon as HH correctly detects that E
has a repeating state HH is correct to abort its simulation and reject
its input as non-halting.

HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally in any finite number of
steps.

--
Copyright 2023 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 2/11/23 11:17 AM, olcott wrote:

On 2/11/2023 9:29 AM, olcott wrote:

On 2/10/2023 10:03 PM, olcott wrote:

On 2/10/2023 6:29 PM, olcott wrote:

On 2/10/2023 5:46 PM, olcott wrote:

Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

void E(int (*x)())
{
   HH(x, x);
   return;
}

int main()
{
   HH(E,E);
}

_E()
[00001d40] 55             push ebp
[00001d41] 8bec           mov ebp,esp
[00001d43] 8b4508         mov eax,[ebp+08]
[00001d46] 50             push eax
[00001d47] 8b4d08         mov ecx,[ebp+08]
[00001d4a] 51             push ecx
[00001d4b] e820f6ffff     call 00001370
[00001d50] 83c408         add esp,+08
[00001d53] 5d             pop ebp
[00001d54] c3             ret
Size in bytes:(0021) [00001d54]

_main()
[00001d60] 55             push ebp
[00001d61] 8bec           mov ebp,esp
[00001d63] 68401d0000     push 00001d40
[00001d68] 68401d0000     push 00001d40
[00001d6d] e8fef5ffff     call 00001370
[00001d72] 83c408         add esp,+08
[00001d75] 33c0           xor eax,eax
[00001d77] 5d             pop ebp
[00001d78] c3             ret
Size in bytes:(0025) [00001d78]

  machine   stack     stack     machine    assembly
  address   address   data      code       language >>>>>   ========  ========  ========  =========  =============
[00001d60][00103017][00000000] 55         push ebp
[00001d61][00103017][00000000] 8bec       mov ebp,esp
[00001d63][00103013][00001d40] 68401d0000 push 00001d40
[00001d68][0010300f][00001d40] 68401d0000 push 00001d40
[00001d6d][0010300b][00001d72] e8fef5ffff call 00001370
New slave_stack at:1030bb

Begin Local Halt Decider Simulation   Execution Trace Stored at:1130c3 >>>>> [00001d40][001130af][001130b3] 55         push ebp      // begin E
[00001d41][001130af][001130b3] 8bec       mov ebp,esp
[00001d43][001130af][001130b3] 8b4508     mov eax,[ebp+08]
[00001d46][001130ab][00001d40] 50         push eax      // push
address of E
[00001d47][001130ab][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][001130a7][00001d40] 51         push ecx      // push
address of E
[00001d4b][001130a3][00001d50] e820f6ffff call 00001370 // call HH
New slave_stack at:14dae3
[00001d40][0015dad7][0015dadb] 55         push ebp      // begin E
[00001d41][0015dad7][0015dadb] 8bec       mov ebp,esp
[00001d43][0015dad7][0015dadb] 8b4508     mov eax,[ebp+08]
[00001d46][0015dad3][00001d40] 50         push eax      // push
address of E
[00001d47][0015dad3][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][0015dacf][00001d40] 51         push ecx      // push
address of E
[00001d4b][0015dacb][00001d50] e820f6ffff call 00001370 // call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001d72][00103017][00000000] 83c408     add esp,+08
[00001d75][00103017][00000000] 33c0       xor eax,eax
[00001d77][0010301b][00000018] 5d         pop ebp
[00001d78][0010301f][00000000] c3         ret
Number of Instructions Executed(15319) == 229 Pages

Because Every E correctly simulated by any HH cannot possibly halt any >>>> HH that detects this is correct to abort its simulation and reject its >>>> input as non-halting.

No halt decider is ever required to simulate any number of steps of its >>>> input. Halt deciders are only required to correctly predict whether or >>>> not their input can possibly reach its own final state and terminate
normally.

Simulating halt decider HH computes the mapping from its input E to an >>>> accept or reject state on the basis of the behavior of E correctly
simulated by HH. As soon as HH has simulated enough steps of E to
correctly predict that E cannot possibly reach its own final state then >>>> HH is correct to abort its simulation of E and reject E as non-halting. >>>>

When we have examined every element of the infinite set of HH/E pairs
and and found that no E correctly simulated by HH ever halts then it is
necessarily correct for HH(E,E) to reject its input as non-halting.

When we find a pea under every shell of the shell game then it is
impossible to do a switch-a-roo and hide the pea under a different
shell. https://en.wikipedia.org/wiki/Shell_game

∀HH ∈ (E is correctly simulated by H) (¬∃(HH/E pair) Halts(E))
∴ HH(E,E)==0 is correct for every HH that aborts its simulation of E.

HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally.

Simulating halt deciders must compute the mapping from their inputs to
their own accept or reject state on the basis of their correct
simulation of their input up to the point when they correctly determine
that E correctly simulated by HH cannot possibly reach its own final
state an terminate normally.

In the same way that Sum(3,4) must compute the sum of 3+4 and is not
allowed to compute the sum of 2+6 HH is only allowed to report on the
behavior of E simulated by HH. As soon as HH correctly detects that E
has a repeating state HH is correct to abort its simulation and reject
its input as non-halting.

HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally in any finite number of steps.

Nope, HH need to simulate E until HH can correct detect that E has a
repeating state such that E correctly simulate [PERIOD] can not possible
reach its own final state.

IF HH terminating this copy of the simulation shows that at a later
point in the simulation, the simulated HH will ALSO terminate its
simulation and return then HH needs to take that behavior into account
in its logic, or it is not processing the input given to it, and the
person claiming it is has just been revealed to be a pathological liar.

"Correct Simulation" is NOT a function of the Simulator, but of the
input, it is a category error to think that the decider used to answer a question about a program makes a difference in the corect answer.

You are just proving your ignorance and stupidity.

Your continued claim you are right without actually trying to actually
rebute the arguenents just shows you are a damned pathological liar.

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

XPost: comp.theory, sci.logic

On 2/11/2023 10:17 AM, olcott wrote:

On 2/11/2023 9:29 AM, olcott wrote:

On 2/10/2023 10:03 PM, olcott wrote:

On 2/10/2023 6:29 PM, olcott wrote:

On 2/10/2023 5:46 PM, olcott wrote:

Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

void E(int (*x)())
{
   HH(x, x);
   return;
}

int main()
{
   HH(E,E);
}

_E()
[00001d40] 55             push ebp
[00001d41] 8bec           mov ebp,esp
[00001d43] 8b4508         mov eax,[ebp+08]
[00001d46] 50             push eax
[00001d47] 8b4d08         mov ecx,[ebp+08]
[00001d4a] 51             push ecx
[00001d4b] e820f6ffff     call 00001370
[00001d50] 83c408         add esp,+08
[00001d53] 5d             pop ebp
[00001d54] c3             ret
Size in bytes:(0021) [00001d54]

_main()
[00001d60] 55             push ebp
[00001d61] 8bec           mov ebp,esp
[00001d63] 68401d0000     push 00001d40
[00001d68] 68401d0000     push 00001d40
[00001d6d] e8fef5ffff     call 00001370
[00001d72] 83c408         add esp,+08
[00001d75] 33c0           xor eax,eax
[00001d77] 5d             pop ebp
[00001d78] c3             ret
Size in bytes:(0025) [00001d78]

  machine   stack     stack     machine    assembly
  address   address   data      code       language >>>>>   ========  ========  ========  =========  =============
[00001d60][00103017][00000000] 55         push ebp
[00001d61][00103017][00000000] 8bec       mov ebp,esp
[00001d63][00103013][00001d40] 68401d0000 push 00001d40
[00001d68][0010300f][00001d40] 68401d0000 push 00001d40
[00001d6d][0010300b][00001d72] e8fef5ffff call 00001370
New slave_stack at:1030bb

Begin Local Halt Decider Simulation   Execution Trace Stored at:1130c3 >>>>> [00001d40][001130af][001130b3] 55         push ebp      // begin E
[00001d41][001130af][001130b3] 8bec       mov ebp,esp
[00001d43][001130af][001130b3] 8b4508     mov eax,[ebp+08]
[00001d46][001130ab][00001d40] 50         push eax      // push
address of E
[00001d47][001130ab][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][001130a7][00001d40] 51         push ecx      // push
address of E
[00001d4b][001130a3][00001d50] e820f6ffff call 00001370 // call HH
New slave_stack at:14dae3
[00001d40][0015dad7][0015dadb] 55         push ebp      // begin E
[00001d41][0015dad7][0015dadb] 8bec       mov ebp,esp
[00001d43][0015dad7][0015dadb] 8b4508     mov eax,[ebp+08]
[00001d46][0015dad3][00001d40] 50         push eax      // push
address of E
[00001d47][0015dad3][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][0015dacf][00001d40] 51         push ecx      // push
address of E
[00001d4b][0015dacb][00001d50] e820f6ffff call 00001370 // call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001d72][00103017][00000000] 83c408     add esp,+08
[00001d75][00103017][00000000] 33c0       xor eax,eax
[00001d77][0010301b][00000018] 5d         pop ebp
[00001d78][0010301f][00000000] c3         ret
Number of Instructions Executed(15319) == 229 Pages

Because Every E correctly simulated by any HH cannot possibly halt any >>>> HH that detects this is correct to abort its simulation and reject its >>>> input as non-halting.

No halt decider is ever required to simulate any number of steps of its >>>> input. Halt deciders are only required to correctly predict whether or >>>> not their input can possibly reach its own final state and terminate
normally.

Simulating halt decider HH computes the mapping from its input E to an >>>> accept or reject state on the basis of the behavior of E correctly
simulated by HH. As soon as HH has simulated enough steps of E to
correctly predict that E cannot possibly reach its own final state then >>>> HH is correct to abort its simulation of E and reject E as non-halting. >>>>

When we have examined every element of the infinite set of HH/E pairs
and and found that no E correctly simulated by HH ever halts then it is
necessarily correct for HH(E,E) to reject its input as non-halting.

When we find a pea under every shell of the shell game then it is
impossible to do a switch-a-roo and hide the pea under a different
shell. https://en.wikipedia.org/wiki/Shell_game

∀HH ∈ (E is correctly simulated by H) (¬∃(HH/E pair) Halts(E))
∴ HH(E,E)==0 is correct for every HH that aborts its simulation of E.

HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally.

Simulating halt deciders must compute the mapping from their inputs to
their own accept or reject state on the basis of their correct
simulation of their input up to the point when they correctly determine
that E correctly simulated by HH cannot possibly reach its own final
state an terminate normally.

In the same way that Sum(3,4) must compute the sum of 3+4 and is not
allowed to compute the sum of 2+6 HH is only allowed to report on the
behavior of E simulated by HH. As soon as HH correctly detects that E
has a repeating state HH is correct to abort its simulation and reject
its input as non-halting.

HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally in any finite number of steps.

Two people with masters degrees in computer science have agreed that E correctly simulated by HH cannot possibly reach its own "return"
instruction in any finite number of steps of correct simulation.

Since this is such simple software engineering it seems to me that
anyone disagreeing knows this too and is simply lying.

--
Copyright 2023 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 2/11/2023 2:54 PM, olcott wrote:

On 2/11/2023 10:17 AM, olcott wrote:

On 2/11/2023 9:29 AM, olcott wrote:

On 2/10/2023 10:03 PM, olcott wrote:

On 2/10/2023 6:29 PM, olcott wrote:

On 2/10/2023 5:46 PM, olcott wrote:

Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

void E(int (*x)())
{
   HH(x, x);
   return;
}

int main()
{
   HH(E,E);
}

_E()
[00001d40] 55             push ebp
[00001d41] 8bec           mov ebp,esp
[00001d43] 8b4508         mov eax,[ebp+08]
[00001d46] 50             push eax
[00001d47] 8b4d08         mov ecx,[ebp+08]
[00001d4a] 51             push ecx
[00001d4b] e820f6ffff     call 00001370
[00001d50] 83c408         add esp,+08
[00001d53] 5d             pop ebp
[00001d54] c3             ret
Size in bytes:(0021) [00001d54]

_main()
[00001d60] 55             push ebp
[00001d61] 8bec           mov ebp,esp
[00001d63] 68401d0000     push 00001d40
[00001d68] 68401d0000     push 00001d40
[00001d6d] e8fef5ffff     call 00001370
[00001d72] 83c408         add esp,+08
[00001d75] 33c0           xor eax,eax
[00001d77] 5d             pop ebp
[00001d78] c3             ret
Size in bytes:(0025) [00001d78]

  machine   stack     stack     machine    assembly >>>>>>   address   address   data      code       language >>>>>>   ========  ========  ========  =========  =============
[00001d60][00103017][00000000] 55         push ebp
[00001d61][00103017][00000000] 8bec       mov ebp,esp
[00001d63][00103013][00001d40] 68401d0000 push 00001d40
[00001d68][0010300f][00001d40] 68401d0000 push 00001d40
[00001d6d][0010300b][00001d72] e8fef5ffff call 00001370
New slave_stack at:1030bb

Begin Local Halt Decider Simulation   Execution Trace Stored
at:1130c3
[00001d40][001130af][001130b3] 55         push ebp      // begin E
[00001d41][001130af][001130b3] 8bec       mov ebp,esp
[00001d43][001130af][001130b3] 8b4508     mov eax,[ebp+08]
[00001d46][001130ab][00001d40] 50         push eax      // push
address of E
[00001d47][001130ab][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][001130a7][00001d40] 51         push ecx      // push
address of E
[00001d4b][001130a3][00001d50] e820f6ffff call 00001370 // call HH >>>>>> New slave_stack at:14dae3
[00001d40][0015dad7][0015dadb] 55         push ebp      // begin E
[00001d41][0015dad7][0015dadb] 8bec       mov ebp,esp
[00001d43][0015dad7][0015dadb] 8b4508     mov eax,[ebp+08]
[00001d46][0015dad3][00001d40] 50         push eax      // push
address of E
[00001d47][0015dad3][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][0015dacf][00001d40] 51         push ecx      // push
address of E
[00001d4b][0015dacb][00001d50] e820f6ffff call 00001370 // call HH >>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped >>>>>>
[00001d72][00103017][00000000] 83c408     add esp,+08
[00001d75][00103017][00000000] 33c0       xor eax,eax
[00001d77][0010301b][00000018] 5d         pop ebp
[00001d78][0010301f][00000000] c3         ret
Number of Instructions Executed(15319) == 229 Pages

Because Every E correctly simulated by any HH cannot possibly halt any >>>>> HH that detects this is correct to abort its simulation and reject its >>>>> input as non-halting.

No halt decider is ever required to simulate any number of steps of
its
input. Halt deciders are only required to correctly predict whether or >>>>> not their input can possibly reach its own final state and terminate >>>>> normally.

Simulating halt decider HH computes the mapping from its input E to an >>>>> accept or reject state on the basis of the behavior of E correctly
simulated by HH. As soon as HH has simulated enough steps of E to
correctly predict that E cannot possibly reach its own final state
then
HH is correct to abort its simulation of E and reject E as
non-halting.

When we have examined every element of the infinite set of HH/E pairs
and and found that no E correctly simulated by HH ever halts then it is >>>> necessarily correct for HH(E,E) to reject its input as non-halting.

When we find a pea under every shell of the shell game then it is
impossible to do a switch-a-roo and hide the pea under a different
shell. https://en.wikipedia.org/wiki/Shell_game

∀HH ∈ (E is correctly simulated by H) (¬∃(HH/E pair) Halts(E))
∴ HH(E,E)==0 is correct for every HH that aborts its simulation of E.

HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally.

Simulating halt deciders must compute the mapping from their inputs to
their own accept or reject state on the basis of their correct
simulation of their input up to the point when they correctly determine
that E correctly simulated by HH cannot possibly reach its own final
state an terminate normally.

In the same way that Sum(3,4) must compute the sum of 3+4 and is not
allowed to compute the sum of 2+6 HH is only allowed to report on the
behavior of E simulated by HH. As soon as HH correctly detects that E
has a repeating state HH is correct to abort its simulation and reject
its input as non-halting.

HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally in any finite number of
steps.

Two people with masters degrees in computer science have agreed that E correctly simulated by HH cannot possibly reach its own "return"
instruction in any finite number of steps of correct simulation.

Since this is such simple software engineering it seems to me that
anyone disagreeing knows this too and is simply lying.

Because E correctly simulated by HH cannot possibly reach its own
"return" instruction in any finite number of steps HH is necessarily
correct to abort its simulation of E and reject this input as non-
halting.

Anyone that attempts to refute necessary truths is always necessarily incorrect.

--
Copyright 2023 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 2/11/23 3:54 PM, olcott wrote:

Two people with masters degrees in computer science have agreed that E correctly simulated by HH cannot possibly reach its own "return"
instruction in any finite number of steps of correct simulation.

Since this is such simple software engineering it seems to me that
anyone disagreeing knows this too and is simply lying.

So?

IF HH ever aborts its simulation and returns 0, then when E is run, or correctly simulated, will reach its final state,

THAT is the definition of Halting, and thus H is incorrect.

Since the only HH in existance that matters (the one that is claimed to
get the right answer for the D built on it) does abort its simulation,
there does not exist a "THIS HH" that doesn't abort its simulation, and
thus this HH can't actualy provide a "Correct Simulation" for all finite
number of steps.

The ACTUAL correct simulation of the D built on this HH, will reach a
final state, thus showing that this HH just fails to reach the final
state because it aborted too soon.

Your insistance on incorrect logic just proves your stupidity.

We aren't talking about other machines that you give the same name to
(which just shows you are trying to be deceptive), we are talking about
the behavior of a PARTICULAR decider, and a PARTICULAR input.

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

XPost: comp.theory, sci.logic

On 2/11/23 6:05 PM, olcott wrote:

On 2/11/2023 2:54 PM, olcott wrote:

On 2/11/2023 10:17 AM, olcott wrote:

On 2/11/2023 9:29 AM, olcott wrote:

On 2/10/2023 10:03 PM, olcott wrote:

On 2/10/2023 6:29 PM, olcott wrote:

On 2/10/2023 5:46 PM, olcott wrote:

Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

void E(int (*x)())
{
   HH(x, x);
   return;
}

int main()
{
   HH(E,E);
}

_E()
[00001d40] 55             push ebp
[00001d41] 8bec           mov ebp,esp
[00001d43] 8b4508         mov eax,[ebp+08]
[00001d46] 50             push eax
[00001d47] 8b4d08         mov ecx,[ebp+08]
[00001d4a] 51             push ecx
[00001d4b] e820f6ffff     call 00001370
[00001d50] 83c408         add esp,+08
[00001d53] 5d             pop ebp
[00001d54] c3             ret
Size in bytes:(0021) [00001d54]

_main()
[00001d60] 55             push ebp
[00001d61] 8bec           mov ebp,esp
[00001d63] 68401d0000     push 00001d40
[00001d68] 68401d0000     push 00001d40
[00001d6d] e8fef5ffff     call 00001370
[00001d72] 83c408         add esp,+08
[00001d75] 33c0           xor eax,eax
[00001d77] 5d             pop ebp
[00001d78] c3             ret
Size in bytes:(0025) [00001d78]

  machine   stack     stack     machine    assembly >>>>>>>   address   address   data      code       language >>>>>>>   ========  ========  ========  =========  =============
[00001d60][00103017][00000000] 55         push ebp
[00001d61][00103017][00000000] 8bec       mov ebp,esp
[00001d63][00103013][00001d40] 68401d0000 push 00001d40
[00001d68][0010300f][00001d40] 68401d0000 push 00001d40
[00001d6d][0010300b][00001d72] e8fef5ffff call 00001370
New slave_stack at:1030bb

Begin Local Halt Decider Simulation   Execution Trace Stored
at:1130c3
[00001d40][001130af][001130b3] 55         push ebp      // begin E
[00001d41][001130af][001130b3] 8bec       mov ebp,esp
[00001d43][001130af][001130b3] 8b4508     mov eax,[ebp+08]
[00001d46][001130ab][00001d40] 50         push eax      // push
address of E
[00001d47][001130ab][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][001130a7][00001d40] 51         push ecx      // push
address of E
[00001d4b][001130a3][00001d50] e820f6ffff call 00001370 // call HH >>>>>>> New slave_stack at:14dae3
[00001d40][0015dad7][0015dadb] 55         push ebp      // begin E
[00001d41][0015dad7][0015dadb] 8bec       mov ebp,esp
[00001d43][0015dad7][0015dadb] 8b4508     mov eax,[ebp+08]
[00001d46][0015dad3][00001d40] 50         push eax      // push
address of E
[00001d47][0015dad3][00001d40] 8b4d08     mov ecx,[ebp+08]
[00001d4a][0015dacf][00001d40] 51         push ecx      // push
address of E
[00001d4b][0015dacb][00001d50] e820f6ffff call 00001370 // call HH >>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped >>>>>>>
[00001d72][00103017][00000000] 83c408     add esp,+08
[00001d75][00103017][00000000] 33c0       xor eax,eax
[00001d77][0010301b][00000018] 5d         pop ebp
[00001d78][0010301f][00000000] c3         ret
Number of Instructions Executed(15319) == 229 Pages

Because Every E correctly simulated by any HH cannot possibly halt >>>>>> any
HH that detects this is correct to abort its simulation and reject >>>>>> its
input as non-halting.

No halt decider is ever required to simulate any number of steps
of its
input. Halt deciders are only required to correctly predict
whether or
not their input can possibly reach its own final state and terminate >>>>>> normally.

Simulating halt decider HH computes the mapping from its input E
to an
accept or reject state on the basis of the behavior of E correctly >>>>>> simulated by HH. As soon as HH has simulated enough steps of E to
correctly predict that E cannot possibly reach its own final state >>>>>> then
HH is correct to abort its simulation of E and reject E as
non-halting.

When we have examined every element of the infinite set of HH/E pairs >>>>> and and found that no E correctly simulated by HH ever halts then
it is
necessarily correct for HH(E,E) to reject its input as non-halting.

When we find a pea under every shell of the shell game then it is
impossible to do a switch-a-roo and hide the pea under a different
shell. https://en.wikipedia.org/wiki/Shell_game

∀HH ∈ (E is correctly simulated by H) (¬∃(HH/E pair) Halts(E))
∴ HH(E,E)==0 is correct for every HH that aborts its simulation of E. >>>>
HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally.

Simulating halt deciders must compute the mapping from their inputs to >>>> their own accept or reject state on the basis of their correct
simulation of their input up to the point when they correctly determine >>>> that E correctly simulated by HH cannot possibly reach its own final
state an terminate normally.

In the same way that Sum(3,4) must compute the sum of 3+4 and is not
allowed to compute the sum of 2+6 HH is only allowed to report on the
behavior of E simulated by HH. As soon as HH correctly detects that E
has a repeating state HH is correct to abort its simulation and reject >>>> its input as non-halting.

HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally in any finite number of
steps.

Two people with masters degrees in computer science have agreed that E
correctly simulated by HH cannot possibly reach its own "return"
instruction in any finite number of steps of correct simulation.

Since this is such simple software engineering it seems to me that
anyone disagreeing knows this too and is simply lying.

Because E correctly simulated by HH cannot possibly reach its own
"return" instruction in any finite number of steps HH is necessarily
correct to abort its simulation of E and reject this input as non-
halting.

Which isn;t the defintion of Halting, so you are just admitting you are
working on a strawman.

The ACTUAL correct simulation of E will reach its final state if HH(D,D) returns 0 as claimed, and thus it is shown that HH doesn't actually do a correct simulation (per the actual definition) and thus your arguement
is based on a LIE.

You are just proving you are a pathological liar, and a total idiot for thinking people will belive them.

Anyone that attempts to refute necessary truths is always necessarily incorrect.

Right, like a program that Halts, like D(D) does since you have claimed
that H(D,D) returns 0, must be decide as Halting to be correct.

Thus YOU are necessarily incorrect.

You are just proving you never had an understand about what "Truth" is,
and have been just lying about it all your life.

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