On 10/7/24 4:29 PM, olcott wrote:

*Simulating Termination Analyzer HHH(DDD) rejects input DDD*
HHH is an emulating termination analyzer that takes the machine
address of DDD as input then emulates the x86 machine language
of DDD until a non-terminating behavior pattern is recognized.

Except their can't be a non-terminating pattern in DDD if that happens,
as DDD is terminating.

*HHH recognizes this pattern when HHH emulates itself emulating DDD*

And is wrong for doing so, as HHH by return PROVES that DDD will terminate.

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

Terminating is a property of finite string machine descriptions.
One cannot simply ignore the actual behavior specified by the
finite string such that

And, for the PROGRAM DDD, must include the FULL decription of the HHH
that it calls.

Thus, if that is all of the input, you are just proving that you have
been lying about working on the Halting problem, as your input ISN'T a sufficient representation of the input.

Thus, your are whole problem is on a false basis.

DDD emulated by each corresponding HHH that can possibly
exist never returns.

No, the Emulation of DDD by each corresponding HHH doesn't reach a final
state, but the actual program DDD will return if the HHH it calls aborts
it simulation are returns 0.

You are just showing that AGAIN, you don't understand the meaning of the
words you are using.

Thus each of these HHH emulators that does return 0 correctly
reports the above non-terminating behavior.

Nope, because by doing so it proves itself wrong, and that you are
nothing but a LIAR.

And, you accept that designation, by not even attempting to refute the arguements present, but just repeat your REFUTED claims, proving you
have less evidence of your innocence then Donald Trunmp.

*Fully operational software*
https://github.com/plolcott/x86utm *x86utm operating system*

In other words, you are just proving that


PPPP EEEEE TTTTT EEEEE RRRR
P P E T E R R
P P E T E R R
PPPP EEEEE T EEEEE RRRR
P E T E R R
P E T E R R
P EEEEE T EEEEE R R


OOO L CCC OOO TTTTT TTTTT
O O L C C O O T T
O O L C O O T T
O O L C O O T T
O O L C O O T T
O O L C C O O T T
OOO LLLLL CCC OOO T T


L IIIII EEEEE SSS
L I E S S
L I E S
L I EEEEE SSS
L I E S
L I E S S
LLLLL IIIII EEEEE SSS


AND THINKS THAT IS JUST OK.

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

On 10/7/24 7:02 PM, olcott wrote:

On 10/7/2024 5:39 PM, Richard Damon wrote:

On 10/7/24 4:29 PM, olcott wrote:

*Simulating Termination Analyzer HHH(DDD) rejects input DDD*
HHH is an emulating termination analyzer that takes the machine
address of DDD as input then emulates the x86 machine language
of DDD until a non-terminating behavior pattern is recognized.

Except their can't be a non-terminating pattern in DDD if that
happens, as DDD is terminating.

*HHH recognizes this pattern when HHH emulates itself emulating DDD*

And is wrong for doing so, as HHH by return PROVES that DDD will
terminate.

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

Terminating is a property of finite string machine descriptions.
One cannot simply ignore the actual behavior specified by the
finite string such that

And, for the PROGRAM DDD, must include the FULL decription  of the HHH
that it calls.

Thus, if that is all of the input, you are just proving that you have
been lying about working on the Halting problem, as your input ISN'T a
sufficient representation of the input.

Thus, your are whole problem is on a false basis.

DDD emulated by each corresponding HHH that can possibly
exist never returns.

No, the Emulation of DDD by each corresponding HHH doesn't reach a
final state, but the actual program DDD will return if the HHH it
calls aborts it simulation are returns 0.

The finite string input to HHH specifies non-halting behavior.
This is simply over your head.

Nope, not if it is actually the description of the program DDD that
calls that HHH, since that program halts.

Not because you are not intelligent or educated enough to understand it.
It is because you are so sure that I must be wrong that all of your
thinking has been boxed in by this false assumption.

Your problem is you just don't understand the meaning of the words you
use, and thus you CHANGE their meaning, which is just a form of lying.

You have been instructed in the proper meaning, but ignore it, that
means that you have just proven that


