On 3/16/25 9:34 PM, olcott wrote:

On 3/16/2025 5:50 PM, Richard Damon wrote:

On 3/16/25 10:59 AM, olcott wrote:

On 3/16/2025 7:06 AM, joes wrote:

Am Sat, 15 Mar 2025 14:32:43 -0500 schrieb olcott:

On 3/15/2025 8:08 AM, dbush wrote:

On 3/14/2025 11:58 PM, olcott wrote:

On 3/14/2025 10:10 PM, dbush wrote:

On 3/14/2025 11:03 PM, olcott wrote:

On 3/14/2025 8:53 PM, dbush wrote:

On 3/14/2025 9:48 PM, olcott wrote:

On 3/14/2025 8:27 PM, dbush wrote:

On 3/14/2025 9:21 PM, olcott wrote:

On 3/14/2025 8:09 PM, dbush wrote:

On 3/14/2025 9:03 PM, olcott wrote:

On 3/14/2025 6:27 PM, dbush wrote:

On 3/14/2025 7:21 PM, olcott wrote:

On 3/14/2025 1:33 PM, dbush wrote:

On 3/14/2025 2:29 PM, olcott wrote:

(3) When we define the HP as having H return a value >>>>>>>>>>>>>>>>>>> corresponding to the halting behavior of input D and >>>>>>>>>>>>>>>>>>> input
D can actually does the opposite of whatever value >>>>>>>>>>>>>>>>>>> that H
returns, then we have boxed ourselves in to a problem >>>>>>>>>>>>>>>>>>> having no solution.

And as above, the correct answer is that no H satisfies >>>>>>>>>>>>>>>>>> that clearly stated requirement.

In the same way that "this sentence is not true" cannot >>>>>>>>>>>>>>>>> possibly be correctly evaluated to any Boolean value. >>>>>>>>>>>>>>>>

The question is, as you have agreed: does an H exist such >>>>>>>>>>>>>>>> that H(X,Y) computes if X(Y) halts when executed >>>>>>>>>>>>>>>> directly for
all X and Y?  And the answer is no.

Why can't a halt decider determine the halt status of the >>>>>>>>>>>>>>> counter-example input?

Because you incorrectly assumed that an H that satisfies this >>>>>>>>>>>>>> definition exists:

That is what blind rote memorization of textbooks would say. >>>>>>>>>>>>>

In other words, you don't understand proof by contradiction, a >>>>>>>>>>>> concept taught to and understood by high school students more >>>>>>>>>>>> that 50 years your junior.

We assume that someone can correctly answer this question: What >>>>>>>>>>> time is it (yes or no)?
Because the question is bogus we have proof by contradiction >>>>>>>>>>> that
our assumption was false.

Because the counter-example input derives a self-contradiction >>>>>>>>>>>>> proving

That the assumption that an H exists that satisfies the below >>>>>>>>>>>> requirements is false:

What integer N is > 5 and < 2

So you started by assuming that such an integer exists.  We then >>>>>>>>>> find the above question can't be answered, therefore the
assumption
that a number N that is > 5 and < 2 is false.

In each of the questions there is a BOGUS FORM  WHY FORM  VALID >>>>>>>>> FORM
BOGUS FORM *This is the BOGUS form of the HP counter-example >>>>>>>>> input*
What Boolean value can halt decider H correctly return for input D >>>>>>>>> that does the opposite of whatever value that H returns? (answer >>>>>>>>> required to be Boolean)
NO CORRECT ANSWER THUS INCORRECT QUESTION

By saying "halt decider H" you're assuming that an H exist that >>>>>>>> reports if X(Y) halts when executed directly for all X and Y.

Likewise when we assume a True(X) predicate where X = "What time is >>>>>>> it?"

Invalid change of subject.  This will be taken as agreement.

