Path: ...!news.misty.com!weretis.net!feeder9.news.weretis.net!i2pn.org!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: The actual truth is that ... industry standard stipulative
 definitions
Date: Tue, 15 Oct 2024 22:12:02 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <f154c55c56747517580dd06249a39a48a4eeee1d@i2pn2.org>
References: <ve39pb$24k00$1@dont-email.me> <veb557$3lbkf$2@dont-email.me>
 <2e6d8fc76e4e70decca1df44f49b338e61cc557e@i2pn2.org>
 <vebchp$3m87o$1@dont-email.me>
 <1071eb58637e27c9b2b99052ddb14701a147d23a@i2pn2.org>
 <vebeu2$3mp5v$1@dont-email.me>
 <58fef4e221da8d8bc3c274b9ee4d6b7b5dd82990@i2pn2.org>
 <vebmta$3nqde$1@dont-email.me>
 <99541b6e95dc30204bf49057f8f4c4496fbcc3db@i2pn2.org>
 <vedb3s$3g3a$1@dont-email.me> <vedibm$4891$2@dont-email.me>
 <72315c1456c399b2121b3fffe90b933be73e39b6@i2pn2.org>
 <vee6s1$7l0f$1@dont-email.me>
 <1180775691cf24be4a082676bc531877147202e3@i2pn2.org>
 <veec23$8jnq$1@dont-email.me>
 <c81fcbf97a35bd428495b0e70f3b54e545e8ae59@i2pn2.org>
 <vef37r$bknp$2@dont-email.me>
 <7e79306e9771378b032e6832548eeef7429888c4@i2pn2.org>
 <veikaf$14fb3$1@dont-email.me> <veipmb$15764$2@dont-email.me>
 <c56fcfcf793d65bebd7d17db4fccafd1b8dea072@i2pn2.org>
 <vejfg0$1879f$3@dont-email.me> <velajq$1l69v$1@dont-email.me>
 <velnfc$1n3gb$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 16 Oct 2024 02:12:02 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2226561"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <velnfc$1n3gb$1@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
Bytes: 8450
Lines: 178

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.

But since it CAN be incorrect, that doesn't hold.

Stiplutive definition can not redefine terms of a Formal Logic and have 
the argument stay in that Formal Logic system.  PERIOD, by the 
definition of a Formal Logic System.

You can only make your claim if you acknoldge that you are not staying 
in the field of Computation Theory, and thus can't even rely on any 
facts IN computation theory as they may not hold with your changed 
definition.

Thus, a premise that includes a stiplitive definition that is in 
contradiction to the Formal Logic System the statement is claimed to be 
in is just INVALID, as it is not allowed.

It isn't that the statement is FALSE, but the statement is 
DEFINITIONALLY excluded from the system.

> 
>> 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.

Only to your stupid claims.

> 
>> 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.

But only if the stipulation is ALLOWED TO OCCUR in the system.

All you are doing is proving that you don't understand the rules of 
Formal Logic.


> 
> 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.

Right. and DDD does that. Since the BEHAVIOR of a function is DEFINED to 
be what it does when it is directly executed.

> 
> 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.

Which isn't accurate, because to be compatible with your above 
definition of behavior, to be complete, it must not ABORT.

While some fields allow for just partial emulation, those fields also 
limit what those emulation indicate, and they do not claim to indicate 
non-termination.

Sorry, you are just using your mis-learned by rote non-education come out.

> 
> A *correct_x86_emulation* of non-terminating inputs includes at
> least N steps of *correct_x86_emulation*.

No, in includes an UNBOUNDED number of steps of correct x86 emulations.

Only N steps would be "Not yet terminating"

This error is a result of your previous incorrect definition.

> 
> DDD *correctly_emulated_by* HHH refers to a *correct_x86_emulation*.
> This also adds that HHH is emulating itself emulating DDD at least once.

Nope, because you used a wrong definition to try to pull an equivocation.

Yes, some field say "correct emulation" determine behavior

Some fields allow a "corect emulation" to be a partial emulation.

No field allows both, so you are just equivocating on the meaning of 
"correct emulation"

> 
> 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 no HHH that returns an answer did a correct emulation by the 
definition that shows behavior, and thus your statement is just invalid.

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

Nope, proven wrong/

> 
> < It also
>> says that a conterargument may use a different stipulative definition
>> for the same term.
>>
> 
> When evaluating the the deductive validity of my reasoning
> changing the premises is the strawman deception.
> https://iep.utm.edu/val-snd/

So, since your arguement is based on trying to change the meaning of the 
definition of the terms you are using, you are just admitting that you 
arguement is just a strawman.

> 
> When evaluating the external truth of my stipulated definition
> premises and thus the soundness of my reasoning

But your stipulated definition was VOID on its utterance, as it violated 
the definitions of the formal system. That means the following 
statements can not use it either, or they are voided from the logic system.

> 
> one cannot change the subject away from the termination analysis
> of C functions to the halt deciders of the theory of computation
> this too is the strawman deception.

But the Theory of Termination Analysis of C functions defines that the C 
functions it works on include ALL the behavior of any function that 
function calls.

Thus, to ignore that requirement makes your arguement a strawman.

========== REMAINDER OF ARTICLE TRUNCATED ==========