Path: ...!news.mixmin.net!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: olcott <polcott333@gmail.com>
Newsgroups: comp.theory,sci.logic
Subject: Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure
Date: Wed, 26 Jun 2024 15:10:36 -0500
Organization: A noiseless patient Spider
Lines: 175
Message-ID: <v5hsjs$29tg1$1@dont-email.me>
References: <v4vrfg$2793f$1@dont-email.me> <v59797$brmn$1@dont-email.me>
 <v5b7nv$qvrb$1@dont-email.me> <v5btf3$v0vb$4@dont-email.me>
 <v5chru$10816$1@i2pn2.org> <v5cn01$149dc$1@dont-email.me>
 <v5ebvr$1hs89$1@dont-email.me> <v5efod$1ikpr$1@dont-email.me>
 <v5ejau$1iq57$1@dont-email.me> <v5eup8$1lar1$2@dont-email.me>
 <v5gidq$221q3$1@dont-email.me> <v5h34g$24jbd$4@dont-email.me>
 <v5h5oq$1g3$1@news.muc.de> <v5h765$25q9l$1@dont-email.me>
 <v5he3t$1c0t$1@news.muc.de> <v5hfb8$26j79$1@dont-email.me>
 <v5hr0e$1c0t$2@news.muc.de>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Wed, 26 Jun 2024 22:10:37 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="28c20839daaf0f4c95806d952d7f722b";
	logging-data="2422273"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX19wyCaMVb/vzg/Zvg0RueC2"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:F/zmCtEfXH9rTo7y87lA7d2NwkU=
In-Reply-To: <v5hr0e$1c0t$2@news.muc.de>
Content-Language: en-US
Bytes: 7915

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
> 

========== REMAINDER OF ARTICLE TRUNCATED ==========