Re: Why do people here insist on denying these verified facts?

On 6/23/24 9:36 AM, olcott wrote:

On 6/23/2024 6:28 AM, Richard Damon wrote:

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

On 6/22/2024 7:19 PM, Richard Damon wrote:

On 6/22/24 7:59 PM, olcott wrote:

On 6/22/2024 3:08 PM, Richard Damon wrote:

On 6/22/24 3:49 PM, olcott wrote:

On 6/22/2024 2:43 PM, Richard Damon wrote:

On 6/22/24 3:35 PM, olcott wrote:

>
The correct measure of the behavior of the actual input is DDD
correctly simulated by H0 according to the definition of the
semantics of the x86 programming language.

>
FROM WHERE?
>
That is just YOUR LIE!!!!!
>

>
Now you are trying to get away with disbelieving in the
semantics of the x86 language and you can't even spell "from"
>
That you have the audacity to call me a liar over this
might condemn you to Hell (I sincerely hope not).
>

>
I call it a lie, because it IS one.
>
You claim a definition of the "Correct Answer" that has NO source but your own ignorant mind. That makes it a LIE, as there is a DIFFERENT definition that you refuse to use.
>
You claim you can show "behavior" by the definition of the x86 assembly language that is not there.
>

>
Liar
>

>
You losing it Peter.
>
you need to show something, or you are just admitting you have lost.
>

>
Not at all. I have written it up much better now.
Because I had to write it up clearly enough that
people trying to get away with lying about it look
like ridiculous fools it finally has a change to
be accepted.

>
>
>

>

>
You HAVE lost, since you have nothing to back your lies, and that has been reveiled, but not even trying is just giving up.
>
The ACTUAL CORRECT emulation of the proper input (which includes the code of the decide which is needed) shows that DDD will Halt since H0 will decide on it and return, and thus DDD will halt.
>

>
That is not the question.
The question is can the call to H0(DDD) made by DDD
correctly simulated by H0 return?

>
No, as long as you are claiming that H0 is a Halt Decider, that isn't the question, but the question is "Does the Machine represented by the input Halt when run?"
>
And, if you are going to admit that H0 isn't a Halt Decider, then our question to you is Why do we care about H0?
>
You need to give us a reason to spend the effort to verify what you claim.
>

>

H0's emulation might not get there, but that isn't the question, and H1's emulation, which will be identical to H0 up to the point H0 stops (if H0 did a correct emulation per your rules) so there is no ground to say the behavior was different.
>
H0 is just WRONG about halting.

>
When you try and get away with conflating an aborted simulation
with terminating normally gullible fools might think you are right.

>
So, are you going to admit that H0 isn't, and never will be, a Halt Decider>
>

>
There are several people here that are not gullible fools.
>

>
But you are not one of them.
>
>

 _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]
 According to the semantics of the x86 programming language
when DDD correctly emulated by H0 calls H0(DDD) this call
cannot possibly return.
 Likewise according to the semantics of arithmetic for
decimal integers: 2 + 3 = 5.
 Anyone disagreeing with these two statements is WRONG.
 

Now, if you REALLY mean just can H0 simulate this input to a final state, the answer is WHO CARES.
But I will put out a few comments on errors in your presentation\.
First, if you ONLY have the bytes presented, then the answer becomes trivial, as H0 HAS to stop emulating when it gets to the call instruction, as there is no data at address 000015d2 defined to simulate.
This means you need to fix your problem statement to include the instructions of HHH0, and everything that it calls as part of the "input", or your question isn't the one you mean to be asking.
Of course, this means that each HHH0 that you try, is processing a DIFFERENT input, so you can't argue from one about the behavior of a different one.
Second, you forgot to specify what HHH0 has as requirements. Once you include its code, so can simulate it, the "non-pure" function tricks allow it to correctly simulate to the return instruction.
Reminder, you complain when we point out assumptions made on previous statements that you didn't want to carry forward, so you can't also complain about us forgetting about requirements that you didn't bring forward.
If you want to pull in the past, we can just point out that we KNOW you are talking about a Halt Decider, and that your question is the wrong question for a Halt decider.
So, your statement is wrong for two logical reasons as described above, so your statement that anyone who disagrees is wrong is just wrong.
You don't know how to properly state a problem.
The last point to make, is that this is NOT a "proof" but just an argument claiming something should be obviously true.
That may be a "proof" in the wild west of Philosophy, but it isn't in the realm of Formal Logic, which is what the field you are talking about is.
So, you are making a statement, that when fixed to correct the deficits in it, becomes a statement that might be plausably true, but not proven.
A proof can likely be made, but it seems that is beyond your ability since you didn't even try, Of course, without the second fix, the statement is just false, and without the first fix, the statment is meaningless, as of course you can't simulate to a return from a call that you are unable to simulate past.