Re: The philosophy of computation reformulates existing ideas on a new basis ---SUCCINCT

On 11/16/24 10:17 AM, olcott wrote:

On 11/16/2024 8:26 AM, Richard Damon wrote:

On 11/16/24 9:09 AM, olcott wrote:

On 11/16/2024 6:36 AM, Richard Damon wrote:

On 11/15/24 11:17 PM, olcott wrote:

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

On 11/15/24 10:57 PM, olcott wrote:

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

On 11/15/24 10:32 PM, olcott wrote:

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

On 11/15/24 7:34 PM, olcott wrote:

On 11/14/2024 8:49 PM, Richard Damon wrote:

On 11/14/24 9:38 PM, olcott wrote:

On 11/14/2024 2:33 PM, Richard Damon wrote:

On 11/14/24 3:28 PM, olcott wrote:

On 11/14/2024 2:22 PM, Alan Mackenzie wrote:

joes <noreply@example.org> wrote:
>

What are weasel words?

>
Words whose precise meaning is difficult/impossible to pin down, and
deliberately so.  Politicians use these all the time.
>

>
_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]
>
DDD emulated by any HHH cannot possibly reach its "ret"
instruction final halt state.
>
>
>

>
But the emulation by HHH is NOT the DEFINITION of the behavior that HHH is suppoded to be reporting on.
>

>
Right and likewise ZFC is "supposed to include" sets that
are members of themselves. Thus according to your reasoning
ZFC is wrong because is directly disobeys the dogma of
naive set theory.
>

>
Where did I say that?
>
You seem to be halucinationg.
>

That behavior that HHH is supposed to be reporting on is the behavior of the actual direct exectution of the program described by the input,

>
IN OTHER WORDS YOU ARE SAYING THAT HHH SHOULD STUPIDLY IGNORE
THE FACT THAT DDD DOES SPECIFY THAT HHH MUST EMULATE ITSELF
EMULATING DDD

>
DDD doesn't "say" anything, it is a program that defines how it will run.
>

>
The semantics of the x86 language specifies that HHH must
emulate itself emulating DDD.
>
>

>
There is no "emulate" instruction.
>
The semantics of the x86 language specifies that HHH must do as it is programmed, and that the correct emulation of it will do EXACTLY the same thing.
>

>
When HHH <is> an x86 emulator
(are you too stupid to remember this?) Then
The semantics of the x86 language specifies that HHH must
emulate itself emulating DDD.
>

>
But it *ISN'T* one if it stops its emulation before it reaches the final end.
>

Sure it is you are just a liar.
>

>
You got a source to back up your claim,

>
Full source-code backs up my claim you schmuck.
https://github.com/plolcott/x86utm
>

>
Which just prove that you are nothing but a LIAR.
>
You agree, that "Truth" comes from steps from those basic truths that build the system, the Axioms of the system.
>
Your "Source Code", is NOT an axiom of the system.
>

>
_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]
>

>
WHich isn't a complete program, so a LIE to call it one.
>

 I never called it a complete program and you swear your
own allegiance to the father of lies by saying that I did.

But Halt Deciders / Termination Analyzers only take COMPLETE programs, so I guess you lie is to call your HHH either of them.
Also, in programing system, "Semantics" only apply to COMPLETE PROGRAMS, so you are just misusing the term, due to your ignorance.

 

The axioms of the system are the x86 language nitwit.

>
Which means that the above is an incorrect statememt.
>
By the "axions" you claim, the PROGRAM DDD, that comes from the Halt7.c file, is HALTING as it calls the HHH that does some partial emulation and returns to DDD and thus DDD returns.
>

 void DDD()
{
   HHH(DDD);
   return;
}
 The C function DDD partially or fully emulated by any
HHH never reaches its own "return" instruction final
halt state.

But "emulation" is a semantic operation, and thus must have an input with semantic meaning, and thus it must be a COMPLETE program.
I guess your whole premise is just a LIE.

 It may prove to be a very bad idea to swear your own
allegiance to Satan by even implying otherwise.

I am not doing that, but you are.

 

HHH applies to axioms to its input proving that DDD
emulated by HHH cannot possibly ever reach its own
"ret" instruction final halt state no matter what
any partial or compete x86 emulator HHH does.

>
Nope, becuase there are no axioms like that to even APPLY.
>

 _DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

NOT A SEMANTICALLY VALID INPUT.

 Sure there are the x86 language provides all of the axioms
that requires HHH to emulate the first four instructions of
DDD then if any more instructions are to be emulated HHH
must at least begin emulating itself emulating DDD.

Right, and since not part of the input, not a valid operation.

 

As you have been told, your problem is that you seem to like just making up things you will ASSUME (incorrectly) to be true in the system without figuring out if there is an actual proof of the idea.
>

 It is pretty simple and everyone that sufficiently knows
the x86 language (and is not a liar) will agree with the
fact that DDD does specify that HHH must emulate itself
emulating DDD with DDD never reaching its own "ret"
instruction final halt state by any finite or infinite
emulation.

But the "meaning" only applies if HHH *IS* just a semantic emulator, which if it aborts its emulation, it is not.
What DDD actually does is call the DECIDER/ANALYZER HHH, which must be a definite entity with definite code (or your discussion is without meaning) and if that entity returns, it returns and DDD is seen to be halting.

 

Your "Logic" is just based on LIES, just like your master and lord who is SATAN.
>

 What I say is a semantic tautology thus impossibly false.
It is necessarily true that anyone that disagrees with a
semantic tautology is necessarily incorrect.

Nope, what yoy say is a semantic CONTRADICTION, as you claim HHH to be two semantically diffferent things at once.

 

>
That most all that you have is lies and call me a liar
on this basis might get you condemned to actual Hell.
I hope not that is why I ask you to repent.

>
Nope, I make statements based on the definitions in the system, that is TRUTH.
>

 You cannot possibly correctly say that DDD emulated
by any HHH can possibly reach its "return" instruction
final halt state.

Right, because that isn't a semantic property of DDD, the semantic property of DDD is the COMPLETE emulation of it.
The emulation by HHH of DDD can never show "final" behavior of that input and report on it, thus your statement is just inconherent gibberisn.

 In a court of law you must tell the truth THE WHOLE TRUTH
and nothing but the truth.  That you fail to tell the whole
truth about the behavior of DDD emulated by HHH would break
this oath.

Yep, and you will fall afoul of the need to tell the complete truth, as that seems impossible for you.

 

YOU makeup statements with NO basis in the system, that is LIES.
>
That you can't tell the difference, just shows you are a stupid ignorant pathetic pathological liar.
>

 The only liar here is you AND YOU KNOW IT!
I don't see how you can twist your understanding
of scripture so that you think you can get away
with deceptive trollish head games.
 

Nope, you are the liar, because everything you say is based on incorrect meaning of words.
Sorry, you are just proving your utter stupidity.