void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
01 int DD(int (*x)())
02 {
03 int Halt_Status = HH(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 int main()
10 {
11 Output("Input_Halts = ", HH(DD,DD));
12 }
DD simulated by HHH has the same behavior
as DDD simulated by HHH.
CAR T infusion tomorrow.
(drastic cancer treatment)
On 4/3/2025 8:59 PM, Richard Damon wrote:
On 4/3/25 9:27 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
But if HHH doesn't do a complete emulation, it doesn't show that its
input is non-halting,
In other words you're convinced that a C
program cannot see what every C programmer sees?
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
On 4/3/2025 8:59 PM, Richard Damon wrote:
On 4/3/25 9:27 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
But if HHH doesn't do a complete emulation, it doesn't show that its
input is non-halting,
In other words you're convinced that a C
program cannot see what every C programmer sees?
On 4/4/2025 3:12 AM, Mikko wrote:
On 2025-04-04 01:27:15 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
Anyone knowing the C language can see that if DDD() does not halt
it means that HHH(DDD) does not halt. The knowledge that that
means that HHH is not a decider is possible but not required.
*Perpetually ignoring this is not any actual rebuttal at all*
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination. The
only rebuttal to this is rejecting the notion that
deciders must always halt.
On 4/3/2025 10:09 PM, Richard Damon wrote:
On 4/3/25 10:06 PM, olcott wrote:
On 4/3/2025 8:59 PM, Richard Damon wrote:
On 4/3/25 9:27 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
But if HHH doesn't do a complete emulation, it doesn't show that its
input is non-halting,
In other words you're convinced that a C
program cannot see what every C programmer sees?
The problem is that you are looking at the wrong thing, because you
have beleived your own lies. It isn't what people "see", it is what is
the answer to the actual question.
That you disagree with truisms makes you look quite foolish.
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination. The
only rebuttal to this is rejecting the notion that
deciders must always halt.
On 4/5/2025 2:05 AM, Mikko wrote:
On 2025-04-05 06:18:06 +0000, olcott said:
On 4/4/2025 3:12 AM, Mikko wrote:
On 2025-04-04 01:27:15 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
Anyone knowing the C language can see that if DDD() does not halt
it means that HHH(DDD) does not halt. The knowledge that that
means that HHH is not a decider is possible but not required.
*Perpetually ignoring this is not any actual rebuttal at all*
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination. The
only rebuttal to this is rejecting the notion that
deciders must always halt.
Wrong, because a termination analyzer is not required to halt.
Why say things that you know are untrue?
A termination analyzer that doesn't halt
would flunk every proof of total program correctness.
On 4/6/2025 5:27 AM, Mikko wrote:
On 2025-04-05 16:45:28 +0000, olcott said:
On 4/5/2025 2:05 AM, Mikko wrote:
On 2025-04-05 06:18:06 +0000, olcott said:
On 4/4/2025 3:12 AM, Mikko wrote:
On 2025-04-04 01:27:15 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
Anyone knowing the C language can see that if DDD() does not halt
it means that HHH(DDD) does not halt. The knowledge that that
means that HHH is not a decider is possible but not required.
*Perpetually ignoring this is not any actual rebuttal at all*
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination. The
only rebuttal to this is rejecting the notion that
deciders must always halt.
Wrong, because a termination analyzer is not required to halt.
Why say things that you know are untrue?
The term "termination analyzer" is used about programs that do not halt
on every input. There is no strict derfiniton of the term so there is
no requirement about halting.
On the first page of https://www.cs.princeton.edu/~zkincaid/pub/
pldi21.pdf
in the first parapgraph of Introduction:
For example, termination analyzers may themselves fail to
terminate on
some input programs, or ...
A termination analyzer that doesn't halt
would flunk every proof of total program correctness.
There are no total termination analyzers.
Total proof of correctness does not require a halt
decider, it only requires a termination analyzer
with inputs in its domain.
On 4/6/2025 5:27 AM, Mikko wrote:
On 2025-04-05 16:45:28 +0000, olcott said:
On 4/5/2025 2:05 AM, Mikko wrote:
On 2025-04-05 06:18:06 +0000, olcott said:
On 4/4/2025 3:12 AM, Mikko wrote:
On 2025-04-04 01:27:15 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
Anyone knowing the C language can see that if DDD() does not halt
it means that HHH(DDD) does not halt. The knowledge that that
means that HHH is not a decider is possible but not required.
*Perpetually ignoring this is not any actual rebuttal at all*
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination. The
only rebuttal to this is rejecting the notion that
deciders must always halt.
Wrong, because a termination analyzer is not required to halt.
Why say things that you know are untrue?
The term "termination analyzer" is used about programs that do not halt
on every input. There is no strict derfiniton of the term so there is
no requirement about halting.
On the first page of https://www.cs.princeton.edu/~zkincaid/pub/pldi21.pdf >> in the first parapgraph of Introduction:
For example, termination analyzers may themselves fail to terminate on >> some input programs, or ...
A termination analyzer that doesn't halt
would flunk every proof of total program correctness.
There are no total termination analyzers.
Total proof of correctness does not require a halt
decider, it only requires a termination analyzer
with inputs in its domain.
On 4/6/2025 11:25 AM, Richard Damon wrote:
On 4/6/25 12:12 PM, olcott wrote:
On 4/6/2025 5:27 AM, Mikko wrote:
On 2025-04-05 16:45:28 +0000, olcott said:
On 4/5/2025 2:05 AM, Mikko wrote:
On 2025-04-05 06:18:06 +0000, olcott said:
On 4/4/2025 3:12 AM, Mikko wrote:
On 2025-04-04 01:27:15 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
Anyone knowing the C language can see that if DDD() does not halt >>>>>>>> it means that HHH(DDD) does not halt. The knowledge that that
means that HHH is not a decider is possible but not required.
*Perpetually ignoring this is not any actual rebuttal at all*
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination. The
only rebuttal to this is rejecting the notion that
deciders must always halt.
Wrong, because a termination analyzer is not required to halt.
Why say things that you know are untrue?
The term "termination analyzer" is used about programs that do not halt >>>> on every input. There is no strict derfiniton of the term so there is
no requirement about halting.
On the first page of https://www.cs.princeton.edu/~zkincaid/pub/
pldi21.pdf
in the first parapgraph of Introduction:
For example, termination analyzers may themselves fail to
terminate on
some input programs, or ...
A termination analyzer that doesn't halt
would flunk every proof of total program correctness.
There are no total termination analyzers.
Total proof of correctness does not require a halt
decider, it only requires a termination analyzer
with inputs in its domain.
WRONG.
To prove Turing wrong,
Is not what a proof of total correctness means.
Only requires proving that a software function derives
values corresponding to its input for its domain of
inputs AND this software function halts for every
input.
On 4/7/2025 3:16 AM, Mikko wrote:
On 2025-04-06 16:12:36 +0000, olcott said:
On 4/6/2025 5:27 AM, Mikko wrote:
On 2025-04-05 16:45:28 +0000, olcott said:
On 4/5/2025 2:05 AM, Mikko wrote:
On 2025-04-05 06:18:06 +0000, olcott said:
On 4/4/2025 3:12 AM, Mikko wrote:
On 2025-04-04 01:27:15 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
Anyone knowing the C language can see that if DDD() does not halt >>>>>>>> it means that HHH(DDD) does not halt. The knowledge that that
means that HHH is not a decider is possible but not required.
*Perpetually ignoring this is not any actual rebuttal at all*
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination. The
only rebuttal to this is rejecting the notion that
deciders must always halt.
Wrong, because a termination analyzer is not required to halt.
Why say things that you know are untrue?
The term "termination analyzer" is used about programs that do not halt >>>> on every input. There is no strict derfiniton of the term so there is
no requirement about halting.
On the first page of https://www.cs.princeton.edu/~zkincaid/pub/
pldi21.pdf
in the first parapgraph of Introduction:
For example, termination analyzers may themselves fail to
terminate on
some input programs, or ...
A termination analyzer that doesn't halt
would flunk every proof of total program correctness.
There are no total termination analyzers.
Total proof of correctness does not require a halt
decider, it only requires a termination analyzer
with inputs in its domain.
Depends on what one wants to prove correct.
Often there is no way to determine whether a pariticular termination
analyser can determine about a particular program.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
Rational minds would agree that the above principle
is correct and directly applies to HHH(DD) rejecting
its input.
On 4/7/2025 3:16 AM, Mikko wrote:
On 2025-04-06 16:12:36 +0000, olcott said:
On 4/6/2025 5:27 AM, Mikko wrote:
On 2025-04-05 16:45:28 +0000, olcott said:
On 4/5/2025 2:05 AM, Mikko wrote:
On 2025-04-05 06:18:06 +0000, olcott said:
On 4/4/2025 3:12 AM, Mikko wrote:
On 2025-04-04 01:27:15 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
Anyone knowing the C language can see that if DDD() does not halt >>>>>>>> it means that HHH(DDD) does not halt. The knowledge that that
means that HHH is not a decider is possible but not required.
*Perpetually ignoring this is not any actual rebuttal at all*
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination. The
only rebuttal to this is rejecting the notion that
deciders must always halt.
Wrong, because a termination analyzer is not required to halt.
Why say things that you know are untrue?
The term "termination analyzer" is used about programs that do not halt >>>> on every input. There is no strict derfiniton of the term so there is
no requirement about halting.
On the first page of https://www.cs.princeton.edu/~zkincaid/pub/ pldi21.pdf
in the first parapgraph of Introduction:
For example, termination analyzers may themselves fail to terminate on
some input programs, or ...
A termination analyzer that doesn't halt
would flunk every proof of total program correctness.
There are no total termination analyzers.
Total proof of correctness does not require a halt
decider, it only requires a termination analyzer
with inputs in its domain.
Depends on what one wants to prove correct.
Often there is no way to determine whether a pariticular termination
analyser can determine about a particular program.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
Rational minds would agree that the above principle
is correct and directly applies to HHH(DD) rejecting
its input.
On 4/7/2025 3:16 AM, Mikko wrote:
On 2025-04-06 16:12:36 +0000, olcott said:
On 4/6/2025 5:27 AM, Mikko wrote:
On 2025-04-05 16:45:28 +0000, olcott said:
On 4/5/2025 2:05 AM, Mikko wrote:
On 2025-04-05 06:18:06 +0000, olcott said:
On 4/4/2025 3:12 AM, Mikko wrote:
On 2025-04-04 01:27:15 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
Anyone knowing the C language can see that if DDD() does not halt >>>>>>>> it means that HHH(DDD) does not halt. The knowledge that that
means that HHH is not a decider is possible but not required.
*Perpetually ignoring this is not any actual rebuttal at all*
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination. The
only rebuttal to this is rejecting the notion that
deciders must always halt.
Wrong, because a termination analyzer is not required to halt.
Why say things that you know are untrue?
The term "termination analyzer" is used about programs that do not halt >>>> on every input. There is no strict derfiniton of the term so there is
no requirement about halting.
On the first page of https://www.cs.princeton.edu/~zkincaid/pub/
pldi21.pdf
in the first parapgraph of Introduction:
For example, termination analyzers may themselves fail to
terminate on
some input programs, or ...
A termination analyzer that doesn't halt
would flunk every proof of total program correctness.
There are no total termination analyzers.
Total proof of correctness does not require a halt
decider, it only requires a termination analyzer
with inputs in its domain.
Depends on what one wants to prove correct.
Often there is no way to determine whether a pariticular termination
analyser can determine about a particular program.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
Rational minds would agree that the above principle
is correct and directly applies to HHH(DD) rejecting
its input.
On 4/7/2025 5:51 AM, Richard Damon wrote:
On 4/7/25 12:28 AM, olcott wrote:
On 4/6/2025 11:25 AM, Richard Damon wrote:
On 4/6/25 12:12 PM, olcott wrote:
On 4/6/2025 5:27 AM, Mikko wrote:
On 2025-04-05 16:45:28 +0000, olcott said:
On 4/5/2025 2:05 AM, Mikko wrote:
On 2025-04-05 06:18:06 +0000, olcott said:
On 4/4/2025 3:12 AM, Mikko wrote:
On 2025-04-04 01:27:15 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
Anyone knowing the C language can see that if DDD() does not halt >>>>>>>>>> it means that HHH(DDD) does not halt. The knowledge that that >>>>>>>>>> means that HHH is not a decider is possible but not required. >>>>>>>>>>
*Perpetually ignoring this is not any actual rebuttal at all* >>>>>>>>>
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination. The
only rebuttal to this is rejecting the notion that
deciders must always halt.
Wrong, because a termination analyzer is not required to halt.
Why say things that you know are untrue?
The term "termination analyzer" is used about programs that do not >>>>>> halt
on every input. There is no strict derfiniton of the term so there is >>>>>> no requirement about halting.
On the first page of https://www.cs.princeton.edu/~zkincaid/pub/
pldi21.pdf
in the first parapgraph of Introduction:
For example, termination analyzers may themselves fail to
terminate on
some input programs, or ...
A termination analyzer that doesn't halt
would flunk every proof of total program correctness.
There are no total termination analyzers.
Total proof of correctness does not require a halt
decider, it only requires a termination analyzer
with inputs in its domain.
WRONG.
To prove Turing wrong,
Is not what a proof of total correctness means.
Only requires proving that a software function derives
values corresponding to its input for its domain of
inputs AND this software function halts for every
input.
First, you don't understand what "correctness" means, as it needs to
derives a CORRECT value corresponding to its input, not just any old
value.
YES
And, to be able to show that it halts for every input,
Termination Analyzers applied to a C function that
has no parameters is a simple exmaple of this.
you need to first prove Turing wrong, as he shows that operation to be
impossible in general.
I first start with a termination analyzer on a
single input that has no inputs.
Note, this doesn't say that proving a specific program is correct is
impossible, because we can correctly show that many programs are
halting, and even show them to always terminate. The limitation is
that no analyzer will be correct for ALL inputs.
This might not be the same domain as the domain for halt
deciders. Termination analyzers may be correct when they
conform to this:
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
OF course, your claim that a correct program only needs to return some
value corresponding to its input, and not a correct value, opens your
crack for it to use a wrong correspondence, like your straw-man
relationship.
It seems to me that reasonable minds would agree with the above
*Simulating termination analyzer Principle*
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 06:33 schreef olcott:
On 4/7/2025 3:16 AM, Mikko wrote:
On 2025-04-06 16:12:36 +0000, olcott said:
On 4/6/2025 5:27 AM, Mikko wrote:
On 2025-04-05 16:45:28 +0000, olcott said:
On 4/5/2025 2:05 AM, Mikko wrote:
On 2025-04-05 06:18:06 +0000, olcott said:
On 4/4/2025 3:12 AM, Mikko wrote:
On 2025-04-04 01:27:15 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
Anyone knowing the C language can see that if DDD() does not halt >>>>>>>>>> it means that HHH(DDD) does not halt. The knowledge that that >>>>>>>>>> means that HHH is not a decider is possible but not required. >>>>>>>>>>
*Perpetually ignoring this is not any actual rebuttal at all* >>>>>>>>>
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination. The
only rebuttal to this is rejecting the notion that
deciders must always halt.
Wrong, because a termination analyzer is not required to halt.
Why say things that you know are untrue?
The term "termination analyzer" is used about programs that do not >>>>>> halt
on every input. There is no strict derfiniton of the term so there is >>>>>> no requirement about halting.
On the first page of https://www.cs.princeton.edu/~zkincaid/pub/
pldi21.pdf
in the first parapgraph of Introduction:
For example, termination analyzers may themselves fail to
terminate on
some input programs, or ...
A termination analyzer that doesn't halt
would flunk every proof of total program correctness.
There are no total termination analyzers.
Total proof of correctness does not require a halt
decider, it only requires a termination analyzer
with inputs in its domain.
Depends on what one wants to prove correct.
Often there is no way to determine whether a pariticular termination
analyser can determine about a particular program.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite string
specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle*
Anyone with sufficient competence with the C programming language
will understand this.
On 4/8/2025 2:51 AM, Mikko wrote:
On 2025-04-08 04:33:57 +0000, olcott said:
On 4/7/2025 3:16 AM, Mikko wrote:
On 2025-04-06 16:12:36 +0000, olcott said:
On 4/6/2025 5:27 AM, Mikko wrote:
On 2025-04-05 16:45:28 +0000, olcott said:
On 4/5/2025 2:05 AM, Mikko wrote:
On 2025-04-05 06:18:06 +0000, olcott said:
On 4/4/2025 3:12 AM, Mikko wrote:
On 2025-04-04 01:27:15 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
Anyone knowing the C language can see that if DDD() does not halt >>>>>>>>>> it means that HHH(DDD) does not halt. The knowledge that that >>>>>>>>>> means that HHH is not a decider is possible but not required. >>>>>>>>>>
*Perpetually ignoring this is not any actual rebuttal at all* >>>>>>>>>
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination. The
only rebuttal to this is rejecting the notion that
deciders must always halt.
Wrong, because a termination analyzer is not required to halt.
Why say things that you know are untrue?
The term "termination analyzer" is used about programs that do not >>>>>> halt
on every input. There is no strict derfiniton of the term so there is >>>>>> no requirement about halting.
On the first page of https://www.cs.princeton.edu/~zkincaid/pub/
pldi21.pdf
in the first parapgraph of Introduction:
For example, termination analyzers may themselves fail to
terminate on
some input programs, or ...
A termination analyzer that doesn't halt
would flunk every proof of total program correctness.
There are no total termination analyzers.
Total proof of correctness does not require a halt
decider, it only requires a termination analyzer
with inputs in its domain.
Depends on what one wants to prove correct.
Often there is no way to determine whether a pariticular termination
analyser can determine about a particular program.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
Rational minds would agree that the above principle
is correct and directly applies to HHH(DD) rejecting
its input.
From the meaning of the word "correct" obviously follows that it is
never correct to reject a terminating input as non-terminating.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle*
Anyone with sufficient competence with the C programming language
will understand this.
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 06:33 schreef olcott:
On 4/7/2025 3:16 AM, Mikko wrote:
On 2025-04-06 16:12:36 +0000, olcott said:
On 4/6/2025 5:27 AM, Mikko wrote:
On 2025-04-05 16:45:28 +0000, olcott said:
On 4/5/2025 2:05 AM, Mikko wrote:
On 2025-04-05 06:18:06 +0000, olcott said:
On 4/4/2025 3:12 AM, Mikko wrote:
On 2025-04-04 01:27:15 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?
Anyone knowing the C language can see that if DDD() does not halt >>>>>>>>>> it means that HHH(DDD) does not halt. The knowledge that that >>>>>>>>>> means that HHH is not a decider is possible but not required. >>>>>>>>>>
*Perpetually ignoring this is not any actual rebuttal at all* >>>>>>>>>
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination. The
only rebuttal to this is rejecting the notion that
deciders must always halt.
Wrong, because a termination analyzer is not required to halt.
Why say things that you know are untrue?
The term "termination analyzer" is used about programs that do not >>>>>> halt
on every input. There is no strict derfiniton of the term so there is >>>>>> no requirement about halting.
On the first page of https://www.cs.princeton.edu/~zkincaid/pub/
pldi21.pdf
in the first parapgraph of Introduction:
For example, termination analyzers may themselves fail to
terminate on
some input programs, or ...
A termination analyzer that doesn't halt
would flunk every proof of total program correctness.
There are no total termination analyzers.
Total proof of correctness does not require a halt
decider, it only requires a termination analyzer
with inputs in its domain.
Depends on what one wants to prove correct.
Often there is no way to determine whether a pariticular termination
analyser can determine about a particular program.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite string
specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle*
Anyone with sufficient competence with the C programming language
will understand this.
Olcott does not understand that. If the simulation would not stop, it
would reach the end.
Rational minds would agree that the above principle
is correct and directly applies to HHH(DD) rejecting
its input.
HHH correctly reports that it could not reach the end of the
simulation of a halting program.
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite string
specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle*
Anyone with sufficient competence with the C programming language
will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite string
specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle*
Anyone with sufficient competence with the C programming language
will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
If I didn't have to tell you this hundreds of times and you didn't
persist in the straw-man deception I would not have called you a nitwit.
On 4/9/2025 3:56 PM, dbush wrote:
On 4/9/2025 4:35 PM, olcott wrote:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite
string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>>>> Anyone with sufficient competence with the C programming language >>>>>>> will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
then the simulated HHH would return to DD and DD would halt.
Simply over your level of technical competence.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
Which means HHH has conflicting requirements,
No, it just means that the ones that you have
been saying are f-cked up and no-one noticed this before.
because to perform aIn other words you simply "don't believe in" the variant
correct simulation of its input it cannot halt itself, and therefore
can't report that.
form of mathematical induction that HHH uses.
A proof by induction consists of two cases. The first, the base case,
proves the statement for 𝑛=0 without assuming any knowledge of other cases. The second case, the induction step, proves that if the statement holds for any given case 𝑛=k, then it must also hold for the next case 𝑛=k+1. These two steps establish that the statement holds for every natural number 𝑛. The base case does not necessarily begin with 𝑛=0, but
often with 𝑛=1, and possibly with any fixed natural number 𝑛=𝒩, establishing the truth of the statement for all natural numbers 𝑛 ≥ 𝒩.
https://en.wikipedia.org/wiki/Mathematical_induction
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite string >>>>>> specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>> Anyone with sufficient competence with the C programming language
will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
then the simulated HHH would return to DD and DD would halt.
Simply over your level of technical competence.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
because the programmer was dreaming of an infinite recursion.
If I didn't have to tell you this hundreds of times and you didn't
persist in the straw-man deception I would not have called you a nitwit.
I really think that you may simply be a troll playing head games.
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:That would make HHH to never halt. But HHH aborts and halts. By this
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite
string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>> Anyone with sufficient competence with the C programming language
will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
then the simulated HHH would return to DD and DD would halt.
No way, José:
By "correctly simulate" I mean a simulation or an emulation
of DD by HHH that obeys the semantics of the C or the x86utm
programming languages respectfully. This expressly includes
that HHH simulates/emulates itself simulating/emulating DD.
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite
string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>> Anyone with sufficient competence with the C programming language
will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
then the simulated HHH would return to DD and DD would halt.
Simply over your level of technical competence.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
because the programmer was dreaming of an infinite recursion.
If I didn't have to tell you this hundreds of times and you didn't
persist in the straw-man deception I would not have called you a nitwit.
I really think that you may simply be a troll playing head games.
On 4/9/2025 3:56 PM, dbush wrote:
On 4/9/2025 4:35 PM, olcott wrote:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite
string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>>>> Anyone with sufficient competence with the C programming language >>>>>>> will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
then the simulated HHH would return to DD and DD would halt.
Simply over your level of technical competence.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
Which means HHH has conflicting requirements,
No, it just means that the ones that you have
been saying are f-cked up and no-one noticed this before.
because to perform aIn other words you simply "don't believe in" the variant
correct simulation of its input it cannot halt itself, and therefore
can't report that.
form of mathematical induction that HHH uses.
A proof by induction consists of two cases. The first, the base case,
proves the statement for 𝑛=0 without assuming any knowledge of other cases. The second case, the induction step, proves that if the statement holds for any given case 𝑛=k, then it must also hold for the next case 𝑛=k+1. These two steps establish that the statement holds for every natural number 𝑛. The base case does not necessarily begin with 𝑛=0, but
often with 𝑛=1, and possibly with any fixed natural number 𝑛=𝒩, establishing the truth of the statement for all natural numbers 𝑛 ≥ 𝒩.
https://en.wikipedia.org/wiki/Mathematical_induction
On 4/9/2025 9:11 PM, dbush wrote:
On 4/9/2025 9:47 PM, olcott wrote:
On 4/9/2025 3:56 PM, dbush wrote:
On 4/9/2025 4:35 PM, olcott wrote:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite >>>>>>>>>> string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer
Principle*
Anyone with sufficient competence with the C programming language >>>>>>>>> will understand this.
HHH returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
DD) then the simulated HHH would return to DD and DD would halt.
Simply over your level of technical competence.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
Which means HHH has conflicting requirements,
No, it just means that the ones that you have
been saying are f-cked up and no-one noticed this before.
because to perform aIn other words you simply "don't believe in" the variant
correct simulation of its input it cannot halt itself, and therefore >>> > can't report that.
form of mathematical induction that HHH uses.
No, because the form it uses is "changing the input".
Changing the input is not allowed.
I never changed the input.That you say that I have
changed the input is intentional deception.
On 4/10/2025 2:56 AM, Mikko wrote:
On 2025-04-09 20:35:30 +0000, olcott said:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite
string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>>>> Anyone with sufficient competence with the C programming language >>>>>>> will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
then the simulated HHH would return to DD and DD would halt.
Simply over your level of technical competence.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
because the programmer was dreaming of an infinite recursion.
If I didn't have to tell you this hundreds of times and you didn't
persist in the straw-man deception I would not have called you a
nitwit.
I really think that you may simply be a troll playing head games.
It is not a good idea to think that everybody is just like you.
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
The only rebuttal to this is to stupidly reject the
notion that all deciders must always halt.
On 4/10/2025 3:52 AM, Fred. Zwarts wrote:
Op 09.apr.2025 om 22:35 schreef olcott:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite
string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>>>> Anyone with sufficient competence with the C programming language >>>>>>> will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
then the simulated HHH would return to DD and DD would halt.
Simply over your level of technical competence.
Ad hominem attack in an attempt to hide that no rebuttal exists.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
Yes, HHH correctly reports that it failed to complete the simulation.
because the programmer was dreaming of an infinite recursion.
If I didn't have to tell you this hundreds of times and you didn't
persist in the straw-man deception I would not have called you a
nitwit.
I really think that you may simply be a troll playing head games.
You are thinking many things that are wrong.
The things that I say are proven completely correct
entirely on the basis of the meaning of their words.
On 4/10/2025 3:49 AM, Fred. Zwarts wrote:
Op 09.apr.2025 om 21:20 schreef olcott:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite
string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>>>> Anyone with sufficient competence with the C programming language >>>>>>> will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
then the simulated HHH would return to DD and DD would halt.
No way, José:
By "correctly simulate" I mean a simulation or an emulation
of DD by HHH that obeys the semantics of the C or the x86utm
programming languages respectfully. This expressly includes
that HHH simulates/emulates itself simulating/emulating DD.
That would make HHH to never halt.
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
The only rebuttal to this is to stupidly reject the notion
that all deciders must always halt.
HHH detects this pattern through mathematical induction
of n steps of DD emulated/simulated by HHH. The criteria
is that the emulated/simulated DD fails to ever reach its
own “return instruction” final halt state.
On 4/10/2025 6:25 PM, dbush wrote:
On 4/10/2025 7:07 PM, olcott wrote:
On 4/9/2025 11:05 PM, dbush wrote:
On 4/9/2025 11:54 PM, olcott wrote:
On 4/9/2025 9:11 PM, dbush wrote:
On 4/9/2025 9:47 PM, olcott wrote:
On 4/9/2025 3:56 PM, dbush wrote:
On 4/9/2025 4:35 PM, olcott wrote:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called >>>>>>>>>> by DD) then the simulated HHH would return to DD and DD would >>>>>>>>>> halt.
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that >>>>>>>>>>>> if HHH returns with a value 0, then DDD halts.
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination >>>>>>>>>>>>>>> analyzer to stop simulating and reject any input that >>>>>>>>>>>>>>> would otherwise prevent its own termination.
In this case there is nothing to prevent, because the >>>>>>>>>>>>>> finite string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer >>>>>>>>>>>>> Principle*
Anyone with sufficient competence with the C programming >>>>>>>>>>>>> language
will understand this.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
Simply over your level of technical competence.
But HHH failed to complete the simulation of the halting program, >>>>>>>>>HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
Which means HHH has conflicting requirements,
No, it just means that the ones that you have
been saying are f-cked up and no-one noticed this before.
because to perform atherefore
correct simulation of its input it cannot halt itself, and
can't report that.In other words you simply "don't believe in" the variant
form of mathematical induction that HHH uses.
No, because the form it uses is "changing the input".
Changing the input is not allowed.
I never changed the input.
You absolutely did when you used the form of induction you did.
You hypothesized changing the code of HHH, which is part of the input. >>>>
Changing the input, hypothetically or otherwise, is not allowed.
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
Except when doing so changes the input, as you're doing.
Changing the input is not allowed.
As I pointed out simulating termination analyzers
are inherently required to terminate the simulation
of any input that would prevent their own termination.
To say this is not allowed stupidly ignores the basic
requirement that termination analyzers must always halt.
On 4/10/2025 5:57 AM, Richard Damon wrote:
On 4/9/25 11:54 PM, olcott wrote:
On 4/9/2025 9:11 PM, dbush wrote:
On 4/9/2025 9:47 PM, olcott wrote:
On 4/9/2025 3:56 PM, dbush wrote:
On 4/9/2025 4:35 PM, olcott wrote:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:Simply over your level of technical competence.
If HHH would correctly simulate DD (and the functions called by >>>>>>>> DD) then the simulated HHH would return to DD and DD would halt. >>>>>>>
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if >>>>>>>>>> HHH returns with a value 0, then DDD halts.
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that >>>>>>>>>>>>> would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite >>>>>>>>>>>> string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer >>>>>>>>>>> Principle*
Anyone with sufficient competence with the C programming >>>>>>>>>>> language
will understand this.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
But HHH failed to complete the simulation of the halting program, >>>>>>>HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
Which means HHH has conflicting requirements,
No, it just means that the ones that you have
been saying are f-cked up and no-one noticed this before.
because to perform atherefore
correct simulation of its input it cannot halt itself, and
can't report that.In other words you simply "don't believe in" the variant
form of mathematical induction that HHH uses.
No, because the form it uses is "changing the input".
Changing the input is not allowed.
I never changed the input.That you say that I have
changed the input is intentional deception.
OF course you do, or you are admitting that you are just a liar, and
your emulator isn't just emulating its input.
Either the input includes all the code it calls, or it just can't be
emulated by your rules.
As the code itself conclusively proves and you have been
countlessly reminded of for several years it has always
emulated all of the code that is reachable from P,PP,D,DD,DDD.
Your problem is you just don't understand what you are talking about
because you beleive your own lies.
It is very stupid to say that they are lies when you understand
that I accept what I say as true. It is actionable libel for you
to say that I tell lies when you know that I believe what I say. Theoretically this could cost you your house.
On 4/10/2025 2:56 AM, Mikko wrote:
On 2025-04-09 20:35:30 +0000, olcott said:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite string >>>>>>>> specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>>>> Anyone with sufficient competence with the C programming language >>>>>>> will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
then the simulated HHH would return to DD and DD would halt.
Simply over your level of technical competence.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
because the programmer was dreaming of an infinite recursion.
If I didn't have to tell you this hundreds of times and you didn't
persist in the straw-man deception I would not have called you a nitwit. >>>>
I really think that you may simply be a troll playing head games.
It is not a good idea to think that everybody is just like you.
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
On 4/10/2025 2:56 AM, Mikko wrote:
On 2025-04-09 20:35:30 +0000, olcott said:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite
string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>>>> Anyone with sufficient competence with the C programming language >>>>>>> will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
then the simulated HHH would return to DD and DD would halt.
Simply over your level of technical competence.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
because the programmer was dreaming of an infinite recursion.
If I didn't have to tell you this hundreds of times and you didn't
persist in the straw-man deception I would not have called you a
nitwit.
I really think that you may simply be a troll playing head games.
It is not a good idea to think that everybody is just like you.
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
No proof of this principle has been shown so its use is not valid.
On 4/10/2025 3:49 AM, Fred. Zwarts wrote:
Op 09.apr.2025 om 21:20 schreef olcott:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite
string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>>>> Anyone with sufficient competence with the C programming language >>>>>>> will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
then the simulated HHH would return to DD and DD would halt.
No way, José:
By "correctly simulate" I mean a simulation or an emulation
of DD by HHH that obeys the semantics of the C or the x86utm
programming languages respectfully. This expressly includes
that HHH simulates/emulates itself simulating/emulating DD.
That would make HHH to never halt.
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
On 4/10/2025 3:49 AM, Fred. Zwarts wrote:
Op 09.apr.2025 om 21:20 schreef olcott:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite
string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>>>> Anyone with sufficient competence with the C programming language >>>>>>> will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
then the simulated HHH would return to DD and DD would halt.
No way, José:
By "correctly simulate" I mean a simulation or an emulation
of DD by HHH that obeys the semantics of the C or the x86utm
programming languages respectfully. This expressly includes
that HHH simulates/emulates itself simulating/emulating DD.
That would make HHH to never halt.
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
The only rebuttal to this is to stupidly reject the notion
that all deciders must always halt.
HHH detects this pattern through mathematical induction
of n steps of DD emulated/simulated by HHH. The criteria
is that the emulated/simulated DD fails to ever reach its
own “return instruction” final halt state.
On 4/10/2025 3:52 AM, Fred. Zwarts wrote:
Op 09.apr.2025 om 22:35 schreef olcott:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite
string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>>>> Anyone with sufficient competence with the C programming language >>>>>>> will understand this.
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
then the simulated HHH would return to DD and DD would halt.
Simply over your level of technical competence.
Ad hominem attack in an attempt to hide that no rebuttal exists.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
Yes, HHH correctly reports that it failed to complete the simulation.
because the programmer was dreaming of an infinite recursion.
If I didn't have to tell you this hundreds of times and you didn't
persist in the straw-man deception I would not have called you a
nitwit.
I really think that you may simply be a troll playing head games.
You are thinking many things that are wrong.
The things that I say are proven completely correct
entirely on the basis of the meaning of their words.
On 4/10/2025 3:55 AM, Fred. Zwarts wrote:
Op 10.apr.2025 om 03:47 schreef olcott:
On 4/9/2025 3:56 PM, dbush wrote:So the proof by induction shows that for any n HHH fails to complete
On 4/9/2025 4:35 PM, olcott wrote:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite >>>>>>>>>> string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer
Principle*
Anyone with sufficient competence with the C programming language >>>>>>>>> will understand this.
HHH returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
DD) then the simulated HHH would return to DD and DD would halt.
Simply over your level of technical competence.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
Which means HHH has conflicting requirements,
No, it just means that the ones that you have
been saying are f-cked up and no-one noticed this before.
because to perform aIn other words you simply "don't believe in" the variant
correct simulation of its input it cannot halt itself, and therefore >>> > can't report that.
form of mathematical induction that HHH uses.
A proof by induction consists of two cases. The first, the base case,
proves the statement for 𝑛=0 without assuming any knowledge of other
cases. The second case, the induction step, proves that if the
statement holds for any given case 𝑛=k, then it must also hold for
the next case 𝑛=k+1. These two steps establish that the statement
holds for every natural number 𝑛. The base case does not necessarily
begin with 𝑛=0, but often with 𝑛=1, and possibly with any fixed
natural number 𝑛=𝒩, establishing the truth of the statement for all >>> natural numbers 𝑛 ≥ 𝒩. https://en.wikipedia.org/wiki/
Mathematical_induction
the simulation. So, it has been proven that no HHH exists that is able
to simulate correctly. It always aborts before it sees that the
simulated HHH aborts as well.
Yet again over-your-head.
Unless the first HHH aborts none of them do because
they all have the exact same x86 machine code. This
did take me three 12 hour days to figure out.
Op 11.apr.2025 om 01:26 schreef olcott:
On 4/10/2025 3:55 AM, Fred. Zwarts wrote:
Op 10.apr.2025 om 03:47 schreef olcott:
On 4/9/2025 3:56 PM, dbush wrote:So the proof by induction shows that for any n HHH fails to complete
On 4/9/2025 4:35 PM, olcott wrote:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if >>>>>>>>> HHH returns with a value 0, then DDD halts.
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite >>>>>>>>>>> string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer
Principle*
Anyone with sufficient competence with the C programming language >>>>>>>>>> will understand this.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
DD) then the simulated HHH would return to DD and DD would halt.
Simply over your level of technical competence.
But HHH failed to complete the simulation of the halting program, >>>>>>HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
Which means HHH has conflicting requirements,
No, it just means that the ones that you have
been saying are f-cked up and no-one noticed this before.
because to perform aIn other words you simply "don't believe in" the variant
correct simulation of its input it cannot halt itself, and therefore >>>> > can't report that.
form of mathematical induction that HHH uses.
A proof by induction consists of two cases. The first, the base
case, proves the statement for 𝑛=0 without assuming any knowledge of >>>> other cases. The second case, the induction step, proves that if the
statement holds for any given case 𝑛=k, then it must also hold for
the next case 𝑛=k+1. These two steps establish that the statement
holds for every natural number 𝑛. The base case does not necessarily >>>> begin with 𝑛=0, but often with 𝑛=1, and possibly with any fixed
natural number 𝑛=𝒩, establishing the truth of the statement for all >>>> natural numbers 𝑛 ≥ 𝒩. https://en.wikipedia.org/wiki/
Mathematical_induction
the simulation. So, it has been proven that no HHH exists that is
able to simulate correctly. It always aborts before it sees that the
simulated HHH aborts as well.
Yet again over-your-head.
Unless the first HHH aborts none of them do because
they all have the exact same x86 machine code. This
did take me three 12 hour days to figure out.
The HHH that does not abort exists only in your dream. HHH does abort,
so a correct simulation would see that the simulated HHH aborts.
However, HHH fails to see its own abort, because it aborts after N
cycles where M>N cycles are needed for a correct simulation.
This has been pointed out to you hundredths of times, but it seems you
are unable to grap its meaning.
It is a pity to see that those three 12 hour days have disabled your
correct thinking.
On 4/11/2025 3:24 AM, Richard Heathfield wrote:
On 11/04/2025 08:57, Mikko wrote:
No proof of this principle has been shown so its use is not valid.
Wweellll...
No proof of Peano's axioms or Euclid's fifth postulate has been shown.
That doesn't mean we can't use them.
Mr Olcott can have his principle if he likes, but only by EITHER
proving it (which, as you say, he has not yet done) OR by taking it as
axiomatic, leaving the world of mainstream computer science behind
him, constructing his own computational 'geometry' so to speak, and
abandoning any claim to having overturned the Halting Problem. Navel
contemplation beckons.
Axioms are all very well, and he's free to invent as many as he
wishes, but nobody else is obliged to accept them.
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
The only rebuttal to this is to stupidly reject the notion
that all deciders must always halt.
On 2025-04-11 08:24:47 +0000, Richard Heathfield said:
On 11/04/2025 08:57, Mikko wrote:
No proof of this principle has been shown so its use is not
valid.
Wweellll...
No proof of Peano's axioms or Euclid's fifth postulate has been
shown. That doesn't mean we can't use them.
We can use them for situations where we can trust that they are
true.
On 11/04/2025 08:57, Mikko wrote:
No proof of this principle has been shown so its use is not valid.
Wweellll...
No proof of Peano's axioms or Euclid's fifth postulate has been shown.
That doesn't mean we can't use them.
On 4/11/2025 3:24 AM, Richard Heathfield wrote:Sure. Why doesn’t the STA simulate itself rejecting its input?
On 11/04/2025 08:57, Mikko wrote:
*Simulating termination analyzer Principle*No proof of this principle has been shown so its use is not valid.
No proof of Peano's axioms or Euclid's fifth postulate has been shown.
That doesn't mean we can't use them.
Mr Olcott can have his principle if he likes, but only by EITHER
proving it (which, as you say, he has not yet done) OR by taking it as
axiomatic, leaving the world of mainstream computer science behind him,
constructing his own computational 'geometry' so to speak, and
abandoning any claim to having overturned the Halting Problem. Navel
contemplation beckons.
Axioms are all very well, and he's free to invent as many as he wishes,
but nobody else is obliged to accept them.
It is always correct for any simulating termination analyzer to stop simulating and reject any input that would otherwise prevent its own termination.
Am Fri, 11 Apr 2025 10:56:32 -0500 schrieb olcott:
On 4/11/2025 3:24 AM, Richard Heathfield wrote:
On 11/04/2025 08:57, Mikko wrote:
Sure. Why doesn’t the STA simulate itself rejecting its input?*Simulating termination analyzer Principle*No proof of this principle has been shown so its use is not valid.
No proof of Peano's axioms or Euclid's fifth postulate has been shown.
That doesn't mean we can't use them.
Mr Olcott can have his principle if he likes, but only by EITHER
proving it (which, as you say, he has not yet done) OR by taking it as
axiomatic, leaving the world of mainstream computer science behind him,
constructing his own computational 'geometry' so to speak, and
abandoning any claim to having overturned the Halting Problem. Navel
contemplation beckons.
Axioms are all very well, and he's free to invent as many as he wishes,
but nobody else is obliged to accept them.
It is always correct for any simulating termination analyzer to stop
simulating and reject any input that would otherwise prevent its own
termination.
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:Such as what actually happens when you run it?
Op 09.apr.2025 om 19:29 schreef olcott:
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 06:33 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)Everyone with a little bit of C knowledge understands that if HHH*Simulating termination analyzer Principle*
It is always correct for any simulating termination analyzer to
stop simulating and reject any input that would otherwise prevent >>>>>>> its own termination.
In this case there is nothing to prevent, because the finite string >>>>>> specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>>
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH NOT ANY OTHER DAMN DDD IN THE UNIVERSE
NITWIT.
then the simulated HHH would return to DD and DD would halt.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its own correct
simulation (meaning the according to the semantics of the C programming language) and would be incorrect to report on any other behavior.
Am Wed, 09 Apr 2025 15:35:30 -0500 schrieb olcott:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 06:33 schreef olcott:
Such as what actually happens when you run it?If HHH would correctly simulate DD (and the functions called by DD)Everyone with a little bit of C knowledge understands that if HHH*Simulating termination analyzer Principle*
It is always correct for any simulating termination analyzer to >>>>>>>> stop simulating and reject any input that would otherwise prevent >>>>>>>> its own termination.
In this case there is nothing to prevent, because the finite string >>>>>>> specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>>>
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH NOT ANY OTHER DAMN DDD IN THE UNIVERSE
NITWIT.
then the simulated HHH would return to DD and DD would halt.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its own correct
simulation (meaning the according to the semantics of the C programming
language) and would be incorrect to report on any other behavior.
On 4/13/2025 3:54 AM, joes wrote:
Am Fri, 11 Apr 2025 10:56:32 -0500 schrieb olcott:
On 4/11/2025 3:24 AM, Richard Heathfield wrote:Sure. Why doesn’t the STA simulate itself rejecting its input?
On 11/04/2025 08:57, Mikko wrote:
*Simulating termination analyzer Principle*No proof of this principle has been shown so its use is not valid.
No proof of Peano's axioms or Euclid's fifth postulate has been shown. >>>> That doesn't mean we can't use them.
Mr Olcott can have his principle if he likes, but only by EITHER
proving it (which, as you say, he has not yet done) OR by taking it as >>>> axiomatic, leaving the world of mainstream computer science behind him, >>>> constructing his own computational 'geometry' so to speak, and
abandoning any claim to having overturned the Halting Problem. Navel
contemplation beckons.
Axioms are all very well, and he's free to invent as many as he wishes, >>>> but nobody else is obliged to accept them.
It is always correct for any simulating termination analyzer to stop
simulating and reject any input that would otherwise prevent its own
termination.
Because that is a STUPID idea and categorically impossible
because the outermost HHH sees its needs to stop simulating
before any inner HHH can possibly see this.
On 4/13/2025 5:08 AM, Richard Heathfield wrote:
On 13/04/2025 09:54, joes wrote:
[...] Why doesn’t the STA simulate itself rejecting its input?
The test-program and the program-under-test are not the same
program. The question is: Can DD simulated by HHH possibly
reach its own final halt state?
Or why doesn't it save itself a huge amount of code and simply
return 1 for all inputs?
Because that is a woefully stupid idea?
On 4/10/2025 6:27 PM, dbush wrote:
On 4/10/2025 7:26 PM, olcott wrote:
On 4/10/2025 3:55 AM, Fred. Zwarts wrote:
Op 10.apr.2025 om 03:47 schreef olcott:
On 4/9/2025 3:56 PM, dbush wrote:So the proof by induction shows that for any n HHH fails to complete
On 4/9/2025 4:35 PM, olcott wrote:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:Simply over your level of technical competence.
If HHH would correctly simulate DD (and the functions called by >>>>>>>> DD) then the simulated HHH would return to DD and DD would halt. >>>>>>>
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if >>>>>>>>>> HHH returns with a value 0, then DDD halts.
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that >>>>>>>>>>>>> would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite >>>>>>>>>>>> string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer >>>>>>>>>>> Principle*
Anyone with sufficient competence with the C programming >>>>>>>>>>> language
will understand this.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
But HHH failed to complete the simulation of the halting program, >>>>>>>HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
Which means HHH has conflicting requirements,
No, it just means that the ones that you have
been saying are f-cked up and no-one noticed this before.
because to perform atherefore
correct simulation of its input it cannot halt itself, and
can't report that.In other words you simply "don't believe in" the variant
form of mathematical induction that HHH uses.
A proof by induction consists of two cases. The first, the base
case, proves the statement for 𝑛=0 without assuming any knowledge >>>>> of other cases. The second case, the induction step, proves that if
the statement holds for any given case 𝑛=k, then it must also hold >>>>> for the next case 𝑛=k+1. These two steps establish that the
statement holds for every natural number 𝑛. The base case does not >>>>> necessarily begin with 𝑛=0, but often with 𝑛=1, and possibly with >>>>> any fixed natural number 𝑛=𝒩, establishing the truth of the
statement for all natural numbers 𝑛 ≥ 𝒩. https://
en.wikipedia.org/wiki/ Mathematical_induction
the simulation. So, it has been proven that no HHH exists that is
able to simulate correctly. It always aborts before it sees that the
simulated HHH aborts as well.
Yet again over-your-head.
Unless the first HHH aborts
Changing the input is not allowed.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
The alternative is the moronically stupid idea
that termination analyzers should allow themselves
to get get stuck in simulating an input that never halts.
Only internet trolls that don't giver a rat's ass for
truth would suggest this nutty alternative.
On 4/13/2025 5:08 AM, Richard Heathfield wrote:
On 13/04/2025 09:54, joes wrote:
Am Fri, 11 Apr 2025 10:56:32 -0500 schrieb olcott:
On 4/11/2025 3:24 AM, Richard Heathfield wrote:Sure. Why doesn’t the STA simulate itself rejecting its input?
On 11/04/2025 08:57, Mikko wrote:
*Simulating termination analyzer Principle*No proof of this principle has been shown so its use is not valid.
No proof of Peano's axioms or Euclid's fifth postulate has been shown. >>>>> That doesn't mean we can't use them.
Mr Olcott can have his principle if he likes, but only by EITHER
proving it (which, as you say, he has not yet done) OR by taking it as >>>>> axiomatic, leaving the world of mainstream computer science behind
him,
constructing his own computational 'geometry' so to speak, and
abandoning any claim to having overturned the Halting Problem. Navel >>>>> contemplation beckons.
Axioms are all very well, and he's free to invent as many as he
wishes,
but nobody else is obliged to accept them.
It is always correct for any simulating termination analyzer to stop
simulating and reject any input that would otherwise prevent its own
termination.
The test-program and the program-under-test are not the same
program. The question is: Can DD simulated by HHH possibly
reach its own final halt state?
Or why doesn't it save itself a huge amount of code and simply return
1 for all inputs?
Because that is a woefully stupid idea?
On 4/13/2025 3:54 AM, joes wrote:
Am Fri, 11 Apr 2025 10:56:32 -0500 schrieb olcott:
On 4/11/2025 3:24 AM, Richard Heathfield wrote:Sure. Why doesn’t the STA simulate itself rejecting its input?
On 11/04/2025 08:57, Mikko wrote:
*Simulating termination analyzer Principle*No proof of this principle has been shown so its use is not valid.
No proof of Peano's axioms or Euclid's fifth postulate has been shown. >>>> That doesn't mean we can't use them.
Mr Olcott can have his principle if he likes, but only by EITHER
proving it (which, as you say, he has not yet done) OR by taking it as >>>> axiomatic, leaving the world of mainstream computer science behind him, >>>> constructing his own computational 'geometry' so to speak, and
abandoning any claim to having overturned the Halting Problem. Navel
contemplation beckons.
Axioms are all very well, and he's free to invent as many as he wishes, >>>> but nobody else is obliged to accept them.
It is always correct for any simulating termination analyzer to stop
simulating and reject any input that would otherwise prevent its own
termination.
Because that is a STUPID idea and categorically impossible
because the outermost HHH sees its needs to stop simulating
before any inner HHH can possibly see this.
On 4/13/2025 3:46 PM, Fred. Zwarts wrote:
Op 13.apr.2025 om 21:59 schreef olcott:
On 4/13/2025 3:54 AM, joes wrote:
Am Fri, 11 Apr 2025 10:56:32 -0500 schrieb olcott:
On 4/11/2025 3:24 AM, Richard Heathfield wrote:Sure. Why doesn’t the STA simulate itself rejecting its input?
On 11/04/2025 08:57, Mikko wrote:
*Simulating termination analyzer Principle*No proof of this principle has been shown so its use is not valid. >>>>>>No proof of Peano's axioms or Euclid's fifth postulate has been
shown.
That doesn't mean we can't use them.
Mr Olcott can have his principle if he likes, but only by EITHER
proving it (which, as you say, he has not yet done) OR by taking
it as
axiomatic, leaving the world of mainstream computer science behind >>>>>> him,
constructing his own computational 'geometry' so to speak, and
abandoning any claim to having overturned the Halting Problem. Navel >>>>>> contemplation beckons.
Axioms are all very well, and he's free to invent as many as he
wishes,
but nobody else is obliged to accept them.
It is always correct for any simulating termination analyzer to stop >>>>> simulating and reject any input that would otherwise prevent its own >>>>> termination.
Because that is a STUPID idea and categorically impossible
because the outermost HHH sees its needs to stop simulating
before any inner HHH can possibly see this.
No, the outermost HHH does not see that. The programmer only dreamed
that it needs to stop.
Empirically proven, nitwit.
The outermost HHH aborts before it can see that no abort is needed,
because the innermost HHH would abort.
On 4/12/2025 3:51 AM, Richard Heathfield wrote:
On 12/04/2025 09:31, Mikko wrote:
On 2025-04-11 08:24:47 +0000, Richard Heathfield said:
On 11/04/2025 08:57, Mikko wrote:
No proof of this principle has been shown so its use is not valid.
Wweellll...
No proof of Peano's axioms or Euclid's fifth postulate has been
shown. That doesn't mean we can't use them.
We can use them for situations where we can trust that they are true.
Indeed. And Mr Olcott has his work cut out persuading us to trust his
principle. Maybe that's why he quotes it so often, in the hope that
constant repetition will make it /seem/ true.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
The alternative is the moronically stupid idea
that termination analyzers should allow themselves
to get get stuck in simulating an input that never halts.
Only internet trolls that don't giver a rat's ass for
truth would suggest this nutty alternative.
If a lie is only printed often enough, it becomes a quasi-truth, and
if such a truth is repeated often enough, it becomes an article of
belief, a dogma, and men will die for it.
Isa Blagden, The Crown of a Life (London: Hurst and Blackett,
1869), Vol. III, Ch. XI; p. 155.
If you repeat a lie many times, people are bound to start believing it.
Joseph Goebbels (attr)
And most of what Mr Olcott posts is... repetition.
What I have been saying has changed at least 10,000 times
(with progressive refinement) over the last three years.
People that only spew out canned fake rebuttals for the
sole purpose of maintaining contention won't notice this.
On 4/11/2025 2:57 AM, Mikko wrote:
On 2025-04-10 23:08:02 +0000, olcott said:
On 4/10/2025 2:56 AM, Mikko wrote:
On 2025-04-09 20:35:30 +0000, olcott said:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite >>>>>>>>>> string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer
Principle*
Anyone with sufficient competence with the C programming language >>>>>>>>> will understand this.
HHH returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
DD) then the simulated HHH would return to DD and DD would halt.
Simply over your level of technical competence.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
because the programmer was dreaming of an infinite recursion.
If I didn't have to tell you this hundreds of times and you didn't >>>>>> persist in the straw-man deception I would not have called you a
nitwit.
I really think that you may simply be a troll playing head games.
It is not a good idea to think that everybody is just like you.
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
No proof of this principle has been shown so its use is not valid.
The proof is self-evident.
Termination analyzers must halt (axiom) therefore
rejecting any input that would prevent the analyzer
from terminating is semantically entailed by this axiom.
On 4/13/2025 4:18 AM, joes wrote:
Am Wed, 09 Apr 2025 15:35:30 -0500 schrieb olcott:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 06:33 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD)Everyone with a little bit of C knowledge understands that if HHH*Simulating termination analyzer Principle*
It is always correct for any simulating termination analyzer to >>>>>>>>> stop simulating and reject any input that would otherwise prevent >>>>>>>>> its own termination.
In this case there is nothing to prevent, because the finite string >>>>>>>> specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) meets the above: *Simulating termination analyzer Principle* >>>>>>>
returns with a value 0, then DDD halts.
DDD CORRECTLY SIMULATED BY HHH NOT ANY OTHER DAMN DDD IN THE UNIVERSE >>>>> NITWIT.
then the simulated HHH would return to DD and DD would halt.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its own correct
simulation (meaning the according to the semantics of the C programming
language) and would be incorrect to report on any other behavior.
Such as what actually happens when you run it?
Why do you insist on dishonestly ignoring the pathological
self-reference difference?
On 4/13/2025 2:54 PM, dbush wrote:
On 4/13/2025 3:52 PM, olcott wrote:
On 4/13/2025 4:18 AM, joes wrote:
Am Wed, 09 Apr 2025 15:35:30 -0500 schrieb olcott:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 06:33 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD) >>>>>> then the simulated HHH would return to DD and DD would halt.Everyone with a little bit of C knowledge understands that if HHH >>>>>>>> returns with a value 0, then DDD halts.*Simulating termination analyzer Principle*
It is always correct for any simulating termination analyzer to >>>>>>>>>>> stop simulating and reject any input that would otherwise >>>>>>>>>>> prevent
its own termination.
In this case there is nothing to prevent, because the finite >>>>>>>>>> string
specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) meets the above: *Simulating termination analyzer
Principle*
DDD CORRECTLY SIMULATED BY HHH NOT ANY OTHER DAMN DDD IN THE
UNIVERSE
NITWIT.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its own correct
simulation (meaning the according to the semantics of the C
programming
language) and would be incorrect to report on any other behavior.
Such as what actually happens when you run it?
Why do you insist on dishonestly ignoring the pathological
self-reference difference?
Why do you insist on dishonestly ignoring that the input to HHH halts
when executed directly?
Because this stupidly ignores the difference
of pathological self-reference.
On 4/10/2025 6:44 PM, dbush wrote:
On 4/10/2025 7:39 PM, olcott wrote:
On 4/10/2025 6:25 PM, dbush wrote:
On 4/10/2025 7:07 PM, olcott wrote:
On 4/9/2025 11:05 PM, dbush wrote:
On 4/9/2025 11:54 PM, olcott wrote:
On 4/9/2025 9:11 PM, dbush wrote:
On 4/9/2025 9:47 PM, olcott wrote:
On 4/9/2025 3:56 PM, dbush wrote:
On 4/9/2025 4:35 PM, olcott wrote:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called >>>>>>>>>>>> by DD) then the simulated HHH would return to DD and DD >>>>>>>>>>>> would halt.
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that >>>>>>>>>>>>>> if HHH returns with a value 0, then DDD halts.
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination >>>>>>>>>>>>>>>>> analyzer to stop simulating and reject any input that >>>>>>>>>>>>>>>>> would otherwise prevent its own termination.
In this case there is nothing to prevent, because the >>>>>>>>>>>>>>>> finite string specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer >>>>>>>>>>>>>>> Principle*
Anyone with sufficient competence with the C programming >>>>>>>>>>>>>>> language
will understand this.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
Simply over your level of technical competence.
But HHH failed to complete the simulation of the halting >>>>>>>>>>>> program,
HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
Which means HHH has conflicting requirements,
No, it just means that the ones that you have
been saying are f-cked up and no-one noticed this before.
because to perform aIn other words you simply "don't believe in" the variant
correct simulation of its input it cannot halt itself, and >>>>>>>>> therefore
can't report that.
form of mathematical induction that HHH uses.
No, because the form it uses is "changing the input".
Changing the input is not allowed.
I never changed the input.
You absolutely did when you used the form of induction you did.
You hypothesized changing the code of HHH, which is part of the
input.
Changing the input, hypothetically or otherwise, is not allowed.
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
Except when doing so changes the input, as you're doing.
Changing the input is not allowed.
As I pointed out simulating termination analyzers
are inherently required to terminate the simulation
of any input that would prevent their own termination.
Category error. That would imply that the termination analyzer, i.e.
an algorithm, has some potential choice or variation.
termination analyzers must halt, disagreeing with
this is ALWAYS STUPID !!!
On 4/13/2025 3:46 PM, Fred. Zwarts wrote:
Op 13.apr.2025 om 21:59 schreef olcott:
On 4/13/2025 3:54 AM, joes wrote:
Am Fri, 11 Apr 2025 10:56:32 -0500 schrieb olcott:
On 4/11/2025 3:24 AM, Richard Heathfield wrote:Sure. Why doesn’t the STA simulate itself rejecting its input?
On 11/04/2025 08:57, Mikko wrote:
*Simulating termination analyzer Principle*No proof of this principle has been shown so its use is not valid. >>>>>>No proof of Peano's axioms or Euclid's fifth postulate has been
shown.
That doesn't mean we can't use them.
Mr Olcott can have his principle if he likes, but only by EITHER
proving it (which, as you say, he has not yet done) OR by taking
it as
axiomatic, leaving the world of mainstream computer science behind >>>>>> him,
constructing his own computational 'geometry' so to speak, and
abandoning any claim to having overturned the Halting Problem. Navel >>>>>> contemplation beckons.
Axioms are all very well, and he's free to invent as many as he
wishes,
but nobody else is obliged to accept them.
It is always correct for any simulating termination analyzer to stop >>>>> simulating and reject any input that would otherwise prevent its own >>>>> termination.
Because that is a STUPID idea and categorically impossible
because the outermost HHH sees its needs to stop simulating
before any inner HHH can possibly see this.
No, the outermost HHH does not see that. The programmer only dreamed
that it needs to stop.
Empirically proven, nitwit.
On 4/10/2025 6:27 PM, dbush wrote:
On 4/10/2025 7:26 PM, olcott wrote:
On 4/10/2025 3:55 AM, Fred. Zwarts wrote:
Op 10.apr.2025 om 03:47 schreef olcott:
On 4/9/2025 3:56 PM, dbush wrote:So the proof by induction shows that for any n HHH fails to complete
On 4/9/2025 4:35 PM, olcott wrote:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD) >>>>>>>> then the simulated HHH would return to DD and DD would halt.
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:Everyone with a little bit of C knowledge understands that if HHH >>>>>>>>>> returns with a value 0, then DDD halts.
Op 08.apr.2025 om 06:33 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that >>>>>>>>>>>>> would otherwise prevent its own termination.
In this case there is nothing to prevent, because the finite string
specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This stuff is simply over-your-head.
HHH(DD) meets the above: *Simulating termination analyzer Principle*
Anyone with sufficient competence with the C programming language >>>>>>>>>>> will understand this.
DDD CORRECTLY SIMULATED BY HHH
NOT ANY OTHER DAMN DDD IN THE UNIVERSE NITWIT.
Simply over your level of technical competence.
But HHH failed to complete the simulation of the halting program, >>>>>>>HHH is only required to report on the behavior of its
own correct simulation (meaning the according to the
semantics of the C programming language) and would be
incorrect to report on any other behavior.
Which means HHH has conflicting requirements,
No, it just means that the ones that you have
been saying are f-cked up and no-one noticed this before.
because to perform aIn other words you simply "don't believe in" the variant
correct simulation of its input it cannot halt itself, and therefore >>>>> > can't report that.
form of mathematical induction that HHH uses.
A proof by induction consists of two cases. The first, the base case, >>>>> proves the statement for 𝑛=0 without assuming any knowledge of other >>>>> cases. The second case, the induction step, proves that if the
statement holds for any given case 𝑛=k, then it must also hold for the >>>>> next case 𝑛=k+1. These two steps establish that the statement holds >>>>> for every natural number 𝑛. The base case does not necessarily begin >>>>> with 𝑛=0, but often with 𝑛=1, and possibly with any fixed natural >>>>> number 𝑛=𝒩, establishing the truth of the statement for all natural >>>>> numbers 𝑛 ≥ 𝒩. https://en.wikipedia.org/wiki/ Mathematical_induction
the simulation. So, it has been proven that no HHH exists that is able >>>> to simulate correctly. It always aborts before it sees that the
simulated HHH aborts as well.
Yet again over-your-head.
Unless the first HHH aborts
Changing the input is not allowed.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
On 4/13/2025 2:54 PM, dbush wrote:
On 4/13/2025 3:52 PM, olcott wrote:
On 4/13/2025 4:18 AM, joes wrote:
Am Wed, 09 Apr 2025 15:35:30 -0500 schrieb olcott:
On 4/9/2025 1:58 PM, Fred. Zwarts wrote:
Op 09.apr.2025 om 19:29 schreef olcott:
On 4/8/2025 10:31 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 17:13 schreef olcott:
On 4/8/2025 2:45 AM, Fred. Zwarts wrote:
Op 08.apr.2025 om 06:33 schreef olcott:
If HHH would correctly simulate DD (and the functions called by DD) >>>>>> then the simulated HHH would return to DD and DD would halt.Everyone with a little bit of C knowledge understands that if HHH >>>>>>>> returns with a value 0, then DDD halts.*Simulating termination analyzer Principle*
It is always correct for any simulating termination analyzer to >>>>>>>>>>> stop simulating and reject any input that would otherwise >>>>>>>>>>> prevent
its own termination.
In this case there is nothing to prevent, because the finite >>>>>>>>>> string
specifies a program that halts.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) meets the above: *Simulating termination analyzer
Principle*
DDD CORRECTLY SIMULATED BY HHH NOT ANY OTHER DAMN DDD IN THE
UNIVERSE
NITWIT.
But HHH failed to complete the simulation of the halting program,
HHH is only required to report on the behavior of its own correct
simulation (meaning the according to the semantics of the C
programming
language) and would be incorrect to report on any other behavior.
Such as what actually happens when you run it?
Why do you insist on dishonestly ignoring the pathological
self-reference difference?
Why do you insist on dishonestly ignoring that the input to HHH halts
when executed directly?
Because this stupidly ignores the difference
of pathological self-reference.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 164:35:40 |
| Calls: | 10,385 |
| Calls today: | 2 |
| Files: | 14,057 |
| Messages: | 6,416,518 |