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

On 6/25/24 9:29 AM, olcott wrote:

On 6/25/2024 4:42 AM, Mikko wrote:

On 2024-06-24 13:52:23 +0000, olcott said:
>

On 6/24/2024 2:31 AM, Mikko wrote:

On 2024-06-23 13:25:36 +0000, olcott said:
>

On 6/23/2024 4:50 AM, Mikko wrote:

On 2024-06-22 19:03:13 +0000, olcott said:
>

On 6/22/2024 1:55 PM, Richard Damon wrote:

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

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

On 6/22/24 1:29 PM, olcott wrote:

On 6/22/2024 12:13 PM, Richard Damon wrote:

On 6/22/24 12:18 PM, olcott wrote:

>
void DDD()
{
   HHH0(DDD);
}
>
The input to HHH0(DDD) includes itself.
The input to HHH1(DDD) DOES NOT include itself.
>
It is stipulated that correct emulation is defined by the
semantics of the x86 programming language and nothing else.

>
And thus, your emulation traces show that your "Simulating Halt Deciders" do not do a "Correct Simulation"

>
Apparently your ADD preventing you from paying close attention
to ALL of my words.
>
*Function names adapted to correspond to my updated paper*
>
void DDD()
{
   H0(DDD);
}
>
*When we stipulate that the only measure of a correct*
*emulation is the semantics of the x86 programming language*
>
*When we stipulate that the only measure of a correct*
*emulation is the semantics of the x86 programming language*
>
*When we stipulate that the only measure of a correct*
*emulation is the semantics of the x86 programming language*
>
*When we stipulate that the only measure of a correct*
*emulation is the semantics of the x86 programming language*
>
*When we stipulate that the only measure of a correct*
*emulation is the semantics of the x86 programming language*
>
then we see that when DDD is correctly emulated by H0 that
its call to H0(DDD) cannot possibly return.

>
Since your H0 has never demonstrated that is actually DOES the correct simulation per your stipulation,

>
Liar
>

>
Then where is it?
>

When we stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language then we see that
when DDD is correctly emulated by H0 that its call to H0(DDD)
cannot possibly return.

>
Semantics of the x86 programming language does not specifiy emulation
or correctness of emulation.
>

>
WRONG!

>
Unless you point where in Intel's documentation emulation or correctness
of emulation is specified you have no basis to say "WRONG".
>

>
Not at all. That is the same as saying that 2 + 3 = 5
is wrong until proven by PA.

>
If you want to claim that 2 + 3 = 5 you must show some basis for the claim.
One obvious source of such basis is Peano Arithmetic. Likewise, if you say
"WRONG" you must show some basis for the claim. When the statement claimed
"WRONG" is about x86 programming language, an sobvious source for such basis
is Intel's documentation.
>

Otherwise we could say that for the decimal integers
2 + 3 = 17 and the semantics of arithmetic does not disagree.

>
No, you can only say that you don't know any disageement between them.
Without a proof threse is a possibility of an unknown disagreement.
>

I can believe you couls but I would not.
>

The semantics of arithmetic agrees that for the decimal
integers 2 + 3 = 5.

>
Intel's processors seem to agree, too. But I havn't checked every one.

>
_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 H0 cannot possibly return.

>
What is shown above does not prove that the call to 15d3 does not
return, nor whether there is H0 or HHH0 or something else at that
location.
>

 It is stipulated that DDD is correctly emulated by the
H0 at machine address 000015d2.

Not something that can be stipulated. You can not stipulate that something IS correct.
You can state that as a condition of the argument (you then need to show that the condition can/is meet by your H0)

 It is stipulated the the correct simulation is ruled by
the semantics of the x86 programming language.

THAT is a valid stipulation,

 *This conclusively proves*
The call from DDD to H0(DDD) when DDD is correctly emulated
by H0 *CANNOT POSSIBLY RETURN*

Nope, not unless you stipulate that you H0 is an actual COMPLETE and correct simulation that never abort.
Otherwise, we know that the ACTUAL behavior of DDD after the aborted simulation will be to return, and if you try to limit "behavior" to what the simulation showed, then implying behavior after the abort is off-limits, and all you can say is that it did not return during the simulation (if you can in fact prove that much).
Note, since you keep on forgetting to put all your requirements on H0, then I can say your statement is just false by the example of the unpure H0 that can see that this is a second call, and just returns.

 I am unwilling to talk about anything else with you until
you agree to this.
 

And that makes arguing with you easier, as we can continue to refine the arguments of why your claim doesn't do what you want.