It is the title of the post.
Determining the Boolean value of "What time it is?"
and determining the correct Boolean value for H to return are the same >>>>> in that both Boolean values are incorrect.
When-so-ever both Boolean values are the wrong answer to a Boolean
question the question itself is incorrect and must be rejected as
erroneous.

"Does it halt?" is however a very sensible question. (Of course it
presupposes the existence of a decider.)

*This is the details of the architecture of my system*

<Accurate Paraphrase>
If emulating termination analyzer H emulates its input
finite string D of x86 machine language instructions
according to the semantics of the x86 programming language
until H correctly determines that this emulated D cannot
possibly reach its own "ret" instruction in any finite
number of correctly emulated steps then

H can abort its emulation of input D and correctly report
that D specifies a non-halting sequence of configurations.
</Accurate Paraphrase>

SInce your "Accurate Paraphrase" isn't that, as it make catergory
errors, your conclusion is just incorrect.

The problem is that it is IMPOSSIBLE for your H to determine that the
correct emulation of D cannot possibly reach its own return instruction,

_Infinite_Recursion()
[00002062] 55             push ebp
[00002063] 8bec           mov ebp,esp
[00002065] e8f8ffffff     call 00002062
[0000206a] 90             nop
[0000206b] 5d             pop ebp
[0000206c] c3             ret
Size in bytes:(0011) [0000206c]

_DDD()
[000020b2] 55             push ebp
[000020b3] 8bec           mov ebp,esp
[000020b5] 68b2200000     push 000020b2
[000020ba] e8c3fbffff     call 00001c82
[000020bf] 83c404         add esp,+04
[000020c2] 5d             pop ebp
[000020c3] c3             ret
Size in bytes:(0018) [000020c3]

HHH sees both of these as the exact same behavior
pattern. HHH has no idea that DDD is calling itself.

Then it is wrong, sicne DDD calls a function that will only run for a
finite time and then return, as that is what the code you says is
looking at it does, and it is using that same code.

In both case HHH only knows that DDD calls the same
function twice in sequence with no conditional code
in-between the invocation of DDD and its function call.

DDD doesn't call DDD, so you are just proving you are a liar.

If you want to say it know HHH is just a correct simulator, then you are admitting to lying, as HHH isn't a "correct simulator", but a simulator
that will abort and return,

You are just stuck in your lies, which you have freely admitted, proving
that you whole argumwnt is a FRAUD.

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

Am Sun, 16 Mar 2025 20:34:05 -0500 schrieb olcott:

On 3/16/2025 5:50 PM, Richard Damon wrote:

On 3/16/25 10:59 AM, olcott wrote:

On 3/16/2025 7:06 AM, joes wrote:

"Does it halt?" is however a very sensible question. (Of course it
presupposes the existence of a decider.)

*This is the details of the architecture of my system*
<Accurate Paraphrase>
</Accurate Paraphrase>

SInce your "Accurate Paraphrase" isn't that, as it make catergory
errors, your conclusion is just incorrect.
The problem is that it is IMPOSSIBLE for your H to determine that the
correct emulation of D cannot possibly reach its own return
instruction,

_Infinite_Recursion()
_DDD()
HHH sees both of these as the exact same behavior pattern. HHH has no
idea that DDD is calling itself.
In both case HHH only knows that DDD calls the same function twice in sequence with no conditional code in-between the invocation of DDD and
its function call.

But there *is* a conditional abort inbetween.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.

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

Am Mon, 17 Mar 2025 08:34:43 -0500 schrieb olcott:

On 3/17/2025 6:33 AM, joes wrote:

Am Sun, 16 Mar 2025 20:34:05 -0500 schrieb olcott:

On 3/16/2025 5:50 PM, Richard Damon wrote:

On 3/16/25 10:59 AM, olcott wrote:

On 3/16/2025 7:06 AM, joes wrote:

_Infinite_Recursion()
_DDD()
HHH sees both of these as the exact same behavior pattern. HHH has no
idea that DDD is calling itself.
In both case HHH only knows that DDD calls the same function twice in
sequence with no conditional code in-between the invocation of DDD and
its function call.

