Path: news.eternal-september.org!eternal-september.org!.POSTED!not-for-mail
From: Mikko <mikko.levanto@iki.fi>
Newsgroups: comp.theory
Subject: Re: DD correctly emulated by HHH --- Totally ignoring invalid rebuttals ---PSR---
Date: Tue, 11 Mar 2025 12:07:27 +0200
Organization: -
Lines: 193
Message-ID: <vqp20v$1too2$1@dont-email.me>
References: <vq5qqc$1j128$2@dont-email.me> <vqcvu3$34c3r$5@dont-email.me> <24c66a3611456f6a6969dc132fd8a227b26cbcbd@i2pn2.org> <vqdlqp$371bi$6@dont-email.me> <vqeceq$3epcg$1@dont-email.me> <vqf2bp$3j68u$4@dont-email.me> <vqh19v$2mh0$1@dont-email.me> <vqhj3n$5r7r$3@dont-email.me> <vqhm4q$6fo8$3@dont-email.me> <vqhs03$6vdc$5@dont-email.me> <vqig6a$bcd0$2@dont-email.me> <vqihd5$bcso$2@dont-email.me> <vqii7c$bcd0$4@dont-email.me> <vqiju2$bcso$4@dont-email.me> <f667993f66e38ce7610b933bbbf13508dfee1e23@i2pn2.org> <vqj1m3$ef0h$3@dont-email.me> <81f99208ab5ac8261e19355d54de31bb0ba8cdc6@i2pn2.org> <vqk4t4$o4oh$4@dont-email.me> <af6a3bd08f89f22772743f9e0946d5cb663ddbc4@i2pn2.org> <vqkqkk$sf7f$1@dont-email.me> <2c05662d218a25329eec1fb052e96758227d094c@i2pn2.org> <vql4uq$uv13$2@dont-email.me> <ce80c9dc3a24d0ab0257e871338b59945526b563@i2pn2.org> <vqll7i$11p4p$1@dont-email.me> <9e4fbf536ccba32198cd7e8f00605165347a10da@i2pn2.org> <vqmrs2$1ckgi$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 11 Mar 2025 11:07:27 +0100 (CET)
Injection-Info: dont-email.me; posting-host="567060c6ab1279f1a3853370f52a2405";
	logging-data="2024194"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX19+2SShbA4e3BcIcgtMm5Vn"
User-Agent: Unison/2.2
Cancel-Lock: sha1:LiL9bshW1159IkutHdbRy+V5kZA=

On 2025-03-10 14:10:10 +0000, olcott said:

> On 3/10/2025 6:04 AM, Richard Damon wrote:
>> On 3/9/25 11:10 PM, olcott wrote:
>>> On 3/9/2025 8:57 PM, Richard Damon wrote:
>>>> On 3/9/25 6:32 PM, olcott wrote:
>>>>> On 3/9/2025 4:43 PM, Richard Damon wrote:
>>>>>> On 3/9/25 3:36 PM, olcott wrote:
>>>>>>> On 3/9/2025 2:24 PM, Richard Damon wrote:
>>>>>>>> On 3/9/25 9:25 AM, olcott wrote:
>>>>>>>>> On 3/9/2025 6:17 AM, Richard Damon wrote:
>>>>>>>>>> On 3/8/25 10:24 PM, olcott wrote:
>>>>>>>>>>> On 3/8/2025 9:03 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/8/25 6:30 PM, olcott wrote:
>>>>>>>>>>>>> On 3/8/2025 5:01 PM, dbush wrote:
>>>>>>>>>>>>>> On 3/8/2025 5:47 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/8/2025 4:26 PM, dbush wrote:
>>>>>>>>>>>>>>>> On 3/8/2025 11:41 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/8/2025 9:01 AM, dbush wrote:
>>>>>>>>>>>>>>>>>> On 3/8/2025 9:09 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/8/2025 3:06 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2025-03-07 15:11:53 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>>> The code proves otherwise
>>>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> A program does not prove. In particular, it does not prove that no
>>>>>>>>>>>>>>>>>>>> different program exists.
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>> The source code 100% perfectly proves exactly what it
>>>>>>>>>>>>>>>>>>> actually does.
>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>> The source code contains a finite sequence of truth preserving steps 
>>>>>>>>>>>>>>>>>> between axioms and a statement?
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>> The source code 100% completely specifies every single detail
>>>>>>>>>>>>>>>>> of exactly what it does on each specific input.
>>>>>>>>>>>>>>>>> Saying that it does not do this is counter-factual.
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> In other words, the source code does not meet the definition of a 
>>>>>>>>>>>>>>>> proof, so your claim is false.
>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>> Dumb Bunny:
>>>>>>>>>>>>>>> *Proof[0] is anything that shows that X is necessarily true*
>>>>>>>>>>>>>>> *and thus impossibly false*
>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>> The source-code in Halt7.c combined with the input to HHH
>>>>>>>>>>>>>>> conclusively proves every detail of the behavior of HHH on
>>>>>>>>>>>>>>> this input. Disagreeing this is either foolish or dishonest.
>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> A proof is a finite sequence of truth preserving steps between the 
>>>>>>>>>>>>>> axioms of a system and a true statement that show the statement is true.
>>>>>>>>>>>>>> 
>>>>>>>>>>>>> 
>>>>>>>>>>>>> Proof[math] tries unsuccessfully to inherit from proof[0].
>>>>>>>>>>>>> I am stipulating that I have always been referring to proof[0].
>>>>>>>>>>>> 
>>>>>>>>>>>> And I am pointing out that it IS the same, it is just that you don't 
>>>>>>>>>>>> understand that "Show" implies FINITE.
>>>>>>>>>>>> 
>>>>>>>>>>> 
>>>>>>>>>>> In that single aspect you are correct.
>>>>>>>>>>> Show that X is definitely true and thus impossibly false
>>>>>>>>>>> by any means what-so-ever is not proof[math].
>>>>>>>>>> 
>>>>>>>>>> or proof[0], since you can not SHOW something "by any means" if those 
>>>>>>>>>> means are not showable due to not being finite.
>>>>>>>>>> 
>>>>>>>>>>> 
>>>>>>>>>>>> You are just proving your stupidity by repeating your disproved claim.
>>>>>>>>>>>> 
>>>>>>>>>>>>> 
>>>>>>>>>>>>> If you cannot understand the Halt7.c conclusively proves[0]
>>>>>>>>>>>>> the actual behavior of HHH(DD) this is merely your lack of
>>>>>>>>>>>>> understanding and nothing more.
>>>>>>>>>>>>> 
>>>>>>>>>>>>> 
>>>>>>>>>>>> 
>>>>>>>>>>>> Sure I can understand what it does, as Halt7.c shows that the behavior 
>>>>>>>>>>>> of the input is to HALT since that is what DD will do when main calls 
>>>>>>>>>>>> it.
>>>>>>>>>>>> 
>>>>>>>>>>> 
>>>>>>>>>>> *WHEN YOU UNDERSTAND THIS THEN YOU KNOW YOU WERE WRONG*
>>>>>>>>>>> DD correctly emulated by HHH cannot possibly reach
>>>>>>>>>>> its own "ret" instruction and terminate normally
>>>>>>>>>>> because DD calls HHH(DD) in recursive emulation.
>>>>>>>>>>> 
>>>>>>>>>>> 
>>>>>>>>>> 
>>>>>>>>>> But The HHH You are talking about doesn't do a correct simulation, so 
>>>>>>>>>> this statment is not applicable.
>>>>>>>>>> 
>>>>>>>>> 
>>>>>>>>> 
>>>>>>>>> _DD()
>>>>>>>>> [00002133] 55         push ebp      ; housekeeping
>>>>>>>>> [00002134] 8bec       mov ebp,esp   ; housekeeping
>>>>>>>>> [00002136] 51         push ecx      ; make space for local
>>>>>>>>> [00002137] 6833210000 push 00002133 ; push DD
>>>>>>>>> [0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
>>>>>>>>> [00002141] 83c404     add esp,+04
>>>>>>>>> [00002144] 8945fc     mov [ebp-04],eax
>>>>>>>>> [00002147] 837dfc00   cmp dword [ebp-04],+00
>>>>>>>>> [0000214b] 7402       jz 0000214f
>>>>>>>>> [0000214d] ebfe       jmp 0000214d
>>>>>>>>> [0000214f] 8b45fc     mov eax,[ebp-04]
>>>>>>>>> [00002152] 8be5       mov esp,ebp
>>>>>>>>> [00002154] 5d         pop ebp
>>>>>>>>> [00002155] c3         ret
>>>>>>>>> Size in bytes:(0035) [00002155]
>>>>>>>> 
>>>>>>>> WHich is *NOT* a program, as it has an external reference.
>>>>>>>> 
>>>>>>>>> 
>>>>>>>>> *When we assume that HHH emulates N steps of DD then*
>>>>>>>>> 
>>>>>>>>> DD correctly emulated by HHH cannot possibly reach
>>>>>>>>> its own "ret" instruction and terminate normally
>>>>>>>>> because DD calls HHH(DD) in recursive emulation.
>>>>>>>> 
>>>>>>>> Wrong, because emulaiting for "N Steps" is NOT correctly emulation.
>>>>>>>> 
>>>>>>> 
>>>>>>> Correctly emulating N steps is emulating N steps correctly.
>>>>>> 
>>>>>> Which is only partially emulating it correctly, and only partially 
>>>>>> correct is incorrect.
>>>>>> 
>>>>>>> 
>>>>>>> Everyone here that has sufficient technical competence can
>>>>>>> see that for any N steps of DD correctly emulated by HHH
>>>>>>> that DD cannot possibly reach its own final state and
>>>>>>> terminate normally.
>>>>>>> 
>>>>>>> 
>>>>>> 
>>>>>> So? As has been pointed out, since HHH can't do enough steps to get to 
>>>>>> the actual answer, it never CORRECTLY emulated the input enough to get 
>>>>>> the answer if it aborts.
>>>>>> 
>>>>> 
>>>>> If HHH can see the same pattern that every competent
>>>>> programmer sees then HHH does not need to emulate DD
>>>>> more than twice to know that HHH cannot possibly reach
>>>>> its own final state and terminate normally.
>>>>> 
>>>> 
>>>> 
>>>> The pattern that HHH sees is IDENTICAL to the pattern that HHH1 saw, up 
>>>> to the point it aborts.
>>>> 
>>> 
>>> In other words you do not believe that HHH can see what
>>> every competent programmer sees.
>>> 
>> 
>> The problem is that what "Every Competent Programmer" will see what I 
>> described, that since HHH aborts and returns 0, that DD will reach the 
>> return.
>> 
> 
> typedef void (*ptr)();
> int HHH(ptr P);
> 
> int DD()
> {
>    int Halt_Status = HHH(DD);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
> 
> int main()
> {
>    HHH(DD);
> }
> 
> When their only knowledge of HHH is that HHH emulates
========== REMAINDER OF ARTICLE TRUNCATED ==========