Can you please verify that the analysis of these C functions is correct?

[olcott]

To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.

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

void Infinite_Loop()
{
HERE: goto HERE;
}

void Infinite_Recursion()
{
Infinite_Recursion();
}

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

int main()
{
H0(Infinite_Loop);
H0(Infinite_Recursion);
H0(DDD);
}

Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop, Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.

When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.

*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

[Bonita Montero]

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
  HERE: goto HERE;
}
void Infinite_Recursion()
{
  Infinite_Recursion();
}
void DDD()
{
  H0(DDD);
  return;
}
int main()
{
  H0(Infinite_Loop);
  H0(Infinite_Recursion);
  H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop, Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

Everything correct, no further questions allowed.

[olcott]

Post by Bonita Montero

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   H0(DDD);
   return;
}
int main()
{
   H0(Infinite_Loop);
   H0(Infinite_Recursion);
   H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop, Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

Everything correct, no further questions allowed.

That is great, I have no further questions about this.

[olcott]

Post by Bonita Montero

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   H0(DDD);
   return;
}
int main()
{
   H0(Infinite_Loop);
   H0(Infinite_Recursion);
   H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop, Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

Everything correct, no further questions allowed.

The reason that I have to come to the C/C++ forum with these
things is that C/C++ software engineers understand that code
does do what this code actually does do.

On the comp.theory forum people disagree that code does do what
it actually does do. They believe that their own misconceptions
carry more weight than the actual verified facts.

I say this full well knowing that some C functions do not
meet the requirements of Turing computable functions. The
functional result of my C functions <is> Turing computable.

*Entirely written in C besides x86utm.cpp*
https://github.com/plolcott/x86utm

[olcott]

Post by Bonita Montero

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   H0(DDD);
   return;
}
int main()
{
   H0(Infinite_Loop);
   H0(Infinite_Recursion);
   H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop, Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

Everything correct, no further questions allowed.

Thanks for your help on this. The Liars on comp.theory are
even lying about what you actually said.

[Richard Harnden]

Post by olcott

Post by Bonita Montero

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   H0(DDD);
   return;
}
int main()
{
   H0(Infinite_Loop);
   H0(Infinite_Recursion);
   H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop, Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

Everything correct, no further questions allowed.

Thanks for your help on this. The Liars on comp.theory are
even lying about what you actually said.

Pretty sure that Bonita was taking the piss.

[olcott]

Post by Richard Harnden

Post by olcott

Post by Bonita Montero

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   H0(DDD);
   return;
}
int main()
{
   H0(Infinite_Loop);
   H0(Infinite_Recursion);
   H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop, Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

Everything correct, no further questions allowed.

Thanks for your help on this. The Liars on comp.theory are
even lying about what you actually said.

Pretty sure that Bonita was taking the piss.

I would say that this would indicate that you are insufficiently
competent with the C programming language.

[Richard Damon]

Post by olcott

Post by Richard Harnden

Post by olcott

Post by Bonita Montero

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   H0(DDD);
   return;
}
int main()
{
   H0(Infinite_Loop);
   H0(Infinite_Recursion);
   H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop, Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

Everything correct, no further questions allowed.

Thanks for your help on this. The Liars on comp.theory are
even lying about what you actually said.

Pretty sure that Bonita was taking the piss.

I would say that this would indicate that you are insufficiently
competent with the C programming language.

It seems you are the one that doesn't know the C programing language.
After all, you didn't know about the unordering of sub-expressions, or
that this can lead to undefined behavior.

[olcott]

Post by Richard Damon

Post by olcott

Post by Richard Harnden

Post by olcott

Post by Bonita Montero

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   H0(DDD);
   return;
}
int main()
{
   H0(Infinite_Loop);
   H0(Infinite_Recursion);
   H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop,
Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

Everything correct, no further questions allowed.

Thanks for your help on this. The Liars on comp.theory are
even lying about what you actually said.

Pretty sure that Bonita was taking the piss.

I would say that this would indicate that you are insufficiently
competent with the C programming language.

It seems you are the one that doesn't know the C programing language.
After all, you didn't know about the unordering of sub-expressions, or
that this can lead to undefined behavior.

It seems pretty stupid to allow gaps in the semantics of C++ programs.
Simply specify that the order of evaluation is left to right unless:
(a) Otherwise specified such as operator precedence rules.
(b) Derives the same result as left to right ordering.

[Richard Damon]

Post by olcott

Post by Richard Damon

Post by olcott

Post by Richard Harnden

Post by olcott

Post by Bonita Montero

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   H0(DDD);
   return;
}
int main()
{
   H0(Infinite_Loop);
   H0(Infinite_Recursion);
   H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop,
Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

Everything correct, no further questions allowed.

Thanks for your help on this. The Liars on comp.theory are
even lying about what you actually said.

Pretty sure that Bonita was taking the piss.

I would say that this would indicate that you are insufficiently
competent with the C programming language.

It seems you are the one that doesn't know the C programing language.
After all, you didn't know about the unordering of sub-expressions, or
that this can lead to undefined behavior.

It seems pretty stupid to allow gaps in the semantics of C++ programs.
(a) Otherwise specified such as operator precedence rules.
(b) Derives the same result as left to right ordering.

Nope. The problem is that such a rule breaks the fundamental design
decisions that the goal is to make it possible to create as efficient
machine code as possible.

If you need the left to right evaluation order, there are ways to write
the code to make that happen.

One of the fundamental design decisions in the language is that it
trusts the programmer to know the rules, and will strive for the fastest
code possible.

C++ made a special rule for the << operator because the gain for its use
as an output was high enough, and the cost as a normal shift operator
was rarely high (and normally hidden by the "as if" rule) so it was done
there.

There are too many cases for the more general arguement that causes
measurable speed differences.

[Bonita Montero]

Post by Richard Damon
C++ made a special rule for the << operator because the gain for its use
as an output was high enough, and the cost as a normal shift operator
was rarely high (and normally hidden by the "as if" rule) so it was done
there.

I guess C++ doesn't make a statement on that and the ordered behaviour
depens in the cascaded return of the stream-object.

[Richard Damon]

Post by Bonita Montero

Post by Richard Damon
C++ made a special rule for the << operator because the gain for its
use as an output was high enough, and the cost as a normal shift
operator was rarely high (and normally hidden by the "as if" rule) so
it was done there.

I guess C++ doesn't make a statement on that and the ordered behaviour
depens in the cascaded return of the stream-object.

My understanding is that the Standard made that a requirement so the
cascaded operands would be computed in the right order.

Prior to that, it was allowed to compute the order of the terms being
output in any order, as the call to operator <<(ostream& strm, T& value)
was allowd to compute value before resolving stream (as the value from
the previous operator <<, which caught enough people off guard.

That was considered useful enough, and where << is used as the shift
operator, the restriction is unlikely to cause a large impact, so they
did it for that special case.

[Bonita Montero]

Post by Richard Damon
Prior to that, it was allowed to compute the order of the terms being
output in any order, as the call to operator <<(ostream& strm, T& value)
was allowd to compute value before resolving stream (as the value from
the previous operator <<, which caught enough people off guard.

With a left-associative operator the result of the left part has to be
calculated before it can be used with the right part.

[Richard Damon]

Post by Bonita Montero

Post by Richard Damon
Prior to that, it was allowed to compute the order of the terms being
output in any order, as the call to operator <<(ostream& strm, T&
value) was allowd to compute value before resolving stream (as the
value from the previous operator <<, which caught enough people off
guard.

With a left-associative operator the result of the left part has to be
calculated before it can be used with the right part.

But the right part can be calculated before the left part is.

so in the call sequence: statement a+b+c where a,b, and c are
expressions of user defined types this becomes

operator+(operator+(a, b), c)

the expressions a, b and c can be evaluated in any order.

The change was that for operator<< the order of evalutation is DEFINED
to be a, then b, then c. That order was NOT provided for +.

Yes, the outer call can't be done before the inner call returns, but
unless there is a specific requirement in the Standard, no order of the
sub-expressions is implied.

[David Brown]

Post by Bonita Montero

Post by Richard Damon
Prior to that, it was allowed to compute the order of the terms being
output in any order, as the call to operator <<(ostream& strm, T&
value) was allowd to compute value before resolving stream (as the
value from the previous operator <<, which caught enough people off
guard.

With a left-associative operator the result of the left part has to be
calculated before it can be used with the right part.

Both the left part and the right part need to be evaluated before the
operator between them can be evaluated - but the two parts can be
evaluated in either order (or even interleaved in their evaluation).
Associativity is irrelevant.


Before C++17 (which added the rules for sequencing for shifts, and made
a few other changes), if you had:

foo() << bar()

then the compiler could evaluate bar() then foo(), or foo() then bar().
It can still happily arrange them as it wants for "foo() + bar()".

<https://en.cppreference.com/w/cpp/language/eval_order>

[Bonita Montero]

Post by olcott
It seems pretty stupid to allow gaps in the semantics of C++ programs.
(a) Otherwise specified such as operator precedence rules.
(b) Derives the same result as left to right ordering.

Most UB is there to allow optimizations, also in this case.
I've got no problem with that.

[Chris M. Thomasson]

Post by Bonita Montero

Post by olcott
It seems pretty stupid to allow gaps in the semantics of C++ programs.
(a) Otherwise specified such as operator precedence rules.
(b) Derives the same result as left to right ordering.

Most UB is there to allow optimizations, also in this case.
I've got no problem with that.

Humm. Sounds reasonable. UB is there to be defined by a non-conforming
compiler? ;^)

[Richard Damon]

Post by Chris M. Thomasson

Post by Bonita Montero

Post by olcott
It seems pretty stupid to allow gaps in the semantics of C++
programs. Simply specify that the order of evaluation is left to
(a) Otherwise specified such as operator precedence rules.
(b) Derives the same result as left to right ordering.

Most UB is there to allow optimizations, also in this case.
I've got no problem with that.

Humm. Sounds reasonable. UB is there to be defined by a non-conforming
compiler? ;^)

Doesn't need to be Non-Conforming to define the behavior of Undefined
Behavior!

[Chris M. Thomasson]

Post by Richard Damon

Post by Chris M. Thomasson

Post by Bonita Montero

Post by olcott
It seems pretty stupid to allow gaps in the semantics of C++
programs. Simply specify that the order of evaluation is left to
(a) Otherwise specified such as operator precedence rules.
(b) Derives the same result as left to right ordering.

Most UB is there to allow optimizations, also in this case.
I've got no problem with that.

Humm. Sounds reasonable. UB is there to be defined by a non-conforming
compiler? ;^)

Doesn't need to be Non-Conforming to define the behavior of Undefined
Behavior!

Think of a system that takes advantage of UB. Remember way back when
standard C did not know about threads, ahhh... We had POSIX?

[Chris M. Thomasson]

Post by Richard Damon

Post by Chris M. Thomasson

Post by Bonita Montero

Post by olcott
It seems pretty stupid to allow gaps in the semantics of C++
programs. Simply specify that the order of evaluation is left to
(a) Otherwise specified such as operator precedence rules.
(b) Derives the same result as left to right ordering.

Most UB is there to allow optimizations, also in this case.
I've got no problem with that.

Humm. Sounds reasonable. UB is there to be defined by a non-conforming
compiler? ;^)

Doesn't need to be Non-Conforming to define the behavior of Undefined
Behavior!

Remember back when using threads in standard C was, technically, a
no-no, unless you went to POSIX, or windows threads, ect...? Heck, back
then, before C recognized threads, atomics and membars, I had to code my
critical sequences that implemented certain lock-free and wait-free
algorihtms in ASM:

https://web.archive.org/web/20071002183926/http://appcore.home.comcast.net/

;^)