But there *is* a conditional abort inbetween.

typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
HHH(DDD);
return;
}
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

*There are no conditional branch instructions in* DDD()
*There are no conditional branch instructions in*
DD() prior to its call to HHH(DD).

But there is a conditional branch in HHH, which is part of DD and DDD.

The conditional branch instructions MUST BE IN THE TEST FUNCTION AND
MUST ENABLE THE TEST FUNCTION TO REACH ITS OWN "return" INSTRUCTION AND TERMINATE NORMALLY.

Fulfilled.

The question is not DOES THE INPUT EVER STOP RUNNING? If it was then Infinite_Loop() halts.

No, that IS the question, and no, the infinite loop doesn't halt.

The question is does the input reach its own final state and terminate normally when emulated according to the semantics of the x86 programming language?

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.

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

On 3/17/25 9:34 AM, olcott wrote:

On 3/17/2025 6:33 AM, joes wrote:

Am Sun, 16 Mar 2025 20:34:05 -0500 schrieb olcott:

On 3/16/2025 5:50 PM, Richard Damon wrote:

On 3/16/25 10:59 AM, olcott wrote:

On 3/16/2025 7:06 AM, joes wrote:

"Does it halt?" is however a very sensible question. (Of course it >>>>>> presupposes the existence of a decider.)

*This is the details of the architecture of my system*
<Accurate Paraphrase>
</Accurate Paraphrase>

SInce your "Accurate Paraphrase" isn't that, as it make catergory
errors, your conclusion is just incorrect.
The problem is that it is IMPOSSIBLE for your H to determine that the
correct emulation of D cannot possibly reach its own return
instruction,

_Infinite_Recursion()
_DDD()
HHH sees both of these as the exact same behavior pattern. HHH has no
idea that DDD is calling itself.
In both case HHH only knows that DDD calls the same function twice in
sequence with no conditional code in-between the invocation of DDD and
its function call.

But there *is* a conditional abort inbetween.

typedef void (*ptr)();
int HHH(ptr P);

void Infinite_Loop()
{
  HERE: goto HERE;
  return;
}

void Infinite_Recursion()
{
  Infinite_Recursion();
  return;
}

void DDD()
{
  HHH(DDD);
  return;
}

int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

*There are no conditional branch instructions in*
Infinite_Loop()
Infinite_Recursion()
DDD()

Sure there is in DD(), since you just admitted that the definition of
HHH in Halt7.c is part of the input.

Decider look at PROGRAMS, not just C Functions, so the criterial is no conditional branch instructions in the FULL loop, and there are in the
HHH that DD calls.

*There are no conditional branch instructions in*
DD() prior to its call to HHH(DD).

Which diesn't matter, as the code for HHH that DD calls is part of it,.

The conditional branch instructions MUST BE IN THE TEST
FUNCTION AND MUST ENABLE THE TEST FUNCTION TO REACH ITS
OWN "return" INSTRUCTION AND TERMINATE NORMALLY.

No, it must be in the test PROGRAM.

Do you have a reference for your claim, or is this going to be another
case you your FRAUD of using the wrong definitions.

The question is not DOES THE INPUT EVER STOP RUNNING?
If it was then Infinite_Loop() halts.

The question is does the input reach its own final state
and terminate normally when emulated according to the
semantics of the x86 programming language?

Right, FULLY emulated, not partially emualted as HHH fails to do because
it aborts its emu;lation.

The CORRECT emulation reachs that final state, as shown by the emulation
done by HHH1.

You have effectively admitted to you lies about this by not ever showing
the first actual instruction correctly emulated by HHH that differs from
the instruction emulated by HHH1.

Note, your strawman of HHH using some rough definition of HHH fails,
because that definition isn't a definition that is acording to the x86 programming language.

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