PPPP EEEEE TTTTT EEEEE RRRR
P P E T E R R
P P E T E R R
PPPP EEEEE T EEEEE RRRR
P E T E R R
P E T E R R
P EEEEE T EEEEE R R


OOO L CCC OOO TTTTT TTTTT
O O L C C O O T T
O O L C O O T T
O O L C O O T T
O O L C O O T T
O O L C C O O T T
OOO LLLLL CCC OOO T T


L IIIII EEEEE SSS
L I E S S
L I E S
L I EEEEE SSS
L I E S
L I E S S
LLLLL IIIII EEEEE SSS


AND THINKS THAT IS JUST OK.

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

On 2024-10-07 20:29:33 +0000, olcott said:

*Simulating Termination Analyzer HHH(DDD) rejects input DDD*
HHH is an emulating termination analyzer that takes the machine
address of DDD as input then emulates the x86 machine language
of DDD until a non-terminating behavior pattern is recognized.

*HHH recognizes this pattern when HHH emulates itself emulating DDD*

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

The above code shows that if HHH(DDD) rejects then DDD halts, which
means that no program that rejects DDD is a halting decider.

--
Mikko

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

On 10/8/24 10:02 AM, olcott wrote:

On 10/8/2024 8:50 AM, Mikko wrote:

On 2024-10-07 20:29:33 +0000, olcott said:

*Simulating Termination Analyzer HHH(DDD) rejects input DDD*
HHH is an emulating termination analyzer that takes the machine
address of DDD as input then emulates the x86 machine language
of DDD until a non-terminating behavior pattern is recognized.

*HHH recognizes this pattern when HHH emulates itself emulating DDD*

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

The above code shows that if HHH(DDD) rejects then DDD halts, which
means that no program that rejects DDD is a halting decider.

DDD emulated by each corresponding HHH that can possibly
exist never returns

thus each of the directly executed  HHH emulators that does
return 0 correctly reports the above non-terminating behavior.

No, the program DDD (which is what the subject of the sentence refers
to) returns since the HHH(DDD) that it calls returns (since you claim
that HHH is correct in doing so)

The emulation of it by HHH just doesn't reach that point, because it is
only partial.

You confound the truth of the program with the fantasy of the emulation, because you don't understand the different between truth and knowledge,
and thus you don't have either.

Thus, the HHH are incorrect and it shows that


PPPP EEEEE TTTTT EEEEE RRRR
P P E T E R R
P P E T E R R
PPPP EEEEE T EEEEE RRRR
P E T E R R
P E T E R R
P EEEEE T EEEEE R R


OOO L CCC OOO TTTTT TTTTT
O O L C C O O T T
O O L C O O T T
O O L C O O T T
O O L C O O T T
O O L C C O O T T
OOO LLLLL CCC OOO T T


L IIIII EEEEE SSS
L I E S S
L I E S
L I EEEEE SSS
L I E S
L I E S S
LLLLL IIIII EEEEE SSS


AND THINKS THAT IS JUST OK.

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

On 2024-10-08 14:02:45 +0000, olcott said:

On 10/8/2024 8:50 AM, Mikko wrote:

On 2024-10-07 20:29:33 +0000, olcott said:

*Simulating Termination Analyzer HHH(DDD) rejects input DDD*
HHH is an emulating termination analyzer that takes the machine
address of DDD as input then emulates the x86 machine language
of DDD until a non-terminating behavior pattern is recognized.

*HHH recognizes this pattern when HHH emulates itself emulating DDD*

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

The above code shows that if HHH(DDD) rejects then DDD halts, which
means that no program that rejects DDD is a halting decider.

DDD emulated by each corresponding HHH that can possibly
exist never returns

That does not make sense without a definition of "each corresponding
HHH that can possibly exist".

thus each of the directly executed HHH emulators that does
return 0 correctly reports the above non-terminating behavior.

If HHH returns 0 to DDD then DDD halts, proving that HHH is not a
halt decider.

If HHH returns 1 to DDD then DDD halts, failing to prove that HHH is
not a halt decider.

If HHH does not return to DDD it is not a halt decider.

--
Mikko

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