[James Kuyper]

...

Post by Chris M. Thomasson

Post by Bonita Montero
Most UB is there to allow optimizations, also in this case.
I've got no problem with that.

Humm. Sounds reasonable. UB is there to be defined by a non-conforming
compiler? ;^)

By definition, non-conforming implementations can always do whatever
they like, regardless of whether the code has undefined behavior, merely
unspecified behavior, or even standard-defined behavior.

UB is for the benefit of conforming implementations. It gives them
permission to handle code that has UB any way they want, without
sacrificing conformance.

[David Brown]

Post by Chris M. Thomasson

Post by Bonita Montero

Post by olcott
It seems pretty stupid to allow gaps in the semantics of C++
programs. Simply specify that the order of evaluation is left to
(a) Otherwise specified such as operator precedence rules.
(b) Derives the same result as left to right ordering.

Most UB is there to allow optimizations, also in this case.
I've got no problem with that.

Humm. Sounds reasonable. UB is there to be defined by a non-conforming
compiler? ;^)

No, UB is there so that /conforming/ compilers don't have to implement
any specific behaviour for it, and can optimise assuming that either it
doesn't happen, or that you don't care about the results if it does happen.

It is also useful for static analysis and debugging and tools like
sanitizers - since UB is typically the result of something you don't
want to happen in your code, like overflows, debugging tools can add
extra code to tell you of such events. If overflow behaviour had been
defined, it would be normal and expected behaviour, and debugging tools
can't freely change that.

