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

On 11/1/24 11:43 PM, olcott wrote:

On 11/1/2024 10:05 PM, Richard Damon wrote:

On 11/1/24 9:34 PM, olcott wrote:

On 11/1/2024 7:27 PM, Richard Damon wrote:

On 11/1/24 9:18 AM, olcott wrote:

On 11/1/2024 6:08 AM, Mikko wrote:

On 2024-10-31 12:53:04 +0000, olcott said:
>

On 10/31/2024 5:55 AM, Mikko wrote:

On 2024-10-31 01:20:40 +0000, Mike Terry said:
>

On 30/10/2024 23:35, Richard Damon wrote:

On 10/30/24 8:34 AM, olcott wrote:

On 10/30/2024 6:19 AM, Richard Damon wrote:

On 10/29/24 10:54 AM, olcott wrote:

On 10/29/2024 5:50 AM, Richard Damon wrote:

On 10/28/24 11:08 PM, olcott wrote:

On 10/28/2024 9:56 PM, Richard Damon wrote:

On 10/28/24 9:09 PM, olcott wrote:

On 10/28/2024 6:56 PM, Richard Damon wrote:

>
It is IMPOSSIBLE to emulate DDD per the x86 semantics without the code for HHH, so it needs to be part of the input.
>

>
*You seemed to be a totally Jackass here*
You are not that stupid
You are not that ignorant
and this is not your ADD
>
_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]
>
At machine address 0000217a HHH emulates itself emulating
DDD without knowing that it is emulating itself.
>

>
Then how did it convert the call HHH into an emulation of DDD again?
>

>
When HHH (unknowingly) emulates itself emulating DDD this
emulated HHH is going to freaking emulate DDD.
>
Did you think it was going to play poker?
>

>
Which is what it would do, get stuck and fail to be a decider. It might figure out that it is emulating an emulating decider, at which point it knows that the decider might choose to abort its conditional emulation to return, so it needs to emulate further.
>
Only by recognizing itself, does it have grounds to say that if I don't abort, it never will, and thus I am stuck, so I need to abort.
>

>
Counter-factual. This algorithm has no ability to KNOW ITS OWN CODE.
https://github.com/plolcott/x86utm/blob/master/Halt7.c // page 801
>
*That people fail to agree with this and also fail to*
*correctly point out any error seems to indicate dishonestly*
*or lack of technical competence*
>
DDD emulated by HHH according to the semantics of the x86
language cannot possibly reach its own "return" instruction
whether or not any HHH ever aborts its emulation of DDD.
>
I read, reread again and again to make sure that my understanding
is correct. You seems to glance at a few words before spouting off a canned rebuttal that does not even apply to my words.
>

>
>
No, it knows its own code because it rule for "No conditional branches" excludes that code.
>

>
It does not know its own code. It merely knows that the
machine address that it is looking at belongs to the
operating system. I simply don't have the fifty labor
years that AProVE: Non-Termination Witnesses for C Programs,
could spend on handling conditional branches.
>
The stupid aspect on your part is that even knowing
that its own code halts THIS HAS NOTHING TO DO WITH
DDD REACHING TS OWN RETURN INSTRUCTION.
>
>

>
No, HHH is NOT part of the "Operating System" so your claims are just a lie,

>
PO definitely has a deep-rooted problem with his thinking here.

>
What PO does does not look like any thingking but more like what one
could expect from ChatgPPT or a similar AI.

>
I don't have the 50 years it would take for me to replicate the work of
AProVE: Non-Termination Witnesses for C Programs.

>
Doesn't matter. Even if you had you could not use it to prove your false
claim that there be some defect in some proof.
>

>
There has never ever been the least trace of error
in this verified fact:

>
Sure there has been, but you have just proven that you are too stupid to understand it.
>

>
That you rejected the statement of fact prior to even seeing
it seems to prove that you are dishonest.

>
WHAT "statement of fact".
>

 It is still shown below. The fact that you rejected it
before I said it seems to prove that you are a liar.

You mean the statement that has been proven to be incorrect, as it is based on an equivocation that you have failed to defend, and thus have effectively admitted you were wrong.

 The honest way to respond to a statement claimed to be a
fact is AFTER the flow of text reaches that statement.

Which I did.
That statement I was refuting was the statement that you had presented a statement of fact, when you had not.
It was just a statement of a disproved hypothosis.

 Saying in advance that it must be incorrect because you
believe that I am stupid is acting like a moron not an
MIT graduate.

No, but it does seem that it proves that your thinking process is deficient and you can only think in the most primitive of methods.

 

It was a statement of ERROR based on equivocation.
>
Since you REFUSE to clearify your equivocation, by stating clearly which of the meanings you actually mean, it just shows that you are deliberately lying.
>

 void DDD()
{
   HHH(DDD);
   return;
}
 _DDD()
[000020a2] 55         push ebp      ; housekeeping
[000020a3] 8bec       mov ebp,esp   ; housekeeping
[000020a5] 68a2200000 push 000020a2 ; push DDD
[000020aa] e8f3f9ffff call 00001aa2 ; call H0
[000020af] 83c404     add esp,+04   ; housekeeping
[000020b2] 5d         pop ebp       ; housekeeping
[000020b3] c3         ret           ; never gets here
Size in bytes:(0018) [000020b3]
 DDD emulated by HHH according to the semantics of the x86
language cannot possibly reach its own "return" instruction
whether or not any HHH ever aborts its emulation of DDD.
 THERE IS ZERO EQUIVOCATION IN THE ABOVE SEEMING TO PROVE
THAT YOU HAVE NO IDEA WHAT THE TERM EQUIVOCATION EVEN MEANS.

The equivocation has been proved, and ignore, showing that you are just a stupid moron.
Do you mean by that sentence, the behavior of the program "DDD" as is the subject of the sentence, which is defined by the sematics of the x86 language as what happens when we run that program on an x86 processor, which will be to reach that return statement, since the only HHH you have defined (and thus the only one that can be presumed in) will abort its emulation (and thus violate your conditions) and the BEHAVIOR OF THE PROGRAM get there.
Or, are you trying to refer to the behavior of the emulation by HHH of DDD, which isn't defined unless HHH never aborts its emulation, as the semantics of the x86 processor only define full behavior, not partial as actual behavior.
Your failure to answer that, likely becuase either answer proves you are wrong, just shows that your equivocation is INTENTIONAL or is based on UTTER STUPIDITY (and thus your statement becomes a lie by the reckless disreguard for the truth to to mental insufficiency).

 

The fact that you just act too stupid to understand just proves again that you are lying, as you claim to be "smart" but then act just so dumb. Either you are lying about your smartness, or lying by deliberately avioding having to clarify your meaning.
>

>

>
DDD emulated by HHH according to the semantics of the x86
language cannot possibly reach its own "return" instruction
whether or not any HHH ever aborts its emulation of DDD.
>

>
>
>

>