Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure

On 6/27/24 9:21 AM, olcott wrote:

On 6/27/2024 6:34 AM, Richard Damon wrote:

On 6/26/24 11:37 PM, olcott wrote:

On 6/26/2024 10:16 PM, Richard Damon wrote:

On 6/26/24 10:46 PM, olcott wrote:

On 6/26/2024 9:38 PM, Richard Damon wrote:

On 6/26/24 10:10 PM, olcott wrote:

On 6/26/2024 8:21 PM, Richard Damon wrote:

On 6/26/24 9:12 PM, olcott wrote:

On 6/26/2024 7:40 PM, Richard Damon wrote:

On 6/26/24 8:24 PM, olcott wrote:

On 6/26/2024 6:52 PM, Richard Damon wrote:
>
Mike understands how your use of static variables is cheating.
Others here will be baffled and confused.
>

>
But the rules are the rules, and you can't create rules you didn't state.
>

>
If you really have such brain damage that you cannot remember
that we already discussed this and closed it I will start
praying for you.

>
And if I am allowed, or even required to remember that, then I can remember that your Hs are all designed to be Halt Deciders, and thus the only correct behavior for their input is that of the direct execution of the program the input represents.
>

>
NONE-THE-LESS I WILL NOT TOLERATE YOU LEAPING TO THE CONCLUSION
THAT I AM INCORRECT WITHOUT GOING THROUGH EVER SINGLE STEP.
*When you do this I will point out your specific deceit*

>
But if you don't include the restriction, it isn't there, and the fact we are so many steps ahead of you isn't grounds to say we don't know what we know.
>

>

>
YOU CAN'T FREAKING USE ANY STATIC LOCAL VARIABLES TO
CHANGE THE BEHAVIOR AND YOU KNOW WHY YOU CAN'T USE
THEM SO FREAKING QUIT IT !!!
>
_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call H0(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]
>
The call from DDD to H0(DDD) when DDD is correctly emulated
by x86 emulator H0 cannot possibly return.
>
>

>
But it does, it just isn't emulated by H0.
>

>
THAT IS THE FREAKING DAMNED LIAR STRAW-MAN DECEPTION.

>
The "Behavior" of the input is DEFINED by the semantics of the x86 instruction set.
>
NO instruction, other than Halt, stops the processor from continuing, thus the behavior of the input doesn't stop just because the emulator stoped processing it.
>

>
When I say that there are some people that are so poor
that they are starving to death and we must halt them
>
you cannot (morally) say there is no need to help them
because rich people are not starving to death.

>
RED HERRING.
>

>
Christ taught in parables I teach in isomorphisms.
>

>
But broken ones, that are just RED HERRING LIES.
>
And, I know Christ, and you are NOT Christ, and it is almost blasphemous for you to make that comparasion, especially since you have claimed to be God in the past.
>
THAT WILL send you to Gehenna.

>
I am not the liar here. I think that we have gone
way beyond reasonable doubt that you have told lies.

>
Really, so what statement have I said that isn't actually true.
>
Not just that you disagree with it, since you have been proven to be a liar, but that you can actualy preove to be untrtue.
>
Your ignorance does not make my statements lies.
>

>
Maybe you are one of those "Christians" that believes
once saved always saved even if you commit genocide
for fun an profit.
>

>
Nope. You don't know me well, so you are just making your typical wild guesses with no basis.
That is what gets you in trouble every time.
>

>
As ALWAYS I hypothesize possibilities.

>
No, you hypothesize thing that might be impossibe, which are just lies.
>

 This is merely your ignorance of how modal logic works.
Modal Logic operators defined
"◇" for "Possibly" and "□" for "Necessarily"
◇P ↔ ¬□¬P
□P ↔¬◇¬P

But you still can not say that something is "Possible" if it actually can not be.
or
□¬P ↔ ¬◇P

 

Since you neither confirmed nor denied it remains open.

>
It is unclear what "it" refers to, as usual for you.
>

 You neither affirmed nor denied whether you are
a once saved always saved Christian or not.
https://www.biblestudytools.com/bible-study/topical-studies/are-christians-really-once-saved-always-saved.html

Right, because that isn't something I care to share about with you, since it is clear that you are not a true believer, and thus couldn't understand the discussion.

 

>
By normal grammer, it woudl be either that you hypothesize possibiliteis, and I have shown some of your claimed immpossiblities are just impossible, or the previous comment was that I might think that "committing genocide for fun and profit" is something a saved person might do.
>

>
You know that you are doing the best that you can to
disable an honest dialogue.
>
I have backed you into a corner on some of your lies.
>

>
What lies?
>
That seems to be one of your biggest lies, you claim others are lying to try to disquise your own lies.
>

 The most important one is that the correct simulation
of DDD by Ho must ALWAYS have the same behavior as the
directly executed DDD().

Right, because that is the DEFINITION of "correct simulation"
"Correct" is an absolute word, you are either correct or you are not.
A Partial simulation is not a "Correct Simulation" in that it doesn't completely show the behavior of the thing simulated, but only a partial set of that behavior.
Your attempt to define an admittedly partial simulation as being fully correct is just an error. IT is only a correct PARTIAL simulation, revealing only PART of the behavior of the input.

 _DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call H0(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]
 The call from DDD to H0(DDD) when DDD is correctly emulated
by x86 emulator H0 cannot possibly return.

And H0 only completely correctly emulates its input if it never aborts, but that has been clearly NOT the H0 you are thinking of.
Partial simulations do not (by themselves) reveal details about behavior past there termination, so you can not say "Never" since that word implies for all time. You can only says that H0 will never simulate the return.
Note, the Partial Simulation of DDD by H0 is NOT a "property" of DDD, but of the pair of DDD and H0, so isn't valid to talk about it as a decision problem based on just the input.

 

You can't show one thing that I have said that is FACTUALY INCORRCT (only that you disagre with them).
>

 It is a matter of you disagreeing with the semantics of
the x86 language. This is analogous to disagreeing with
arithmetic.

Nope, the x86 languge includes the semantics that the behavior of the program continues until the program itself terminates, and not just until it is terminated by some outside force.

 You are already hedging your original claim because I have
backed you into a corner.

Nope.

 

I have shown statements of your that ARE DEFINITIONALLY INCORRECT (even if you want to use a different definition, which just isn't allowed, and thus becomes a lie).