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

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.

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.

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.
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.
Your "Logic" is just based on LIES, just like your master and lord who is SATAN.

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

 

Thus, it can't be the SOURCE of your assertions.
>
You don't even understand what you source code says, as has been pointed out before, the semantics of x86 code REQUIRE that a full execution or emulation be done,

 That is a lie. The semantics of the x86 language requires that
a partial or complete emulator never diverges from the meaning
that the code specifies.

But ALL partial emulation diverge from the final meaning because they don't reach it.
The fact that a partial emulation doesn't reach the end means nothing, only the COMPLETE emulation of the EXACT PROGRAM that is being talked about, which is DDD calling the HHH that does what you say is correct, which is to abort its emulation and return.
It isn't about what HHH does to its input that defines its behavior, it is the actual behavior of the program described to it, based on the EXACT code within it (which includes ALL the code it calls, despite your lies about it).

 When DDD emulated by HHH reaches the point where HHH would emulate
itself emulating DDD again it can correctly stop. What it cannot
do is ignore the call to itself and jmp to the "ret" instruction.
 

Nope. Made up fake rule that is just a LIE.
NO source of that rule except your own brainwashed mind that is filled with error.
Your "claim" just proves that you are nothing but a liar.
What we can not ignore is that the ACTUAL definition of the behavior of input doesn't depend on what the decider does with the input, but what the actual behavior of the program described does when run.
Your inability to understand that DEFINITION just shows your utter STUPIDITY.
So, in summary, all you are doing is PROVING to the world that you are nothing but a pathetic pathlogical lying idiot who doesn't know what he is talking about or what truth actually is, but just want to spout off his lies to try to wreck other people into beleiving his lies.
Sorry, but you are just revealing that you are nothing but a pawn for the father of lies, trying to spread the idea that lies are ok if you can "justify" them well enough.
THAT will be your eternal legacy.