Re: The actual truth is that ... industry standard stipulative definitions

On 10/15/24 10:25 PM, olcott wrote:

On 10/15/2024 9:11 PM, Richard Damon wrote:

On 10/15/24 8:33 AM, olcott wrote:

On 10/15/2024 3:54 AM, Mikko wrote:

On 2024-10-14 16:05:20 +0000, olcott said:
>

A stipulative definition is a type of definition in which
a new or currently existing term is given a new specific
meaning for the purposes of argument or discussion in a
given context. https://en.wikipedia.org/wiki/Stipulative_definition
>
*Disagreeing with a stipulative definition is incorrect*

>
The Wikipedia page does not say that. It only says that a stipulative
definition itself cannot be correct.

>
If X cannot be incorrect then disagreeing that X is correct
is incorrect.
>

It says nothing about disagreement.
In particular, one may diagree with the usefulness of a stipulative
definition.
>

>
It seems that my reviewers on this forum make being disagreeable
a top priority.
>

The article also says that the scope of a stipulative definition is
restricted to an argument or discussion in given context.

>
Once a stipulated definition is provided by its author it continues
to apply to every use of this term when properly qualified.
>
A *non_terminating_C_function* is C a function that cannot possibly
reach its own "return" instruction  (final state) thus never terminates.
A *non_terminating_x86_function* is the same idea applied to x86
functions having "ret" instructions. *non_terminating _behavior* refers
to the above definitions.
>
It is stipulated that *correct_x86_emulation* means that a finite
string of x86 instructions is emulated according to the semantics
of the x86 language beginning with the first bytes of this string.
>
A *correct_x86_emulation* of non-terminating inputs includes at
least N steps of *correct_x86_emulation*.
>
DDD *correctly_emulated_by* HHH refers to a *correct_x86_emulation*.
This also adds that HHH is emulating itself emulating DDD at least once.
>
void DDD()
{
   HHH(DDD);
   return;
}
>
When HHH is an x86 emulation based termination analyzer then
each DDD *correctly_emulated_by* any HHH that it calls never returns.

>
But, to do so, HHH can't abort is eulation, so doesn't answer, and thius isn't the HHH that you claim to correctly ans
>

>
Each of the directly executed HHH emulator/analyzers that returns
0 correctly reports the above *non_terminating _behavior* of its input.

>
But, since the input isn't "non-terminating" per the definiton of the field, you are just WRONG.
>

 WRONG FIELD YOU FREAKING JACKASS !!!
 

Really? That is the field of everything you have quoted for your argument!
Analysys of "leafs", of code that calls nothing that isn't part of the code under analysys, and Termination as the FINAL behavior of the code.
Try to show me something that is accepted in the field that defines non-terminating in the way you want to claim it.
That it can be appied to a non-leaf function (without includig the whole branch to make it a leaf-branch), or
That a partial emulation not reaching a final state is proof, by itself, that the function is non-terminating.
Go ahead, knock yourself out, and try to find it,
You are just proving that YOU aren't in the field, and are just totally ignorant of what you claim to be talking about.