Compilers - conforming or not - are always free to pick a definition for
something that the standard says is undefined behaviour (either
explicitly, or by simply omitting a definition for the behaviour). If
they document this definition, you can view it as an extension and rely
on its use - if they don't document it, you rely on it at your own risk.

[David Brown]

Post by olcott

Post by Richard Damon

Post by olcott
I would say that this would indicate that you are insufficiently
competent with the C programming language.

It seems you are the one that doesn't know the C programing language.
After all, you didn't know about the unordering of sub-expressions, or
that this can lead to undefined behavior.

It seems pretty stupid to allow gaps in the semantics of C++ programs.
(a) Otherwise specified such as operator precedence rules.
(b) Derives the same result as left to right ordering.

The tighter you specify something, the less scope there is for
optimisations and generating more efficient code. It's a tradeoff. C
and C++, as languages aimed at (amongst other uses) generating efficient
code, have design decisions that give more flexibility to the compilers
rather than specifying the details of how implementations must work.

It is very simple to enforce the logical order of calculation of
subexpressions - use temporary variables. So the programmer has the
choice you are looking for, but needs to express it in a different way
from what you thought.

[Bonita Montero]

Post by olcott

Post by Bonita Montero

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   H0(DDD);
   return;
}
int main()
{
   H0(Infinite_Loop);
   H0(Infinite_Recursion);
   H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop, Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

Everything correct, no further questions allowed.

Thanks for your help on this. The Liars on comp.theory are
even lying about what you actually said.

Come up with some _practical_ issues which are related to C or C++.
You're asking things which are generic to a lot of languages.

[DFS]

Post by Bonita Montero

Post by olcott

Post by Bonita Montero

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   H0(DDD);
   return;
}
int main()
{
   H0(Infinite_Loop);
   H0(Infinite_Recursion);
   H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop, Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

Everything correct, no further questions allowed.

Thanks for your help on this. The Liars on comp.theory are
even lying about what you actually said.

Come up with some _practical_ issues which are related to C or C++.
You're asking things which are generic to a lot of languages.

Why are you corresponding with this pedophile olcott?

[Bonita Montero]

Post by DFS

Post by Bonita Montero

Post by olcott

Post by Bonita Montero

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   H0(DDD);
   return;
}
int main()
{
   H0(Infinite_Loop);
   H0(Infinite_Recursion);
   H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop, Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

Everything correct, no further questions allowed.

Thanks for your help on this. The Liars on comp.theory are
even lying about what you actually said.

Come up with some _practical_ issues which are related to C or C++.
You're asking things which are generic to a lot of languages.

Why are you corresponding with this pedophile olcott?

I know that an affinity to computer sciences is correlated to pedophilia
bi 97,2%.

[Chris M. Thomasson]

On 6/26/2024 10:42 AM, Bonita Montero wrote:
[...]

Post by Bonita Montero
I know that an affinity to computer sciences is correlated to pedophilia
bi 97,2%.

Huh?

[DFS]

Post by Bonita Montero

Post by DFS

Post by Bonita Montero

Post by olcott

Post by Bonita Montero

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   H0(DDD);
   return;
}
int main()
{
   H0(Infinite_Loop);
   H0(Infinite_Recursion);
   H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop,
Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

Everything correct, no further questions allowed.

Thanks for your help on this. The Liars on comp.theory are
even lying about what you actually said.

Come up with some _practical_ issues which are related to C or C++.
You're asking things which are generic to a lot of languages.

Why are you corresponding with this pedophile olcott?

I know that an affinity to computer sciences is correlated to pedophilia
bi 97,2%.

It's no joke. He was arrested for possession of significant amounts of
child porn.

[Chris M. Thomasson]

Post by Bonita Montero

Post by DFS

Post by Bonita Montero

Post by olcott

Post by Bonita Montero

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   H0(DDD);
   return;
}
int main()
{
   H0(Infinite_Loop);
   H0(Infinite_Recursion);
   H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop,
Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

Everything correct, no further questions allowed.

Thanks for your help on this. The Liars on comp.theory are
even lying about what you actually said.

Come up with some _practical_ issues which are related to C or C++.
You're asking things which are generic to a lot of languages.

Why are you corresponding with this pedophile olcott?

I know that an affinity to computer sciences is correlated to pedophilia
bi 97,2%.

It's no joke.  He was arrested for possession of significant amounts of
child porn.

Yikes! Bonita's assertion of 97.2% is wild to me. That means we are in
the minority? Na, Bonita's full of shit.

[olcott]

Post by olcott
To understand this analysis requires a sufficient knowledge of
the C programming language and what an x86 emulator does.
typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
  HERE: goto HERE;
}
void Infinite_Recursion()
{
  Infinite_Recursion();
}
void DDD()
{
  H0(DDD);
  return;
}
int main()
{
  H0(Infinite_Loop);
  H0(Infinite_Recursion);
  H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when H0
emulates the machine language of Infinite_Loop, Infinite_Recursion, and
DDD that it must abort these emulations so that itself can terminate
normally.
When this is construed as non-halting criteria then simulating
termination analyzer H0 is correct to reject these inputs as non-
halting.
*My POD24 diagnosis is reducing the time I have left to work on this*
Validation of POD24 as a robust early clinical end point of poor
survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

I wrote this whole paper all over again from scratch to make
it most easily understood by C/C++ software engineers like
myself. It also has some key technical details for computer
scientists.

*Termination Analyzer H is Not Fooled by Pathological Input P*

https://www.researchgate.net/publication/381636432_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_P