Re: HHH maps its input to the behavior specified by it --- never reaches its halt state

On 2024-08-08 18:45:00 +0000, olcott said:

On 8/8/2024 2:59 AM, Mikko wrote:

On 2024-08-07 13:43:09 +0000, olcott said:
 

On 8/7/2024 2:24 AM, Mikko wrote:

On 2024-08-05 15:01:36 +0000, olcott said:
 

On 8/5/2024 2:49 AM, Mikko wrote:

On 2024-08-04 12:37:49 +0000, olcott said:
 

On 8/4/2024 2:18 AM, Mikko wrote:

On 2024-08-03 13:58:07 +0000, olcott said:
 

On 8/3/2024 3:19 AM, Mikko wrote:

On 2024-08-02 20:57:26 +0000, olcott said:
 

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?
 void DDD()
{
   HHH(DDD);
   return;
}

 Everyone here understands that that depends on whther HHH returns.

 Fred's understanding is worse than that.

 You don't know whether that is true.
 

Some have deeper understanding than that.
 *Ben has the best understanding of all*

 In particular better than you.
 

 *Ben has a deeper agreement with me than anyone else*

 Doesn't matter. Points of disagreement, both deep and shallow, are
more important than points of agreement.

 Not at all.
Most of the reviewers simply don't have a clue that they
don't have a clue. The error is entirely on their side.

 Your reviewers don't need a clue. You need. But you don't have.
And you don't know you don't have so you don't seek. As you
don't seek you will never get.
 

 void DDD()
{
   HHH(DDD);
   return;
}
 Any expert in the C language that knows what x86 emulators
are knows that DDD correctly emulated by HHH specifies what
is essentially equivalent to infinite recursion.

 No, that requires knowing what does or at least whther it
ever returns. Knowledge of what x86 emulators are does not
help.
 

 x86 machine code is a 100% exact and concrete specification.

But has too many unimportant details.

C is a little more vague and hides the details.

With C it is possible to write unambigous programs. It is not
as easy as with many other languages because C is usually
used for purposes where implementation dependnet behaviour
need not be avoided.

typedef void (*ptr)();
int HHH(ptr P); // simulating termination analyzer
 void DDD()
{
   HHH(DDD);
   return;
}
 Each HHH of every HHH that can possibly exist definitely
emulates zero to infinity instructions of DDD correctly.
Every expert in the C language sees that this emulated DDD
cannot possibly reaches its own "return" instruction halt state.
 Every rebuttal that anyone can possibly make is necessarily
erroneous because the above paragraph is a tautology.
 HHH computes the mapping from its finite string of x86 machine
code to the actual behavior that this finite string specifies
which includes recursive emulation.

It is not useful to repeat what has already been said. You should
always improve, at least the presentation. If you cant find any
other improvemnt you should at least correct the worst typo.
--
Mikko