From Newsgroup: comp.ai.philosophy

void DDD()
{
HHH(DDD);
}

int main()
{
DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

On 7/20/24 11:28 AM, olcott wrote:

void DDD()
{
  HHH(DDD);
}

int main()
{
  DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

I don't know where you got the false idea that "Termination Analyzers"
were "Partial Halt Deciders", then most certainly are not.

Read https://en.wikipedia.org/wiki/Termination_analysis for a
description, they deal with the related problem of determining if the
input program will halt for *ALL* inputs, not just a given one.


Yes, in computer science, where the building of partial Termination
Analyzers is an ongoing project, they often just drop the assumed
partial as everyone know the general problem is not universally solvable.

Also, the answer must be correct,

and the input must be a PROGRAM, which mean it includes ALL its code
that it uses, so for DDD, include the code for HHH.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

But that is a DIFFERENT DDD then the one given to the HHH that aborted
it emulation, and thus your logic is based on LYING.

We can given the input it the aborting HHH to another emulator which
doesn't abort, and as long as we don't change the input, and thus that
DDD calls that same HHH that aborts, we see that HHH was incorrect in
its need to abort THIS input.

This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.

Right, and shows that the problem can not be solved (at least not with
this method). Not that a wrong answer is correct.

The Flibble varient does handle this input, so it just shows that your
program isn't good enough, but a better one does exist.

You are just proving that you think lying is ok, and thus agree with the Election and Climate Change deniers.

Sorry, but I can't let you get away with that.

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

On 7/20/2024 11:01 AM, Richard Damon wrote:

On 7/20/24 11:28 AM, olcott wrote:

void DDD()
{
   HHH(DDD);
}

int main()
{
   DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

I don't know where you got the false idea that "Termination Analyzers"
were "Partial Halt Deciders", then most certainly are not.

Read https://en.wikipedia.org/wiki/Termination_analysis for a
description, they deal with the related problem of determining if the
input program will halt for *ALL* inputs, not just a given one.

Yes, in computer science, where the building of partial Termination Analyzers is an ongoing project, they often just drop the assumed
partial as everyone know the general problem is not universally solvable.

Also, the answer must be correct,

and the input must be a PROGRAM, which mean it includes ALL its code
that it uses, so for DDD, include the code for HHH.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

But that is a DIFFERENT DDD then the one given to the HHH that aborted
it emulation, and thus your logic is based on LYING.

Sure of course everyone knows that when you examine
every element of an infinite set that there are a
whole bunch of elements of this infinite set that you
never examined after you have examined every single
one of them.

Likewise when you are no longer hungry after getting
something to eat this conclusively proves that you never
were hungry thus never needed to eat.

Are you really sure that you want to swear your allegiance
to the father of lies?
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

Op 20.jul.2024 om 17:28 schreef olcott:

void DDD()
{
  HHH(DDD);
}

int main()
{
  DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.

And when it aborts, the simulation is incorrect. When HHH aborts and
halts, it is not needed to abort its simulation, because it will halt of
its own. When analysing an aborting and halting HHH, dreaming of a hypothetical *other* HHH that does not abort, is irrelevant.
This proves that HHH cannot possibly simulate itself correctly up to the
end.

DDD is a misleading and unneeded complication. It is easy to eliminate DDD:

int main() {
return HHH(main);
}

This has the same problem. This proves that the problem is not in DDD,
but in HHH, which halts when it aborts the simulation, but it decides
that the simulation of itself does not halt.

HHH is simply unable to decide about finite recursions.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

It decides after N recursions that there is an infinite recursion, which
is incorrect.

Olcott's HHH is programmed to abort the simulation after N cycles of
recursive simulations. Therefore, it is incorrect to abort the
simulation of HHH when the simulated HHH has performed only N-1 cycles, because that changes the behaviour of HHH.
Since the simulated HHH always runs one cycle behind the simulating HHH,
it is clear that HHH can never simulate enough cycles for a correct simulation, as is required by the x86 language.
Therefore, the simulation is incorrect according to the criteria olcott stipulated.
The conclusion is simple:
HHH cannot possibly simulate itself correctly.

No matter how much olcott wants it to be correct, or how many times
olcott repeats that it is correct, it does not change the fact that such
a simulation is incorrect, because it is unable to reach the end.
Olcott's own claim that the simulated HHH does not reach its end
confirms it. The trace he has shown also proves that HHH cannot reach
the end of its own simulation. So, his own claims prove that it is true
that HHH cannot possibly simulate itself up to the end, which makes the simulation incorrect.

Sipser would agree that this incorrect simulation cannot be used to
detect a non-halting behaviour.

Olcott could not point to an error, but prefers to ignore it. So, I will repeat it, until either an error is found, or olcott admits that HHH
cannot possibly simulate itself correctly.
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

On 7/20/2024 2:00 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 17:28 schreef olcott:

void DDD()
{
   HHH(DDD);
}

int main()
{
   DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.

And when it aborts, the simulation is incorrect. When HHH aborts and
halts, it is not needed to abort its simulation, because it will halt of
its own.

So you are trying to get away with saying that no HHH
ever needs to abort the simulation of its input and HHH
will stop running?
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

Op 20.jul.2024 om 21:09 schreef olcott:

On 7/20/2024 2:00 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 17:28 schreef olcott:

void DDD()
{
   HHH(DDD);
}

int main()
{
   DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.

And when it aborts, the simulation is incorrect. When HHH aborts and
halts, it is not needed to abort its simulation, because it will halt
of its own.

So you are trying to get away with saying that no HHH
ever needs to abort the simulation of its input and HHH
will stop running?

No, you try to get away with saying that a HHH that is coded to abort
and halt, will never stop running, only because you are dreaming of
*another* HHH that does not abort.

DDD is a misleading and unneeded complication. It is easy to eliminate DDD:

int main() {
return HHH(main);
}

This has the same problem. This proves that the problem is not in DDD,
but in HHH, which halts when it aborts the simulation, but it decides
that the simulation of itself does not halt.

HHH is simply unable to decide about finite recursions.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

It decides after N recursions that there is an infinite recursion, which
is incorrect.

Olcott's HHH is programmed to abort the simulation after N cycles of
recursive simulations. Therefore, it is incorrect to abort the
simulation of HHH when the simulated HHH has performed only N-1 cycles, because that changes the behaviour of HHH.
Since the simulated HHH always runs one cycle behind the simulating HHH,
it is clear that HHH can never simulate enough cycles for a correct simulation, as is required by the x86 language.
Therefore, the simulation is incorrect according to the criteria olcott stipulated.
The conclusion is simple:
HHH cannot possibly simulate itself correctly.

No matter how much olcott wants it to be correct, or how many times
olcott repeats that it is correct, it does not change the fact that such
a simulation is incorrect, because it is unable to reach the end.
Olcott's own claim that the simulated HHH does not reach its end
confirms it. The trace he has shown also proves that HHH cannot reach
the end of its own simulation. So, his own claims prove that it is true
that HHH cannot possibly simulate itself up to the end, which makes the simulation incorrect.

Sipser would agree that this incorrect simulation cannot be used to
detect a non-halting behaviour.

Olcott could not point to an error, but prefers to ignore it. So, I will repeat it, until either an error is found, or olcott admits that HHH
cannot possibly simulate itself correctly.



--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

On 7/20/24 2:52 PM, olcott wrote:

On 7/20/2024 11:01 AM, Richard Damon wrote:

On 7/20/24 11:28 AM, olcott wrote:

void DDD()
{
   HHH(DDD);
}

int main()
{
   DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

I don't know where you got the false idea that "Termination Analyzers"
were "Partial Halt Deciders", then most certainly are not.

Read https://en.wikipedia.org/wiki/Termination_analysis for a
description, they deal with the related problem of determining if the
input program will halt for *ALL* inputs, not just a given one.


Yes, in computer science, where the building of partial Termination
Analyzers is an ongoing project, they often just drop the assumed
partial as everyone know the general problem is not universally solvable.

Also, the answer must be correct,

and the input must be a PROGRAM, which mean it includes ALL its code
that it uses, so for DDD, include the code for HHH.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

But that is a DIFFERENT DDD then the one given to the HHH that aborted
it emulation, and thus your logic is based on LYING.

Sure of course everyone knows that when you examine
every element of an infinite set that there are a
whole bunch of elements of this infinite set that you
never examined after you have examined every single
one of them.

Who said there were some that weren't looked at?

That is just another of your near infinite set of lies.

We can look at EVERY ELEMENT in that infinite set, and every case falls
into one of two cases:

Case 1: The HHH(DDD) *WILL* abort its emulation of the DDD it is given,
that thus, does NOT "Correctly Emulate" its input per the FULL semantics
of the x86 (since just stopping but not halting in the middle of the
program doesn't match those semantics) and the DDD that was paired to
such an HHH *WILL* reach its final state when run or correctly emulated
by an ACTUAL correct emulator given the exact same input including the
fact that it calls the HHH that aborts.

Case 2: The HHH(DDD) NEVER aborts its emulation of the DDD it is given,
at which point that HHH will never return an answer. You acknoledge that
this HHH doesn't meet your requirements, but you keep on trying to refer
its case as to showing that DDD doesn't halt if not aborted, but this
DDD is never given to any of the Case 1 HHHs.

Your trying to claim that DDD doesn't include the HHH is just a LIE, as
it must to be a program, so if it doesn't, you can't actually emulate it
past the first 4 steps.

Likewise when you are no longer hungry after getting
something to eat this conclusively proves that you never
were hungry thus never needed to eat.

Red Herring.

Are you really sure that you want to swear your allegiance
to the father of lies?

I don't, but you sure seem to have.

For instance, are you still holding to your lie that the representation
of DDD as a FULL program doesn't include the code of HHH?

Or is it a LIE that HHH is actually defined as a decider for the
behavior of a program?

Or is it a LIE that you are following the requirement of Computation
Theory (which I think you just don't know). Note, not knowing doesn't
make it a lie, but could be an honest mistake, repeating them after
being told you are wrong, makes it a lie by the reckless disregard of
the truth.
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

On 7/20/24 3:09 PM, olcott wrote:

On 7/20/2024 2:00 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 17:28 schreef olcott:

void DDD()
{
   HHH(DDD);
}

int main()
{
   DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.

And when it aborts, the simulation is incorrect. When HHH aborts and
halts, it is not needed to abort its simulation, because it will halt
of its own.

So you are trying to get away with saying that no HHH
ever needs to abort the simulation of its input and HHH
will stop running?

It is the fact that HHH DOES abort its simulation that makes it not need
to. The only DDD that we care about are the DDD that are built on HHH
that answers, and to answer for such a DDD, HHH will need to abort, and
from that, we make the DDD that ends up not needing to abort.

Yes, that sounds contradictory, but that is because they are two
different questions. The first is you decision of what HHH to put into
the challenge, and with your limited set of options that you have
limited yourself to, you need to choose one of the aborting ones, or you
will lose by not answering.

*THEN* the input is created for that specific HHH that you have chosen,
and now we can actually evaluate the actual NEED to abort but the
behavior of an unaborted emulation of THIS PARTICULAR input, which
includes the HHH that it was paired with. That emulator can't be put in
the location of HHH, but can be put somewhere else in memory, and it
will show that DDD will halt, and thus HHH doesn't NEED to abort, even
though it DOES.

The problem is you broke your system such that you can't talk about
giving a given DDD (which includes the HHH that it calls) to any other
HHH the way you talk about it, so your wording is just illogical words
that can't mean what they need to mean. To have built DDD properly, it
SHOULD have included its own copy of the HHH that it was going to
confound, but you system doesn't allow that operation because it seems
to not actually be Turing Complete in what it takes as inputs.

The fact you persist after this has been pointed out just shows that
either you are just totally mentally incompetent, or you are just a pathological liar that doesn't care that their words are not logical and
the "facts" they use are not true.
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

On 7/20/2024 2:36 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 21:09 schreef olcott:

On 7/20/2024 2:00 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 17:28 schreef olcott:

void DDD()
{
   HHH(DDD);
}

int main()
{
   DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.

And when it aborts, the simulation is incorrect. When HHH aborts and
halts, it is not needed to abort its simulation, because it will halt
of its own.

So you are trying to get away with saying that no HHH
ever needs to abort the simulation of its input and HHH
will stop running?

No, you try to get away with saying that a HHH that is coded to abort
and halt, will never stop running, only because you are dreaming of *another* HHH that does not abort.

*You know that I didn't say anything like that*

Unless I refer to the infinite set of every possible
HHH my reviewers try to get away with saying that I am
referring to the wrong HHH.

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

DDD correctly simulated by pure function HHH cannot
possibly reach its own return instruction.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

[ Followup-To: set ]

In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> wrote:

[ .... ]

Olcott could not point to an error, but prefers to ignore it. So, I will repeat it, until either an error is found, or olcott admits that HHH
cannot possibly simulate itself correctly.

This has the disadvantage of making your posts boring to read. All but
one poster on this newsgroup KNOW that Olcott is wrong, here.

Continually repeating your argument won't get him to admit he's wrong.
Richard has been trying that for much longer than you have, with the
same lack of success. Olcott's lack of capacity for abstract reasoning, combined with his ignorance, combined with his arrogance, prevent him
learning at all.

May I suggest that you reconsider your strategy of endless repetition?

Thanks!
--
Alan Mackenzie (Nuremberg, Germany).

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

On 7/20/2024 2:50 PM, Richard Damon wrote:

On 7/20/24 3:09 PM, olcott wrote:

On 7/20/2024 2:00 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 17:28 schreef olcott:

void DDD()
{
   HHH(DDD);
}

int main()
{
   DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.

And when it aborts, the simulation is incorrect. When HHH aborts and
halts, it is not needed to abort its simulation, because it will halt
of its own.

So you are trying to get away with saying that no HHH
ever needs to abort the simulation of its input and HHH
will stop running?

It is the fact that HHH DOES abort its simulation that makes it not need
to.

No stupid it is not a fact that every HHH that can possibly
exist aborts its simulation.

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

It *is* a fact that no DDD correctly simulated by any
pure function HHH ever reaches its own return instruction.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

On 7/20/24 4:02 PM, olcott wrote:

On 7/20/2024 2:36 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 21:09 schreef olcott:

On 7/20/2024 2:00 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 17:28 schreef olcott:

void DDD()
{
   HHH(DDD);
}

int main()
{
   DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.

And when it aborts, the simulation is incorrect. When HHH aborts and
halts, it is not needed to abort its simulation, because it will
halt of its own.

So you are trying to get away with saying that no HHH
ever needs to abort the simulation of its input and HHH
will stop running?

No, you try to get away with saying that a HHH that is coded to abort
and halt, will never stop running, only because you are dreaming of
*another* HHH that does not abort.

*You know that I didn't say anything like that*

Unless I refer to the infinite set of every possible
HHH my reviewers try to get away with saying that I am
referring to the wrong HHH.

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

DDD correctly simulated by pure function HHH cannot
possibly reach its own return instruction.

And the problem you ignore is that each HHH is given the DDD that calls itself, and not some other HHH, and thus you can't look at the other
HHHs behavior with their different behavior (in particular, the HHH/DDD
pair where HHH doesn't abort) but look at giving this exact input,
calling this exact HHH to a "correct emulator" that doesn't abort its emulation.

You logic of looking at other HHHs is just a LIE and proves you don't understand either Computations or Logic, or even what Truth itself is.

EVERY DDD that calls an HHH that aborts and returns will reach its own
return instruction. so your claim is just a lie.

You confuse that DDD with the PARTIAL emulation that HHH did, which
doesn't show the full behavior of DDD, only partial.

This appears to be because you just don't understand the difference
between Truth and Knowledge which shows you don't really know what
EITHER of them actually is, so, you are just proving you total inability
tto understand how logic actually works.
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

On 7/20/2024 3:10 PM, Richard Damon wrote:

On 7/20/24 4:02 PM, olcott wrote:

On 7/20/2024 2:36 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 21:09 schreef olcott:

On 7/20/2024 2:00 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 17:28 schreef olcott:

void DDD()
{
   HHH(DDD);
}

int main()
{
   DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.

And when it aborts, the simulation is incorrect. When HHH aborts
and halts, it is not needed to abort its simulation, because it
will halt of its own.

So you are trying to get away with saying that no HHH
ever needs to abort the simulation of its input and HHH
will stop running?

No, you try to get away with saying that a HHH that is coded to abort
and halt, will never stop running, only because you are dreaming of
*another* HHH that does not abort.

*You know that I didn't say anything like that*

Unless I refer to the infinite set of every possible
HHH my reviewers try to get away with saying that I am
referring to the wrong HHH.

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

DDD correctly simulated by pure function HHH cannot
possibly reach its own return instruction.

And the problem you ignore is that each HHH is given the DDD that calls itself, and not some other HHH, and thus you can't look at the other

Yet again trying to get away with saying that when every element
of an infinite set cannot reach its return instruction that some
of these elements still reach their return instruction.

My God have mercy on your soul (if you have a soul).
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

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

On 7/20/2024 3:10 PM, Richard Damon wrote:

On 7/20/24 4:02 PM, olcott wrote:

On 7/20/2024 2:36 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 21:09 schreef olcott:

On 7/20/2024 2:00 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 17:28 schreef olcott:

void DDD()
{
   HHH(DDD);
}

int main()
{
   DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD} >>>>>>> never stop running.

This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.

And when it aborts, the simulation is incorrect. When HHH aborts
and halts, it is not needed to abort its simulation, because it
will halt of its own.

So you are trying to get away with saying that no HHH
ever needs to abort the simulation of its input and HHH
will stop running?

No, you try to get away with saying that a HHH that is coded to
abort and halt, will never stop running, only because you are
dreaming of *another* HHH that does not abort.

*You know that I didn't say anything like that*

Unless I refer to the infinite set of every possible
HHH my reviewers try to get away with saying that I am
referring to the wrong HHH.

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

DDD correctly simulated by pure function HHH cannot
possibly reach its own return instruction.

And the problem you ignore is that each HHH is given the DDD that
calls itself, and not some other HHH, and thus you can't look at the
other

Yet again trying to get away with saying that when every element
of an infinite set cannot reach its return instruction that some
of these elements still reach their return instruction.

Because you are using the wrong definitions. The thing that never gets
to the return instruciton is the PARTIAL emulation by HHH.

But the question being asked to a Halt Decider is does the PROGRAM
represented by the input get there, and *IT* does.

My God have mercy on your soul (if you have a soul).

I know where my ticket to eternity is. You may think you have an idea,
but I thihk you have been lying to youreself, just as you have been
lying with all your words.

I know what "My God" has said, and I don't care what "YOUR GOD" says, as
I try not to listen to the words of your God, Satan the deciver (who you
show is your god as you follow his methods of using deciet).

Remember, "God" defines the criteria, where "God" is the creator of the
thing. In Computation Theory, that "god" is the people who DEFINED the
field, and they have defined the meaningi of halting and what a halt
decider is suppose to answer about, so trying to change that is just
LYING, and you know where LIARS go.

Just like you don't get to pick and choose what words of the Scriptures
you are going to believe. If they are Gods words, then ALL of them are,
or he isn't a "big" enough God to worry about.
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

On 7/20/24 4:05 PM, olcott wrote:

On 7/20/2024 2:50 PM, Richard Damon wrote:

On 7/20/24 3:09 PM, olcott wrote:

On 7/20/2024 2:00 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 17:28 schreef olcott:

void DDD()
{
   HHH(DDD);
}

int main()
{
   DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.

And when it aborts, the simulation is incorrect. When HHH aborts and
halts, it is not needed to abort its simulation, because it will
halt of its own.

So you are trying to get away with saying that no HHH
ever needs to abort the simulation of its input and HHH
will stop running?

It is the fact that HHH DOES abort its simulation that makes it not
need to.

No stupid it is not a fact that every HHH that can possibly
exist aborts its simulation.

But every HHH that is a decider does.

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

It *is* a fact that no DDD correctly simulated by any
pure function HHH ever reaches its own return instruction.

No, you show that the EMULATION BY HHH never reaches that point, not
that DDD doesn't reach that point.

You miss the fact that EVERY DDD built on an HHH that aborts is
emulation and returns to its caller makes a DDD that does reach its own
return instruction, though after that HHH has aborted it emulation, so
the HHH never gets that knowledge.

You are just ignorant of the differnce between the TRUTH of the
program's behavior from the limited KNOWLEDGE gotten from the PARTIAL EMULAITON.

It also seems you just don't understnd what a program actualy is as you
LIE about what needs to be considered the representation of DDD to give
to HHH.

You are just proving that you are nothing but an ignorant pathological
lying idiot.
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

Op 20.jul.2024 om 22:02 schreef olcott:

On 7/20/2024 2:36 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 21:09 schreef olcott:

On 7/20/2024 2:00 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 17:28 schreef olcott:

void DDD()
{
   HHH(DDD);
}

int main()
{
   DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.

And when it aborts, the simulation is incorrect. When HHH aborts and
halts, it is not needed to abort its simulation, because it will
halt of its own.

So you are trying to get away with saying that no HHH
ever needs to abort the simulation of its input and HHH
will stop running?

No, you try to get away with saying that a HHH that is coded to abort
and halt, will never stop running, only because you are dreaming of
*another* HHH that does not abort.

*You know that I didn't say anything like that*

Unless I refer to the infinite set of every possible
HHH my reviewers try to get away with saying that I am
referring to the wrong HHH.

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

DDD correctly simulated by pure function HHH cannot
possibly reach its own return instruction.

DDD is a misleading and unneeded complication. It is easy to eliminate DDD:

int main() {
return HHH(main);
}

This has the same problem. This proves that the problem is not in DDD,
but in HHH, which halts when it aborts the simulation, but it decides
that the simulation of itself does not halt.
It shows that HHH cannot possibly simulate itself correctly.

HHH is simply unable to decide about finite recursions.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

It decides after N recursions that there is an infinite recursion, which
is incorrect.

Olcott's HHH is programmed to abort the simulation after N cycles of
recursive simulations. Therefore, it is incorrect to abort the
simulation of HHH when the simulated HHH has performed only N-1 cycles, because that changes the behaviour of HHH.
Since the simulated HHH always runs one cycle behind the simulating HHH,
it is clear that HHH can never simulate enough cycles for a correct simulation, as is required by the x86 language.
Therefore, the simulation is incorrect according to the criteria olcott stipulated.
The conclusion is simple:
HHH cannot possibly simulate itself correctly.

No matter how much olcott wants it to be correct, or how many times
olcott repeats that it is correct, it does not change the fact that such
a simulation is incorrect, because it is unable to reach the end.
Olcott's own claim that the simulated HHH does not reach its end
confirms it. The trace he has shown also proves that HHH cannot reach
the end of its own simulation. So, his own claims prove that it is true
that HHH cannot possibly simulate itself up to the end, which makes the simulation incorrect.

Sipser would agree that this incorrect simulation cannot be used to
detect a non-halting behaviour.

Olcott does not know how to point to an error in this explanation, but
prefers to ignore it. He even consistently removes it from the
citations. So, I will repeat it, until either an error is found, or
olcott admits that HHH cannot possibly simulate itself correctly.
--
Paradoxes in the relation between Creator and creature. <http://www.wirholt.nl/English>.

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.ai.philosophy

Op 20.jul.2024 om 22:29 schreef olcott:

On 7/20/2024 3:10 PM, Richard Damon wrote:

On 7/20/24 4:02 PM, olcott wrote:

On 7/20/2024 2:36 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 21:09 schreef olcott:

On 7/20/2024 2:00 PM, Fred. Zwarts wrote:

Op 20.jul.2024 om 17:28 schreef olcott:

void DDD()
{
   HHH(DDD);
}

int main()
{
   DDD();
}

(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.

(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD} >>>>>>> never stop running.

This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.

And when it aborts, the simulation is incorrect. When HHH aborts
and halts, it is not needed to abort its simulation, because it
will halt of its own.

So you are trying to get away with saying that no HHH
ever needs to abort the simulation of its input and HHH
will stop running?

No, you try to get away with saying that a HHH that is coded to
abort and halt, will never stop running, only because you are
dreaming of *another* HHH that does not abort.

*You know that I didn't say anything like that*

Unless I refer to the infinite set of every possible
HHH my reviewers try to get away with saying that I am
referring to the wrong HHH.

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

DDD correctly simulated by pure function HHH cannot
possibly reach its own return instruction.

And the problem you ignore is that each HHH is given the DDD that
calls itself, and not some other HHH, and thus you can't look at the
other

Yet again trying to get away with saying that when every element
of an infinite set cannot reach its return instruction that some
of these elements still reach their return instruction.

No, you are trying to get away with saying that, although all variants
of HHH are incorrect, the infinite set of them is correct.

The fact that none of them can reach its own return instruction, proves
that these simulations are incorrect.
Other simulations are shown, which prove that it is possible for a
simulation to reach the return of a HHH that aborts.
But HHH cannot possibly reach the return of its *own* simulation.
So, you are proving that HHH cannot possibly simulate itself correctly.


DDD is a misleading and unneeded complication. It is easy to eliminate DDD:

int main() {
return HHH(main);
}

This has the same problem. This proves that the problem is not in DDD,
but in HHH, which halts when it aborts the simulation, but it decides
that the simulation of itself does not halt.
It shows that HHH cannot possibly simulate itself correctly.

HHH is simply unable to decide about finite recursions.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

It decides after N recursions that there is an infinite recursion, which
is incorrect.

Olcott's HHH is programmed to abort the simulation after N cycles of
recursive simulations. Therefore, it is incorrect to abort the
simulation of HHH when the simulated HHH has performed only N-1 cycles, because that changes the behaviour of HHH.
Since the simulated HHH always runs one cycle behind the simulating HHH,
it is clear that HHH can never simulate enough cycles for a correct simulation, as is required by the x86 language.
Therefore, the simulation is incorrect according to the criteria olcott stipulated.
The conclusion is simple:
HHH cannot possibly simulate itself correctly.

No matter how much olcott wants it to be correct, or how many times
olcott repeats that it is correct, it does not change the fact that such
a simulation is incorrect, because it is unable to reach the end.
Olcott's own claim that the simulated HHH does not reach its end
confirms it. The trace he has shown also proves that HHH cannot reach
the end of its own simulation. So, his own claims prove that it is true
that HHH cannot possibly simulate itself up to the end, which makes the simulation incorrect.

Sipser would agree that this incorrect simulation cannot be used to
detect a non-halting behaviour.

Olcott does not know how to point to an error in this explanation, but
prefers to ignore it. He even consistently removes it from the
citations. So, I will repeat it, until either an error is found, or
olcott admits that HHH cannot possibly simulate itself correctly.
--- Synchronet 3.20a-Linux NewsLink 1.114