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

On 6/26/2024 2:43 PM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

 Emulating termination analyzer H is inherently an emulator.
It really should not be that hard to pay attention to that
unless one only cares about rebuttal and thus does not care
about truth.

 Your posts are, in the main, tedious in the extreme.  When you repeat the
same thing 30 times over, you can't expect anybody to read each of the
repetitions as though it were fresh and new.
 

I must keep repeating them until they bother to pay attention
to the exact words that I am exactly saying because every fake
rebuttal is the strawman deception.

All the people you are debating with care about the truth.  That's why
they're in this group debating with you.
 

It seems to me that they are only here to play the troll.

Given how most people here are mathematically trained, perhaps if you
started a typical post with "Suppose E is a code emulator ...", and other
prerequisites there would be less confusion still.

 

OK that sounds like a reasonable way to avoid information overload.

 

_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]

 

It is clear that the semantics of the x86 language specifies
that DDD correctly emulated by H0 at machine address 0000217a
will continue to repeat the first four instructions of DDD
until out-of-memory error.

 

It is not at all clear, given how murky the code at 15d2 is, and what you
mean by "correctly emulated".

 

Of course I must mean jumping up and down yelling and screaming
and not be referring to anything like what an x86 emulator does.

 Anything "like" what an x86 emulator does is insufficiently precise.

An x86 emulator is already 100% perfectly precise if the
trolls that review my work don't think so then that proves
that they are trolls.

There are plenty of different functions which could appear at 15d2, some
of them will return, some won't.

Not if you know exactly what an x86 emulator is.

 Some of them could be called emulators,
most couldn't. 

Since I specify emulator changing the subject for rebuttal
is a damned lie.

And the "semantics of x86" don't specify anthing beyond
the meaning of x86 programs in general.
 

*That is a stupid thing to say*
The semantics of the x86 language provides 100% of all
of the details of the behavior of these two functions.
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}

When we add that the outermost directly executed H0 can abort
its simulation as soon as the behavior of its input matches
the the infinite recursion behavior pattern it remains true
that the call from the emulated DDD to the emulated H0(DDD)
cannot possibly return.

 

It might do.  Convincing argument that this is the case (i.e. a proof)
has not been forthcoming.

 

We cannot prove differential calculus to anyone not knowing
how to count to ten.

 Everybody else in this group knows differential calculus, and certainly
how to count up to ten.  They also know what a proof looks like, and how
necessary it is.
 

Yet they are either mostly clueless about programming or
dishonestly pretend to be mostly clueless about programming.

That DDD correctly emulated by H0 must continue to repeat
its first four instructions is self-evident true to anyone
knowing what an x86 emulator is and having sufficient basic
knowledge of the x86 programming language.

 It is not self-evident.
 

To anyone that is mostly clueless about the x86 language.

I was very surprised to find out that one person having a PhD
in computer science said that they had hardly any experience
with programming.

 Why?  Many architects won't have much experience of brick laying, either.
 

The CS courses that fulfilled the requirements for a BSCS degree
at my university had quite a bit of programming. One of the projects
for the data structures course was to write a LISP interpreter that
could do car, cdr and cons.
https://www.gnu.org/software/emacs/manual/html_node/eintr/car-cdr-_0026-cons.html

 I'm familiar with that page, being a member of the Emacs maintenance
team.
 

These expressions could be arbitrarily complex. I was one of
two students out of fifty that got the project in on time. The
other one was my co-worker at the US Army Corps of engineers.
He and I got a 100% grade.

 

*That people consistently lie about this is quite annoying*
*yet not nearly so much when their lie is easily exposed*

 

I haven't seen other people here lying.

 

When they say that I am wrong knowing that they do not understand
what I am saying this would be a lie.

 They say you are wrong because you are wrong. 

_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.
They say that I am wrong about that lying in one of two
different ways (1) They don't have a clue what the code
means (2) They knowing lie about what the behavior is.

They do understand what
you are saying, mostly, and understand that it is wrong, again mostly.
 

-- Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

 

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer